九、排序

一、基本概念：

假设含有n个记录的序列为{r1,r2,……rn},其相对应的关键字分别为{k1,k2,……kn},需确定1，2，……n的一种排列P1,P2,……Pn,使其对应的关键字满足Kp1 <= Kp2<=…<=Kpn(非递减或非递增)关系，即是的序列成为一个按关键字有序的序列{Rp1，Rp2，……,Rpn},这样的操作称为排序。
1、排序的稳定性:假设ki = kj（1<=i<=n,1<=j<=n,n!=j）,且在排序前的序列中Ri领先于rj(即i<j)。如果排序后Ri任领先rj，则称所用的排序方法是稳定的；反之，若可能使得排序后的序列中rj领先ri，则称所用的排序方法是不稳定的。
2、根据再排序过程中待排序的记录是否全部被放置在内存中，排序分为：内排序和外排序；
内排序：再排序整个过程中，待排序的记录是否全部被放置再内存中，
外排序：由于排序的几率个数太多，不能同时放置在内存，整个排序过程需要在内外存之间多次狡猾数据才能进行。
这里主要介绍内排序的多种方法。
对于内拍戏来说，排序算法的性能主要受三个方面影响:
1、时间性能：比较、移动（越少越好）
2、辅助空格键
3、算法的复杂性：算法本身的复杂度，不是时间复杂度

二、冒泡排序算法（Bubble Sort）：

1、基本思想：是一种交换排序，基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。
C#代码如下：

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  
  namespace ConsoleApp1
  {
   class Program
   {
   static void Main(string[] args)
   {
   int[] sort = { 16, 2, 5, 8, 6, 22, 15 };
   Sort(sort);
  
   for (int i = 0; i < sort.Length ; i++)
   {
   Console.WriteLine(sort[i].ToString());
   }
  
   Console.ReadKey();
   }
   /// <summary>
   /// 冒泡排序
   /// </summary>
   /// <param name="sort"></param>
   public static void Sort(int[] sort)
   {
  
   bool flag = true;//标记和后面是否产生数据交换
   for (int i = 0; i < sort.Length && flag ; i++) //flag 为false则表示后面已经有序，结束循环
   {
   flag = false;
   for (int j = sort.Length - 2; j >= i; j--)
   {
   if (sort[j] > sort[j + 1])
   {
   Swap(sort,j, j + 1);
   flag = true;
   }
   }
   }
   }
   /// <summary>
   /// 交换数组内的两个数
   /// </summary>
   /// <param name="i"></param>
   /// <param name="j"></param>
   public static void Swap(int[] dataArray, int i, int j)
   {
   int m = dataArray[i];
   dataArray [i] = dataArray[j];
   dataArray[j] = m;
   }
  
   }
  
  
  
  }

2、时间复杂度：O（n^2）;

三、简单选择排序算法（Simple Selection Sort）：

1、定义：就是通过n - i次关键字间的比较，从n - I + 1个记录中选出最小的记录，并和第i（1 <= I <= n）个记录交换之。
C#代码实现：

 using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  
  namespace JianDanXuanZe
  {
   class Program
   {
   static void Main(string[] args)
   {
   int[] array = { 5, 8, 1, 6, 3, 12 };
   Sort(array);
  
   for (int i = 0; i < array.Length; i++)
   {
   Console.WriteLine(array[i]);
   }
   Console.ReadKey();
  
  
   }
   public static void Sort(int[] array)
   {
   for (int i = 0; i < array.Length; i++)
   {
   int min = i;//最小值下标
   for (int j = i + 1; j < array.Length; j++)
   {
   if (array[j] < array[min]) //如果有小于当前最小值，将下标的值赋给min
   min = j;
   }
   if (min != i)//min！= i，说明找到最小值
   {
   Swap(array, i, min);//交换下标为min和i的数据
   }
   }
   }
  
   /// <summary>
   /// 交换数组内的两个数
   /// </summary>
   /// <param name="i"></param>
   /// <param name="j"></param>
   public static void Swap(int[] dataArray, int i, int j)
   {
   int m = dataArray[i];
   dataArray[i] = dataArray[j];
   dataArray[j] = m;
   }
   }
  }

2、时间复杂度：O（n^2）;
尽管与冒泡排序同为O(n^2)，但简单选择排序的性能上还是略优于冒泡排序。

四、直接插入排序（Straight Insertion Sort）：

1、定义：将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。
C#代码实现：

 using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  
  namespace InsertSort
  {
   /// <summary>
   /// 简单插入排序
   /// </summary>
   class Program
   {
   static void Main(string[] args)
   {
   int[] array = { 2, 15, 3, 56, 10, 166 };
   InsertSort(array);
   for (int i = 0; i < array.Length; i++)
   {
   Console.WriteLine(array[i].ToString());
   }
   Console.ReadKey();
   }
  
   /// <summary>
   /// 插入算法
   /// </summary>
   /// <param name="dataArray"></param>
   public static void InsertSort(int[] dataArray)
   {
   for (int i = 1; i < dataArray.Length; i++)
   {
   //要插入的值
   int ivalue = dataArray[i];
   //标志位 用来确定要插入的值是否为要插入区域的最小值
   bool isInsert = false;
  
   for (int j = i - 1; j >= 0; j--)
   {
   //如果当前值比要插入的值大那么该当前值进行后移
   if (dataArray[j] > ivalue)
   {
   dataArray[j + 1] = dataArray[j];//后移一位
  
   }
   else//否则的话就是当前值小于或者等于要插入的值，因为该方法进行元
   //素后移时是直接进行赋值所以进入else时就应该把当前元素的后一个元素赋值为要插入的值
   {
   dataArray[j + 1] = ivalue;
   isInsert = true;
   break;
   }
   }
  
   if (isInsert == false)
   {
   //将要插入的值插入到首位
   dataArray[0] = ivalue;
   }
   }
   }
  
  
   }
  }

2、时间复杂度：O（n^2）;
尽管与同为O(n^2)，但插入排序的性能上还是略优于冒泡排序和简单选择排序。

五、希尔排序（Shell Sort）：

1、基本有序：就是小的关键字基本在前面大的基本在后面，不大不小的在中间，像{2，1，3，6，4，7，5，8，9}这样就可以称为基本有序。
2、概念:先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量
C#代码实现：

 using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  
  namespace ShellSort
  {
   class Program
   {
   static void Main(string[] args)
   {
   int[] array = { 26, 16, 19, 156, 159, 18, 161, 1, 9, 15, 61 };
   ShellSort(array);
   foreach (int i in array) {
   Console.WriteLine(i.ToString());
   }
   Console.ReadKey();
   }
   /// <summary>
   /// 希尔排序
   /// </summary>
   /// <param name="array"></param>
   public static void ShellSort(int[] array)
   {
   int i, j, increment;
   int temp;
   for (increment = array.Length / 2; increment > 0; increment /= 2)
   {
   for (i = increment; i < array.Length; i++)
   {
   temp = array[i];
   for (j = i; j >= increment; j -= increment)
   {
   if (temp < array[j - increment])
   array[j] = array[j - increment];
   else
   break;
   }
   array[j] = temp;
   }
   }
   }
   }
  
  }

3、时间复杂度：O(n^ 3/2);需注意增量的最后一个增量值必须等于1；
由于记录是跳跃式的移动，所以希尔排序并不稳定。

六、堆排序（Heap Sort）：

1、堆：堆是具有以下性质的完全二叉树：每个节点的值都大于或等于其左右孩子节点的值，称为大顶堆（如左图）。或者每个节点的值都小于或等于其左右孩子节点的值，称为小顶堆（如右图）。

2、堆排序：就是利用堆（假设为大顶堆）进行排序的方法。它的基本思想是，将待排序的序列的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩下的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次小值，如此反复执行，便能得到一个有序序列。
C#实现代码：

 using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  
  namespace HeapSort
  {
   class Program
   {
   static void Main(string[] args)
   {
   int[] sortArray = { 26, 15, 16, 18, 64, 46, 34, 19, 59, 49 };
   HeapSort(sortArray);
   foreach( int i in sortArray)
   {
   Console.WriteLine(i.ToString());
   }
   Console.ReadKey();
   }
   /// <summary>
   ///
   /// 堆排序
   /// </summary>
   /// <param name="array"></param>
   public static void HeapSort(int[] array)
   {
   for (int i = array.Length / 2; i >= 0; i--)
   {
   MaxHeapify(array, i, array.Length);//调整为大顶堆
   }
   for (int i = array.Length-1; i > 0; i--)
   {
   Swap(array, 0, i);
   MaxHeapify(array, 0, i );
   }
   }
   /// <summary>
   /// 交换数组内的两个数据
   /// </summary>
   /// <param name="array"></param>
   /// <param name="i"></param>
   /// <param name="j"></param>
   public static void Swap(int[] array, int i, int j)
   {
   int temp = array[i];
   array[i] = array[j];
   array[j] = temp;
   }
   /// <summary>
   /// 將指定的節點調整為堆
   /// </summary>
   /// <param name="i">需要調整的節點</param>
   /// <param name="heapSize">堆的大小，也指數組中無序區的長度</param>
   private static void MaxHeapify(int[] sortArray, int i, int heapSize)
   {
   int left = 2 * i + 1; // 左子節點
   int right = 2 * i + 2; // 右子節點
   int larger = i; // 臨時變數，存放大的節點值
   // 比較左子節點
   if (left < heapSize && sortArray[left] > sortArray[larger])
   {
   larger = left;
   }
   // 比較右子節點
   if (right < heapSize && sortArray[right] > sortArray[larger])
   {
   larger = right;
   }
   // 如有子節點大於自身就交換，使大的元素上移。
   if (i != larger)
   {
   Swap(sortArray,i,larger);
   MaxHeapify(sortArray, larger, heapSize);
   }
   }
   }
  }

3、时间复杂度：O（nlogn）
由于记录的比较和交换是以跳跃的形式进行，所以堆排序也是一种不稳定的排序算法。

七、归并排序（Merging Sort）：

1、归并：将两个或者两个以上的有序表合成一个新的有序表。
2、定义：利用归并思想实现的排序算法。 它的原理是假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，

个长度为2或1的有序子序列，再两两归并，。。。。如此重复，直至得到长度为n的有序序列为止，
这种排序方法称为二路归并排序。
C#代码实现:

using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  
  namespace MergeSort
  {
   class Program
   {
   static void Main(string[] args)
   {
   int[] array = { 16, 18, 3, 7, 31, 11, 49, 55, 13 };
   MergeSort(array);
   foreach (int i in array)
   {
   Console.WriteLine(i.ToString());
   }
   Console.ReadKey();
   }
   /// <summary>
   ///
   /// </summary>
   /// <param name="array"></param>
   public static void MergeSort(int[] array)
   {
   MergeSort(array, 0, array.Length - 1);
   }
   /// <summary>
   ///
   /// </summary>
   /// <param name="array"></param>
   /// <param name="p"></param>
   /// <param name="r"></param>
   private static void MergeSort(int[] array, int p, int r)
   {
   if (p < r)
   {
   int q = (p + r) / 2;//二分法
   MergeSort(array, p, q);//递归
   MergeSort(array, q + 1, r);//递归
   Merge(array, p, q, r);//递归
   }
   }
  
   private static void Merge(int[] array, int p, int q, int r)
   {
   int[] L = new int[q - p + 2];//新建两个数组，用于存储原数组的左右子序列
   int[] R = new int[r - q + 1];
   L[q - p + 1] = int.MaxValue;
   R[r - q] = int.MaxValue;
  
   for (int i = 0; i < q - p + 1; i++)
   {
   L[i] = array[p + i];
   }
  
   for (int i = 0; i < r - q; i++)
   {
   R[i] = array[q + 1 + i];
   }
  
   int j = 0;
   int k = 0;
   for (int i = 0; i < r - p + 1; i++)//将左右子序列的值赋回原数组
   {
   if (L[j] <= R[k])
   {
   array[p + i] = L[j];
   j++;
   }
   else
   {
   array[p + i] = R[k];
   k++;
   }
   }
   }
  
  
  
   }
  }

3、时间复杂度：O（nlogn）
归并排序算法是一种效率高且稳定的算法。

八、快排（Quick Sort）：

1、基本思想：通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则可对这两部分记录继续进行排序，以达到这个序列有序的目的。
C#代码实现：

 using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  
  namespace QuickSort
  {
   class Program
   {
   static void Main(string[] args)
   {
   int[] a = { 57, 68, 59, 52, 72, 28, 96, 33, 24 };
   QSort(a);
   foreach (int i in a)
   {
   Console.WriteLine(i.ToString());
   }
   Console.ReadKey();
   }
   public static void QSort(int[] array)
   {
   QSort(array, 0, array.Length - 1);
   }
   /// <summary>
   /// 快排
   /// </summary>
   /// <param name="a"></param>
   /// <param name="low"></param>
   /// <param name="high"></param>
   public static void QSort(int[] a, int low, int high)
   {
   if (low >= high)
   return;
   int first = low, last = high;
   int key = a[first];
   while (first < last)
   {
   while (first < last && a[last] >= key)
   last--;
   a[first] = a[last];
   while (first < last && a[first] <= key)
   first++;
   a[last] = a[first];
   }
   a[first] = key;
   QSort(a, low, first - 1);
   QSort(a, first + 1, high);
   }
  
  
   }
  }

2、时间复杂度：O（nlogn）

九、总结与比较

1、分类：

		排序
	插入类		选择类		交换	归并
直接插入	希尔排序	简单选择	堆排序	冒泡	快排	归并

简单算法：冒泡、简单选择、直接插入
改进算法：希尔、堆、归并、快速
平均情况：最后三种改进算法要胜过希尔排序，并远远胜过前三种简单算法
最好情况：反而是冒泡和直接插入要更胜一筹，
最坏情况：堆排序和归并拍戏又强过快速排序和其他简单排序
稳定性：归并排序最好