数据结构复习笔记 ------- 排序

知识点1：	插入排序： 插入排序的主要操作是插入，其基本思想是：每次将一个待排序的记录按其关键码的大小插入到一个已经排好序的有序序列中，直到全部记录排好序为止
	直接插入排序： 初始序列：【65】 23  12  86  23  29   第一趟：【23  65】 12  86  23  29   第二趟：【12  23  65】 86  23  29   第三趟：【12  23  65  86】 23  29   第四趟：【12  23  23  65  86】 29   第五趟：【12  23  23  29  65  86】
	算法： void  insertSort (int  r[ ], int n) {    for (i=2; i<=n; i++)    {        r[0]=r[i]; j=i-1;        while (r[0]<r[j])        {              r[j+1]=r[j];  j=j-1;         }        r[j+1]=r[0];     } }	1、执行n-1趟 2、空间性能O（1） 3、时间性能： 平均：T(n)=O(n2) 4、稳定性：稳定
知识点2：	希尔排序 基本思想：将整个待排序记录分割成若干个子序列，在子序列内分别进行直接插入排序，待整个序列中的记录基本有序时，对全体记录进行直接插入排序。
	初始序列 23 56 34 10 80 65 38 24 23 59 66 第一趟 d=n/2=5 23 38 24 10 59 65 56 34 23 80 66 第二趟 d=d/2=2 23 10 23 34 24 38 56 65 59 80 66 第三趟 d=d/2=1 10 23 23 24 34 38 56 59 65 66 80
	1、空间性能：O(1) 2、时间性能：O(nlog2n)~ O(n2)，平均为O(n1.3 ) 3、不稳定
知识点3：	交换排序： 交换排序的主要操作是交换，其主要思想是：在待排序列中选两个记录，将它们的关键码相比较，如果反序（即排列顺序与排序后的次序正好相反），则交换它们的存储位置。
	起泡排序 基本思想：两两比较相邻记录的关键码，如果反序则交换，直到没有反序的记录为止。
	起泡排序过程： 初始序列：29  12  86  23  23  95   第一趟：12  29  23  23  86 【95】   第二趟：12  23  23  29 【86  95】   第三趟：12  23  23 【29  86  95】   第四趟：12  23 【23  29  86  95】   第五趟：12 【23  23  29  86  95】			改进的起泡排序过程： 初始序列：29  12  86  23  23  95   第一趟：12  29  23  23 【86  95】   第二趟：12  23  23 【29  86  95】   第三趟：【12  23  23  29  86  95】
	最好、最坏、平均的时间性能O(n2) 空间性能：O(1)			1、时间性能： 平均：O(n2) 2、空间性能：O（1） 3、稳定的排序算法
	改进的起泡排序算法 void BubbleSort(int r[ ], int n)  {     exchange=n;     while (exchange)     {         bound=exchange;         exchange=0；           for (j=1; j<bound; j++)              if (r[j]>r[j+1]) {                 r[j]←→r[j+1]；       exchange=j；             }      }  }
知识点4：	快速排序 首先选一个轴值（即比较的基准），通过一趟排序将待排序记录分割成独立的两部分，前一部分记录的关键码均小于或等于轴值，后一部分记录的关键码均大于或等于轴值，然后分别对这两部分重复上述方法，直到整个序列有序。
	初始序列： 29 12 86 23 23 95 46 70 第一趟： 23 12 23 [29] 86 95 46 70 第二趟： 12 [23] 23 [29] 70 46 [86] 95 第三趟： [12] [23] [23] [29] 46 [70] [86] [95]
	1、时间性能： 最好：O（nlog2n）；最坏：O(n2)；平均：O(n2)； 2、空间性能O（log2n）~O（n2） 3、不稳定 4、快速排序在有序的情况下最不利于发挥长处。
知识点5：	选择排序 选择排序的主要操作是选择，其主要思想是：每趟排序在当前待排序序列中选出关键码最小的记录，添加到有序序列中。
	简单选择排序 初始序列 34 67 54 19 6 49 34 第一趟 [6] 67 54 19 34 49 34 第二趟 [6 19] 54 67 34 49 34 第三趟 [6 19 34] 67 54 49 34 第四趟 [6 19 34 34] 54 49 67 第五趟 [6 19 34 34 49] 54 67 第六趟 [6 19 34 34 49 54] 67
	void  selectSort ( int  r[ ], int n) {        for ( i=1; i<n; i++)     {           index=i;         for (j=i+1; j<=n; j++)            if  (r[j]<r[index])  index=j;         if (index!=i)   r[i]<==>r[index];       } }		1、时间性能： 平均：T（n）=O(n2) 2、空间性能：O(1) 3、不稳定
知识点6：	堆排序 1堆是具有下列性质的完全二叉树： 2每个结点的值都小于或等于其左右孩子结点的值（称为小根堆），或每个结点的值都大于或等于其左右孩子结点的值（称为大根堆）。 3. 小根堆的根结点是所有结点的最小者。（大根堆同理） 4. 较小（较大）结点靠近根结点，但不绝对。
初始建堆	1、筛选法建堆 2、初始建堆时间性能：O（nlog2n） 3、升序排序要建大根堆
堆排序	1、最好、最坏、平均时间性能：初始建堆+堆排序=O(nlog2n)+ O(nlog2n)= O(nlog2n) 2、空间性能：O(1) 3、不稳定

知识点:7：	归并排序 归并排序的主要操作是归并，其主要思想是：将若干有序序列逐步归并，最终得到一个有序序列。
	二路归并：将两个有序序列合并成一个有序序列的过程。
	初始序列 [34] [11] [98] [45] [29] [67] [78] [91] [34] [33] [20] [63] [30] 第一趟 [11 34] [45 98] [29 67] [78 91] [33 34] [20 63] [30] 第二趟 [11 34 45 98] [29 67 78 91] [20 33 34 63] [30] 第三趟 [11 29 34 45 67 78 91 98] [20 30 33 34 63] 第四趟 [11 20 29 30 33 34 34 45 63 67 78 91 98]
	一次归并 void Merge (int r[ ], int r1[ ], int s, int m, int t ) {     i=s;   j=m+1;   k=s;     while (i<=m && j<=t)     {            if (r[i]<=r[j])  r1[k++]=r[i++];         else  r1[k++]=r[j++];      }      if (i<=m)  while (i<=m)                                          r1[k++]=r[i++];          else  while (j<=t)                   r1[k++]=r[j++];              }
	一趟归并 void  MergePass (int  r[ ], int  r1[ ], int  n, int  h) {      i=1;      while (i≤n-2h+1)                //情况1      {            Merge (r, r1, i, i+h-1, i+2*h-1);            i+=2*h;       }       if (i＜n-h+1) Merge (r, r1, i, i+h-1, n);   //情况2       else for (k=i; k<=n; k++)    //情况3                  r1[k]=r[k]; }

	归并排序 void  MergeSort (int r[ ], int r1[ ], int n ) {     h=1;     while (h<n)     {          MergePass (r, r1, n, h);          h=2*h;          MergePass (r1, r, n, h);          h=2*h;     } }
	1、时间复杂度： 2、空间复杂度：O(n) 3、稳定的排序算法
知识点8：	排序方法 平均情况 最好情况 最坏情况 空间性能 稳定性 直接插入排序 O(n2) O(n) O(n2) O(1) 稳定 希尔排序 O(nlog2n) O(n1.3) O(n2) O(1) 不稳定 起泡排序 O(n2) O (n) O(n2) O(1) 稳定 快速排序 O(nlog2n) O(nlog2n) O(n2) O(log2n)~ O(n) 不稳定 简单选择排序 O(n2) O(n2) O(n2) O(1) 不稳定 堆排序 O(nlog2n) O(nlog2n) O (nlog2n) O(1) 不稳定 归并排序 O(nlog2n) O(nlog2n) O(nlog2n) O(n) 稳定