排序算法复习

一、排序（一）

1. 冒泡排序 Bubble Sort O(N^2) 稳定排序算法

void bubble_sort1(int a[], int n)//n是数组长度
{
    int i, j;
    int flag;

    for(i=n-1;i>0;i--)
    {
        flag=0;//初始化标记为0
        for(j=0;j<i;j--)
        {
              if(a[j]>a[j+1])
                  swag(a[j], a[j+1]);
                  flag=1;
        }
        if(flag==0)
            break;

    }
}

2. 快排 Quick Sort O(N*lgN) 最坏情况O(N^2) 非稳定排序算法

void quick_sort(int a[], int l, int r)
{
    if (l<r)
    {
        int i,j,x;//x为基准值

        i=l;
        j=r;
        x=a[i];
        while(i<j) {
            while (i < j && a[j] > x)
                j--;//从右向左找第一个小于x的数
            if (i < j)
                a[i++] = a[j];
            while (i < j && a[i] < x)
                i++;
            if (i < j)
                a[j--] = a[i];
        }
        a[i]=x;
        quick_sort(a,l,i-1);//对小于基准部分进行快速排序递归调用
        quick_sort(a,i+1,r);//对大于基准部分进行快速排序递归调用
    }
}

3. 直接插入排序 Straight Insertion Sort  O(N^2)  稳定排序算法

void insert_sort(int a[], int n)
{
    int i,j,k;

    for(i=1;i<n;i++){
        for(j=i-1;j>=0;j--)
            if(a[j]<a[i])
                break;
        if(j!=i-1)
        {
            //将比a[i]大的数据向后移
            int temp=a[i];
            for(k=i-1;k>j;k--)
                a[k+1]=a[k];
            //将a[i]放到正确位置
            a[k+1]=temp;
        }
    }
}

4. 希尔排序（缩小增量排序) Shell Sort 不稳定

void shell_sort1(int a[], int n)
{
    int i, j, gap;
    //gap为步长，每次减少为原来的一半
    for(gap=n/2;gap>0;gap/=2)
    {
        //共gap个分组，对每一组执行直接插入排序
        for(i=0;i<gap;i++)
        {
            for(j=i+gap;j<n;j+=gap)
            {
                //如果a[j]<a[j-gap],则寻找a[j]位置，并将后面数据的位置都后移
                if(a[j]<a[j-gap])
                {
                    int tmp=a[j];
                    int k=j-gap;
                    while(k>=0&&a[k]>tmp)
                    {
                        a[k+gap]=a[k];
                        k-=gap;
                    }
                    a[k+gap]=tmp;
                }
            }
        }
    }
}

5. 选择排序 Select Sort O(N^2)  稳定排序算法

void select_sort(int a[], int n)
{
    int i;//有序区的末尾位置
    int j;//无序区的起始位置
    int min;//无序区中最小元素位置
    
    for(i=0;i<n;i++){
        min=i;
        //找出a[i+1]到a[n]之间的最小元素，并赋值给min;
        for(j=i+1;j<n;j++)
        {
            if(a[j]<a[min])
                min=j;
        }
        
        //若min!=i, 则交换a[i]和a[min]
        //交换之后，保证了a[0]...a[i]之间的元素是有序的
        if(min!=i)
            swap(a[i], a[min]);
    }
}