数据结构-排序

思维导图

1.插入排序

1.1 直接插入排序

基本思想：将一个待排序的数从后往前插入到一个匹配好的子序列中。

实现代码片

for(i = 1;i < 5;i++){
        temp = a[i];
    for( j =i-1;j >= 0;j--){
             if(a[j] > temp)
              a[j+1] = a[j];//在有序列表中比temp值大的元素后移
              else break;
    }
    a[j+1] = temp;
}

●最好情况O(n),表中元素已经有序，每插入一个元素，只需要比较一次，且不需要移动元素。
●平均情况O(n²)
●是一个稳定算法
●适用于顺序存储和链式存储的顺序表。
●空间复杂度O(1)

1.2希尔排序

基本思想：将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

实现代码片

void ShellInsertSort(int a[], int n, int dk)
{
	for(int i= dk; i<n; ++i){
		if(a[i] < a[i-dk]){			//若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入
			int j = i-dk;	
			int x = a[i];			//复制为哨兵，即存储待排序元素
			a[i] = a[i-dk];			//首先后移一个元素
			while(x < a[j]){		//查找在有序表的插入位置
				a[j+dk] = a[j];
				j -= dk;			 //元素后移
			}
			a[j+dk] = x;			//插入到正确位置
		}
	}	
}

●n在一定范围是，时间复杂度为O(n1.3)
●仅适用于线性表为顺序存储的情况。
●空间复杂度O(1)

2.交换排序

2.1冒泡排序

基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

实现代码片

  for(int i = 0;i < 5;i++){//冒泡
        for(int j  =0; j< 5-i-1;j++){
            if(a[j]> a[j+1])
                swap(a[j], a[j+1]);
       }
    }

●最好情况O(n),表中元素已经有序，只需要比较一次，且不需要移动元素。
●平均情况O(n²)
●是一个稳定算法
●空间复杂度O(1)

2.2快速排序

基本思想：1）选择一个基准元素,通常选择第一个元素或者最后一个元素,
2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
3）此时基准元素在其排好序后的正确位置
4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

实现代码片

void QuickSort(int a[],int left,int right){

    if(left >= right)
        return;
        int l = left;
    int r = right;
    int temp = a[l];
    while(l<r){
        while(l < r&&a[r] >= temp){
            r--;
        }
        a[l] = a[r];
        while(l < r&&a[l] <= temp){
            l++;
        }
        a[r] = a[l];
    }          
 a[l] = temp;
    QuickSort(a, left, l-1);
     QuickSort(a, l+1, right);
}

●最好情况O(nlog2n)
●平均情况O(nlog2n)
●最坏情况O(n²)
●不是一个稳定算法
●空间复杂度O(log2n)

3.选择排序

3.1 简单选择排序

基本思想：在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

实现代码片

for(i =0; i <4;i++){
        int m =i;
    for(j=i+1;j<5:j++){
        if(a[j] < a[m])
        m = j;
    }
if(m != i)
    swap(a[i],a[m]);
}

●最好情况O(n²)
●最坏情况O(n²)
●不是一个稳定算法
●空间复杂度O(1)

3.2 堆排序

基本思想：初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。
（a）大顶堆序列：（96, 83,27,38,11,09)
(b) 小顶堆序列：（12，36，24，85，47，30，53，91）

插入时，新结点放在堆末，再进行调整。
对于最小堆和最大堆而言，删除是针对于根节点而言，对于删除操作，将二叉树的最后一个节点替换到根节点，然后自顶向下，递归调整。
●最好情况O(nlog2n)
●平均情况O(nlog2n)
●不是一个稳定算法
●空间复杂度O(1)

4.归并排序

基本思想：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

实现代码片

void mergesort1(int left,int mid,int right){
      int I = left; int j = mid+1; int k = left; 
         while(I <= mid && j <= right) {
              if(a[i] > a[j]) {
               b[k++] = a[j++]; 
               } else 
                 b[k++] = a[i++]; 
         } 
         while(I <= mid) {
            b[k++]=a[i++];
          }
            while(j <= right) { 
               b[k++]=a[j++]; 
            } 
             t = 0;
        //将b中的元素全部拷贝到原数组中
        while(left <= right){
            a[left++] = b[t++];
        }
}
void mergesort(int left,int right) {
           int mid;
           if(left < right){ 
                mid=(left+right);
                mergesort(left,mid); //左                
                mergesort(mid+1,right); //右               
                mergesort1(left,mid,right);//二路归并 
           } 
}

●最好情况O(nlog2n)
●平均情况O(nlog2n)
●不是一个稳定算法
●空间复杂度O(n)