排序算法合集（C++实现）

摘要

排序操作在程序设计中是非常基础和常见的，也是算法的基础部分，我对几种常见的比较排序算法进行了整理。

暴力排序(violence sort)

思想：遍历数组，每次遍历都在未排序的部分找到最小元素的下标，在此次遍历结束后将最小元素放到遍历开始的位置。

性能：时间复杂度为O(n²)，算法比较次数与初始序列状态无关，性能在所有排序算法中最差。

void Violence_Sort(int* A, int len){
        for(int i=0;i<len;i++)
        {
                int k = i;
                for(int j=i;j<len;j++)
                        if(A[j]<A[k])
                                k = j;
                if(k != i){
                        int t = A[i];
                        A[i] = A[k];
                        A[k] = t;
                }
        }
}

插入排序（insert sort）

思想： 将当前元素与它前面已排好序的元素依次进行比较，最后放置在合适的位置，初始时可从第二个元素开始，认为第一个元素已排好序。

性能：算法时间复杂度为O(n²)，在序列规模较小时，性能比较好，且元素比较次数与初始序列杂乱程度相关，最优复杂度为O(n)。

void Insert_Sort(int* A, int len){
        for(int i=1;i<len;i++)
        {
                int key = A[i];
                int j = i - 1;
                while(j >= 0 && key  < A[j]){
                        A[j+1] = A[j];
                        j--;
                }
                A[j+1] = key;
        }
}

冒泡排序（bubble sort） 

思想：从左往右遍历，比较相邻两个元素的大小，将大的一个放在后面，每遍历一趟，可找到一个最大值放置在最后，经过n-1趟遍历即可。

性能：时间复杂度为O(n²)，元素比较次数与初始状态无关，性能略低于插入排序。

void Bubble_Sort(int* A,int len){
        for(int i=1;i<len;i++)
                for(int j=0;j<len-i;j++)
                {
                        if(A[j]>A[j+1]){
                                int t = A[j+1];
                                A[j+1] = A[j];
                                A[j] = t;
                        }
                }
}

归并排序（merge sort)

思想：使用分治思想，将原始序列分为两部分分别排序，然后合并，重点在于合并过程。

性能：时间复杂度为O(nlgn)，不过合并过程会使用额外的存储空间，占用内存。

void Merge(int* A, int low, int mid, int high){
        int left[mid-low+1],right[high-mid];
        int sentry = A[mid]>A[high]?(A[mid]+1):(A[high]+1);
        int l = 0;
        int r = 0;
        int i;
        for(i=0;i<mid-low+1;i++)
                left[i] = A[low+i];
        left[i] = sentry;//添加哨兵
        for(i=0;i<high-mid;i++)
                right[i] = A[mid+1+i];
        right[i] =  sentry;//添加哨兵
        for(int i=low;i<=high;i++)
                if(left[l] <= right[r])
                        A[i] = left[l++];
                else
                        A[i] = right[r++];
}

void Merge_Sort(int* A, int low, int high){
        if(high > low){
                int mid = (low+high)/2;
                Merge_Sort(A, low, mid);
                Merge_Sort(A, mid+1, high);
                Merge(A, low, mid, high);
        }
}

快速排序（quick sort)

思想：与归并排序类似，也使用分治思想，选择一个元素值（一般选择最后一个元素），将比它小的放在左边部分，比它大的放在右边，然后对两部分分别进行上述操作知道递归结束，关键步骤在于元素的分类，且只占用O(1)的额外存储空间。

性能：时间复杂度为O(nlgn)，与归并排序不同，该算法占用常数级额外存储，在大规模序列排序应用中性能较好。

int Partition(int* A, int low, int high){
        int key = A[high];
        int i = low;
        for(int j=low;j<high;j++)
                if(A[j]<=key){
                        int t = A[j];
                        A[j] = A[i];
                        A[i] = t;
                        i++;
                }
        A[high] = A[i];
        A[i] = key;
        return i;
}//对数组元素进行移位分类，key的左边都<=key，右边都>key。返回key的下标。


void Quick_Sort(int* A, int low, int high){
        if(low >= high)
               return;
        int k = Partition(A, low, high);
        Quick_Sort(A, low, k-1);
        Quick_Sort(A, k+1, high);
}

堆排序（heap sort）

思想：使用堆数据结构进行排序，堆是一种用数组存储的二叉树，根据父节点和子节点的大小关系分为最大堆和最小堆，这里使用最大堆进行排序。

性能：时间复杂度为O(nlgn)，在实际使用中，堆排序的排序性能通常逊与快速排序。

void Max_Heapify(int* A, int i,int size){
        int l = 2*i;
        int r = 2*i + 1;
        int large = i;
        if(l <= size && A[l] > A[i])
                large = l;
        else
                large = i;
        if(r <= size && A[r] > A[large])
                large = r;
        if(large != i){
        int t = A[large];
        A[large] = A[i];
        A[i] = t;
        Max_Heapify(A, large, size);
        }
}

void Build_Max_Heap(int* A, int size){
        for(int i=size/2;i>0;i--)
                Max_Heapify(A,i,size);
}
  
void Heap_Sort(int* A, int len){
        Build_Max_Heap(A, len);
        while(len-1){
                int t = A[1];
                A[1] = A[i];
                A[i] = t;
                len--;
                Max_Heapify(A,1,len);
        }
}