排序：选择、插入、冒泡、归并、快排、堆排序的Python和Java实现
1 复杂度分析
空间复杂度都是O(1)的：
选择排序：最好、最坏、平均都是O(n2)。
插入排序：最好O(n)，最坏O(n2)，平均O(n2)。
冒泡排序：不稳定，最好O(n)、最坏O(n2)、平均都是O(n2)。
归并排序：最好、最坏、平均都是O(nlogn)。
堆排序：最坏O(nlogn)。
空间复杂度为O(nlogn)：
快速排序：最坏O(n2)，最好O(nlogn)，平均O(nlogn)。
1：直接插入排序：
最好：待排序已经有序， 从前往后走都不用往里面 插入。 时间复杂度为o(n)
最坏：待排序列是逆序，每一次都要移位插入。 时间复杂度o(n^2)
是稳定排序
2：希尔排序：
最好：缩小增量的插入排序，待排序已经有序。时间复杂度o(n）
一般：平均时间复杂度o(n1.3)，最差也是时间复杂度o(n1.3)
不稳定排序
3：冒泡排序：
最好：待排序已经有序。时间复杂度o(n）
最坏：待排序是逆序。时间复杂度o(n^2）
稳定排序
4：快速排序：
最好：待排序无序。时间复杂度o(nlogn)
最坏: 待排序已经有序，基准定义在开始。 时间复杂度为o(n^2)
不稳定排序
5：直接选择排序：
无论好坏:o(n^2)
稳定排序
6：堆排序：
无论好坏：时间复杂度o(nlogn)
不稳定排序
7：归并排序：
稳定排序
8：基数排序：
无论好坏:o(d(n+r)) ，r为基数，d为位数.
稳定排序
堆排序：时间复杂度主要在筛选时的比较。筛选时，首先将堆顶元素与最后一个元素调换位置，然后调整剩下的n-1个元素构成的堆，这个调整的过程是从第1个元素开始，自上而下进行比较，每次需要与左右孩子结点都进行比较，所以总的比较次数为 2 ( l o g 2 ( n − 1 ) ) + 2 ( l o g 2 ( n − 2 ) ) . . . 2 ( l o g 2 ( 2 ) ) = O ( n l o g n ) 2(log_2(n-1)) + 2(log_2(n-2))...2(log_2(2)) = O(nlogn) 2(log2(n−1))+2(log2(n−2))...2(log2(2))=O(nlogn)。
注意：无论有序序列还是无序序列，堆排序的时间复杂度都是相同的。
选择排序：每次后面未排序序列中选择一个元素，放置到前面已排序序列的末尾。
最坏复杂度： n + ( n − 1 ) + . . . + 1 = O ( n 2 ) n+(n-1)+...+1 = O(n^2) n+(n−1)+...+1=O(n2)
最好时间复杂度：也是 O ( n 2 ) O(n^2) O(n2)，无论序列是否有序，都会将后面的所有元素进行比较。
堆排序：堆排序是选择排序的一种。
无论序列是否有序，比较次数都相同，所以时间复杂度为O(nlogn)。
插入排序：将后面未排序序列中的元素，插入到前面已排序序列中。
其他插入排序：折半插入排序、2路插入排序。
希尔排序：希尔排序时插入排序的一种。先将整个序列划分成小序列，分别进行直接插入排序，待序列基本有序后，再对整个序列进行插入排序。希尔排序的时间复杂度尚未得到完美分析。
归并排序：最开始的n个元素，可以视为n个子序列，现将这n个子序列两两归并，得到n/2个子序列。再将这n/2个子序列两两归并。
归并排序的具体操作：将两个已排序序列S[i…m]、S[m+1…n]，归并到另一个序列T[i…n]中，所以归并排序需要的辅助空间与元素数相同。空间复杂度为O(n)。
冒泡排序：将未排序序列中的最值元素，冒泡到未排序序列的最后一个位置。
最坏时间复杂度： ( n − 1 ) + ( n − 2 ) . . . + ( 2 ) = O ( n 2 ) (n-1) + (n-2) ... + (2) = O(n^2) (n−1)+(n−2)...+(2)=O(n2)
最好时间复杂度：无论序列是否有序，都会从头冒泡到尾，比较次数不会减少。
快速排序：选一个枢轴，将比他小的元素都放在枢轴的左边，比他大的元素都放到枢轴的右边。然后递归解决除枢轴之外的两个部分。
最坏时间复杂度：序列是有序的，并且每次枢轴都选择第一个。 ( n − 1 ) + ( n − 2 ) + . . . + 2 = O ( n 2 ) (n-1) + (n-2) + ... + 2 = O(n^2) (n−1)+(n−2)+...+2=O(n2)
平均时间复杂度：序列是无序的， n l o g n nlogn nlogn
3 稳定性分析
在牛客网中见到一句非常好的总结。
不稳定的排序算法是：快些选堆。快速排序、希尔排序、简单选择排序、堆排序。
转自：稳定排序和不稳定排序-紫红的泪-博客园
稳定排序和不稳定排序
这几天笔试了好几次了，连续碰到一个关于常见排序算法稳定性判别的问题，往往还是多选，对于我以及和我一样拿不准的同学可不是一个能轻易下结论的题目，当然如果你笔试之前已经记住了数据结构书上哪些是稳定的，哪些不是稳定的，做起来应该可以轻松搞定。本文是针对老是记不住这个或者想真正明白到底为什么是稳定或者不稳定的人准备的。
首先，排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj，Ai原来在位置前，排序后Ai还是要在Aj位置前。
其次，说一下稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，对基于比较的排序算法而言，元素交换的次数可能会少一些（个人感觉，没有证实）。
回到主题，现在分析一下常见的排序算法的稳定性，每个都给出简单的理由。
(1)冒泡排序
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
(2)选择排序
选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n - 1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。
(3)插入排序
插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
(4)快速排序
快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，i <= j，交换a[i]和a[j],重复上面的过程，直到i > j。 交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为5 3 3 4 3 8 9 10 11，现在中枢元素5和3（第5个元素，下标从1开始计）交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j] 交换的时刻。
(5)归并排序
归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素（认为直接有序）或者2个序列（1次比较和交换），然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。
(6)基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。
(7)希尔排序(shell)
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小， 插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比O(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。
(8)堆排序
我们知道堆的结构是节点i的孩子为2 * i和2 * i + 1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n 的序列，堆排序的过程是从第n / 2开始和其子节点共3个值选择最大（大顶堆）或者最小（小顶堆），这3个元素之间的选择当然不会破坏稳定性。但当为n / 2 - 1， n / 2 - 2， … 1这些个父节点选择元素时，就会破坏稳定性。有可能第n / 2个父节点交换把后面一个元素交换过去了，而第n / 2 - 1个父节点把后面一个相同的元素没 有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。
综上，得出结论: 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法
2 程序实现
# 选择排序：找出序列中最小的数，与第一个数交换。记录的是下标
def select_sort(lists):
count = len(lists)
for i in range(0,count):
min = i
for j in range(i+1,count):
if lists[j] < lists[min]:
min = j
lists[i],lists[min] = lists[min],lists[i]
return lists
#--------------------------------------------------------------
#插入排序 :第一个元素为一个序列，后面的元素插入到前面的序列中
def insert_sort(lists):
count = len(lists)
for i in range(1,count):
key = lists[i]
j = i-1
while j>=0:
if lists[j] >= key:
lists[j+1] = lists[j]
lists[j] = key
j-=1
return lists
#--------------------------------------------------------------
#冒泡排序：第一个元素与后面的元素比较，大的往上冒
def bubble_sort(lists):
count = len(lists)
for i in range(0,count-1):#不遍历最后一个元素，比较大小的时候，就用到最后一个元素了
for j in range(0,count-1-i):#第一次是[0,倒数第二个元素] ，后面end逐渐减1
if lists[j]>lists[j+1]:
lists[j], lists[j + 1] = lists[j+1], lists[j]
return lists
#--------------------------------------------------------------
def merge(left,right):
result = []
i , j = 0, 0
while i <= len(left) and right <= len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.append(left[i:])
result.append(right[j:])
return right
#归并排序：相邻元素合并，递归与分治
def merge_sort(lists):
if len(lists)<=1:
return lists
num = len(lists)/2
left = merge_sort(lists[:num])
right = merge_sort(lists[num:])
return merge(left,right)
#--------------------------------------------------------------
def partition(lists,low,high):#交换字表l[low:high]中的元素，使枢轴到位
key = lists[low] #初始关键字是第一个元素
while lowkey: high -= 1;
lists[low] = lists[high]
if low 3 选择排序 Java实现
3.1 简单选择排序
package com.selectionSort;
/**
* 简单选择排序：从未排序序列中，选择最小值，放置到已排序序列的尾部。—— 从小到大排序
* 时间复杂度：O(n^2)
* 空间复杂度：O(1)
* @author dell
*
*/
public class SelectSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] numbers = {10,1,8,3,6,5,4,7,2,9};
selectSort(numbers);
for (int number : numbers) {
System.out.print(number + " ");
}
}
private static void selectSort(int[] numbers) {
// TODO Auto-generated method stub
for (int location = 0; location < numbers.length; location ++) {//待放置的位置是i
int min = location;
for (int j = location; j < numbers.length; j++) {
if(numbers[j] <= numbers[min]) {
int temp = numbers[min];
numbers[min] = numbers[j];
numbers[j] = temp;
}
}
}
}
}
3.2 堆排序
package com.selectionSort;
/*
* 堆排序：
* --树形选择排序：为了减少时间复杂度的比较次数，产生了树形选择排序，即从树叶开始，两两比较，再到倒数第二层两两比较。
* --但树形选择排序的缺点较多：比如需要较多的辅助空间。所以产生了另一种形式的选择排序：堆排序。
*
*
*/
public class HeapSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] nums = {1,11,3,8,10,5,6,7,4,9,2};
heapSort(nums);
for (int i = 0; i < nums.length; i++) {
System.out.print(nums[i] + " ");
}
}
//核心：顺序排序
private static void heapSort(int[] nums) {
// TODO Auto-generated method stub
//建立大顶堆
for(int i = nums.length/2-1;i>=0;i--) {//从第一个非叶节点开始调整
adjust(nums,i,nums.length-1);
}
//筛选
for(int j=nums.length - 1; j>0;j--) { //j代表，将根结点的值与第j个结点的值交换。j=1时，j=1与根结点交换，所以不需要再调整根结点了，或者说j=2~n-1都调整好了，根结点跟谁交换呢。
swap(nums,0,j);//交换nums的下标为0,j的两个节点的值。
adjust(nums,0,j-1);
}
}
//begin：要调整的子树起始下标（即该子树的根结点），要调整的子树的最后一个节点的下标。
private static void adjust(int[] nums, int begin,int end) {
while(begin <= end) {
int left = begin * 2 + 1;
int right = begin * 2 + 2;
int largest = begin;
if(left <= end && nums[left] >= nums[begin]) largest = left;
if(right <= end && nums[right] >= nums[largest]) largest = right;
if(begin == largest) break;//根结点比两个子节点都大，就可以结束循环了
swap(nums,begin,largest);
begin = largest;
}
}
private static void swap(int[] nums, int first, int second) {
int temp = nums[first];
nums[first] = nums[second];
nums[second] = temp;
}
}