排序算法

推荐：https://blog.csdn.net/xiazdong/article/details/8462393

 

一 冒泡排序

冒泡排序的名字很形象，实际实现是相邻两节点进行比较，大的向后移一个，经过第一轮两两比较和移动，最大的元素移动到了最后，第二轮次大的位于倒数第二个，依次进行。

    void bubble_sort (int a[], int n) {
        int i, j, lastSwap, tmp;
        for (j=n-1; j>0; j=lastSwap) {        lastSwap=0;     //每一轮要初始化为0，防止某一轮未发生交换，lastSwap保留上一轮的值进入死循环
            for (i=0; i<j; i++) {
                if (a[i] > a[i+1]) {
                    tmp=a[i];
                    a[i]=a[i+1];
                    a[i+1]=tmp;
       //最后一次交换位置的坐标
                    lastSwap = i;
                }
            }
        }
    }

优化：某一轮结束位置为j，但是这一轮的最后一次交换发生在lastSwap的位置，则lastSwap到j之间是排好序的，下一轮的结束点就不必是j--了，而直接到lastSwap即可

 

二 插入排序

插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

                                   

void InsertSortArray(int[] arr ,int n)
{
for(int i=1;i<n;i++)//循环从第二个数组元素开始，因为arr[0]作为最初已排序部分
{
    int temp=arr[i];//temp标记为未排序第一个元素
    int j=i-1;
while (j>=0 && arr[j]>temp)/*将temp与已排序元素从小到大比较，寻找temp应插入的位置*/
{
    arr[j+1]=arr[j];
    j--;
}
arr[j+1]=temp;
}
}

 

三 快速排序

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）

•     从数列中挑出一个元素，称为 “基准”（pivot）；
•     重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
•     递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

    int mpartition(int a[], int l, int r) {
        int pivot = a[l];
     
        while (l<r) {
            while (l<r && pivot<=a[r]) r--;
            if (l<r) a[l++]=a[r];
            while (l<r && pivot>a[l]) l++;
            if (l<r) a[r--]=a[l];
        }
        a[l]=pivot;
        return l;
    }
     
    void quick_sort (int a[], int l, int r) {
     
        if (l < r) {
            int q = mpartition(a, l, r);
            msort(a, l, q-1);
            msort(a, q+1, r);
        }
    }

四 选择排序

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

  void selection_sort (int a[], int n) {
        int i,j,pos,tmp;
        for (i=0; i<n-1; i++) {   //寻找最小值的下标
            for (pos=i, j=i+1; j<n; j++)
                if (a[pos]>a[j])
                    pos=j;
            if (pos != i) {
                tmp=a[i];
                a[i]=a[pos];
                a[pos]=tmp;
            }
        }
    }

五 希尔排序

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

                   

    void shell_sort(int a[], int n)
    {
        int d, i, j, temp; //d为增量
        for(d = n/2;d >= 1;d = d/2) //增量递减到1使完成排序
        {
            for(i = d; i < n;i++)   //插入排序的一轮
            {
                temp = a[i];
                for(j = i - d;(j >= 0) && (a[j] > temp);j = j-d)
                {
                    a[j + d] = a[j];
                }
            a[j + d] = temp;
            }
        }
    }

 

六 归并排序

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

         

 

void mergearray(int a[], int first, int mid, int last, int temp[])
{
    int i = first, j = mid + 1;
    int m = mid,   n = last;
    int k = 0;
 
    while (i <= m && j <= n)
    {
        if (a[i] <= a[j])
            temp[k++] = a[i++];
        else
            temp[k++] = a[j++];
    }
 
    while (i <= m)
        temp[k++] = a[i++];
 
    while (j <= n)
        temp[k++] = a[j++];
 
    for (i = 0; i < k; i++)
        a[first + i] = temp[i];
}
void merge_sort(int a[], int first, int last, int temp[])
{
    if (first < last)
    {
        int mid = (first + last) / 2;
        merge_sort(a, first, mid, temp);    //左边有序
        merge_sort(a, mid + 1, last, temp); //右边有序
        mergearray(a, first, mid, last, temp); //再将二个有序数列合并
    }
}

 

七 堆排序

堆排序是把数组看作堆，第i个结点的孩子结点为第2*i+1和2*i+2个结点（不超出数组长度前提下），堆排序的第一步是建堆，然后是取堆顶元素 然后调整堆。建堆的过程是自底向上不断调整达成的，这样当调整某个结点时，其左节点和右结点已经是满足条件的，此时如果两个子结点不需要动，则整个子树不 需要动，如果调整，则父结点交换到子结点位置，再以此结点继续调整。

      下述代码使用的大顶堆，建立好堆后堆顶元素为最大值，此时取堆顶元素即使堆顶元素和最后一个元素交换，最大的元素处于数组最后，此时调整小了一个长度的堆，然后再取堆顶和倒数第二个元素交换，依次类推，完成数据的非递减排序。

      堆排序的主要时间花在初始建堆期间，建好堆后，堆这种数据结构以及它奇妙的特征，使得找到数列中最大的数字这样的操作只需要O(1)的时间复杂度，维护需要logn的时间复杂度。堆排序不适宜于记录数较少的文件。

    

void heapAdjust(int a[], int i, int nLength)
{
    int nChild;
    int nTemp;
    for (nTemp = a[i]; 2 * i + 1 < nLength; i = nChild)
    {
        // 子结点的位置=2*（父结点位置）+ 1
        nChild = 2 * i + 1;
        // 得到子结点中较大的结点
        if ( nChild < nLength-1 && a[nChild + 1] > a[nChild])
            ++nChild;
        // 如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点
        if (nTemp < a[nChild])
        {
            a[i] = a[nChild];
            a[nChild]= nTemp;
        }
        else
        // 否则退出循环
            break;
    }
}
 
// 堆排序算法
void heap_sort(int a[],int length)
{
    int tmp;
    // 调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素
    //length/2-1是第一个非叶节点，此处"/"为整除
    for (int i = length / 2 - 1; i >= 0; --i)
        heapAdjust(a, i, length);
    // 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
    for (int i = length - 1; i > 0; --i)
    {
        // 把第一个元素和当前的最后一个元素交换，
        // 保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
      ///  Swap(&a[0], &a[i]);
          tmp = a[i];
          a[i] = a[0];
          a[0] = tmp;
        // 不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值
        heapAdjust(a, 0, i);
    }
}

转载：

https://blog.csdn.net/zhangshk_/article/details/82911093

https://blog.csdn.net/ccblogger/article/details/82384480