上次写的算法排序的文章都是O(logn^2)的,这次写两个比较常用的经典的排序算法:归并排序和快速排序。
1.归并排序
也就是合并排序,将两个或两个以上的有序数据序列合并成一个新的有序数据序列,它的基本思想是假设数组A有N个元素,那么可以看成数组A有N个有序的子序列组成,每个子序列的长度为1,然后在将两两合并,得到一个N/2个长度为2或1的有序子序列,再两两合并,如此重复,直到得到一个长度为N的有序序列为止。
例如:数组A有7个数据,分别是 23,5,69,85,26,32,15 采用归并排序算法的操作过程如下:
初始值【23】【5】【69】【85】【26】【32】【15】
第一次 会被分成两组【23】【5】 【69】,【85】【26】【32】【15】
第二次 将第一组分成【23】,【5】 【69】两组
第三次 将第二次分的第二组进行拆分【5】,【69】两组
第四次 对第三次拆分数组进行合并排序【5 69】
第五次 第四次排序好的数组和第二次拆分的数组合并为【5 23 69】
接下来 对第一次拆分的第二数组做同样的过程操作,合并为【15 26 32 85】
最后将两个有序的数组做最后的合并【5 15 23 26 32 69 85】
该算法的核心思想是采用了分治思想,即将一个数组分成若干个小数组排序,排序后再两两合并的过程。
首先看合并的过程实现,上代码:
1 //将两个排序好的序列合并 2 void Merge(int[] left, int[] right, int[] mergeArr) 3 { 4 int i = 0, j = 0, k = 0; 5 6 while (i < left.Length && j < right.Length) 7 { 8 if (left[i] < right[j]) //将元素小的放在合并的序列内 9 { 10 mergeArr[k] = left[i]; 11 i++; 12 } 13 else 14 { 15 mergeArr[k] = right[j]; 16 j++; 17 } 18 k++; 19 } 20 21 //有左元素 没有右元素的情况 22 while (i < left.Length) 23 { 24 mergeArr[k] = left[i]; 25 i++; 26 k++; 27 } 28 29 //有右元素 没有左元素的情况 30 while (j < right.Length) 31 { 32 mergeArr[k] = right[j]; 33 j++; 34 k++; 35 } 36 }
下面看看如何将一个数组分成若干个小组的过程:
1 public int[] MergeSort(int[] arr) 2 { 3 if (arr == null || arr.Length == 0) 4 return arr; 5 6 int middle = arr.Length >> 1; 7 8 //左数组 9 int[] left = new int[middle]; 10 11 //右数组 12 int[] right = new int[arr.Length - middle]; 13 14 for (int i = 0; i < arr.Length; i++) 15 { 16 if (i < middle) 17 left[i] = arr[i]; 18 else 19 right[i - middle] = arr[i]; 20 } 21 22 if (arr.Length > 1) 23 { 24 //递归左序列 25 left = MergeSort(left); 26 27 //递归右序列 28 right = MergeSort(right); 29 30 Merge(left, right, arr); 31 } 32 33 Console.WriteLine("归并排序过程:{0}", String.Join(",", arr.ToArray())); 34 35 return arr; 36 }
看效果:
2.快速排序
在平均状况下,排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见。事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环可以在大部分的架构上很有效率地被实现出来,且在大部分真实世界的数据,可以决定设计的选择,减少所需时间的二次方项之可能性。
快速排序使用分治法策略来把一个串行分为两个子串行。
步骤为:
- 从数列中挑出一个元素,称为 "基准",
- 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区操作。
- 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递归下去,但是这个算法总会退出,因为在每次的迭代中,它至少会把一个元素摆到它最后的位置去。
看图:
上代码:
1 //快速排序2 2 public List<int> QuickSort(List<int> arr) 3 { 4 if (arr.Count <= 1) return arr; 5 6 int pivotIndex = arr.Count >> 1; 7 int pivot = arr[pivotIndex]; 8 arr.Remove(pivot); 9 10 List<int> left = new List<int>(); 11 List<int> right = new List<int>(); 12 13 for (int i = 0; i < arr.Count; i++) 14 { 15 if (arr[i] < pivot) 16 left.Add(arr[i]); 17 else 18 right.Add(arr[i]); 19 } 20 21 var newArr = QuickSort(left); 22 newArr.Add(pivot); 23 newArr.AddRange(QuickSort(right)); 24 Console.WriteLine("已排序的序列*********{0}",(String.Join(",",newArr.ToArray()))); 25 return newArr; 26 }
快速排序是二叉查找树的一个空间优化版本。不以循序地把项目插入到一个明确的树中,而是由快速排序组织这些项目到一个由递归调用所意含的树中。这两个算法完全地产生相同的比较次数,但是顺序不同。
快速排序的最直接竞争者是堆排序(Heapsort)。堆排序通常比快速排序稍微慢,但是最坏情况的运行时间总是O(n log n)。