算法系列——排序算法
此表格转自此链接博客（http://www.cnblogs.com/nannanITeye/archive/2013/04/11/3013737.html）
1.插入排序
插入排序的方法：从第二个数字num[i]开始，依次与它前边的num[j]比较，如果num[i]>num[j]，比较下一个num[j]，如果num[i]<num[j],则将num[j]和之后的数字依次向后 移动一个位置，为num[i]腾出空间，将num[i]放在num[j]的位置上。
public static void main(String[] args) throws IOException { int[] num = {4,8,3,9,5,7,2}; sort(num); for(int i =0;i<num.length;i++){ System.out.println(num[i]); } } private static void sort(int[] num) { int temp = 0; for(int i = 1;i<num.length;i++){ for(int j =0;j<i;j++){ if(num[i]>num[j]){ continue; } if(num[i]<num[j]){ temp = num[i]; for(int x=i;x>j;x--){ //找到数字应该放置的位置后，将应在位置和实际位置之间的数字向后移一位，以便插入数字。 num[x] = num[x-1]; } num[j] =temp; } } } }
2.希尔排序
希尔排序的方法：第一步：选取增量序列的值，一般是按除2的方式选取，直至1 gap=num.length/2;gap=gap/2...
第二步：如果gap=num.leng/2=3，则将数列中的第0项，第3项，第6项...放在一起；第1项，第4项，第7项...放在一起，分别按插入排序的方法比较。
最后一步：gap=3/2=1;就将数列按照插入排序的方法排序一次，得出结果。
public static void main(String[] args){ int[] num = {3,3,5,2,7,0,1,4,9,6,8}; sort(num); for(int i = 0;i<num.length;i++){ System.out.println(num[i]); } } public static void sort(int[] num){ int gap = num.length/2; for(int k = gap;k>0;k=k/2){ for(int i=0;i<num.length;i++){ for(int j = i+k;j<num.length;j+=k){ if(num[i]>num[j]){ int temp = num[i]; num[i] = num[j]; num[j] = temp; } } } } }
3.冒泡排序
冒泡排序的方法：第一步：将num[0]与之后的num[i]依次比较，如果num[0]<num[i]，继续比较下一个，如果num[0]>num[i]，将num[0]和num[i]互换。第一步结束之 后，数组中的最小值就是num[0];
第二步：将num[1]与之后的num[i]依次比较，重复第一步。第二小的数字便是num[1].
public static void main(String[] args){ int[] num = {9,4,2,7,2,8,4,1}; sort(num); for(int i =0;i<num.length;i++){ System.out.println(num[i]); } } public static void sort(int[] num){ int temp = 0; for(int i=0;i<num.length-1;i++){ for(int j=i+1;j<num.length;j++){ if(num[i]<num[j]){ continue; } else{ temp = num[i]; num[i] = num[j]; num[j] = temp; } } } }
4.快速排序
快速排序的方法：分治法+填坑法。
第一步：首先取最右端（或最左端或随机都可以，但尽量在最左或最右，此次按最右端）的值num[num.length-1]赋给中间值middle，此时num.length-1处可以看作没有了，是一个坑，所以我们 就可以找一个值来填充它。
那么把哪个位置上的值填充到这里呢？由于我们的目的是按照从小到大的顺序排列这个数列，所以当我们在数列的最后一位有空位置的时候，我们自然就要把比middle大的值放在空位置上。
那么怎么来找这一个比middle大的值？我们就需要两个指针，一个low，一个high，low初始指向num[0]，high初始指向num[num.length-2]，由它们带领来查找合适的填坑值。
当高位有空位时，就从低位找一个比middle大的值放过来，当低位有空位时，就从高位找一个比middle小的值来填充，同时low和high也在不断逼近，当low=high时，第一次排序完成。把middle的值放在low和high处。
第二步：low和high在的位置就是中间值的位置，然后递归将middle左边的数列排序，middle右边的数列排序。
注释掉的是自己写的时候犯的错误，包括对于方法参数的不明确。
最坏情况：排一个已经排好序的数列，时间复杂度是O(n2);
public class Test { public static void main(String[] args){ int[] num = {1,7,2,4,6,8,5}; /*int middle = getMiddle(num,0,num.length-1); getMiddle(num,0,middle-1); getMiddle(num,middle+1,num.length-1);*/ sort(num,0,num.length-1); for(int i = 0;i<num.length;i++){ System.out.print(num[i]); } } public static int getMiddle(int[] num,int low,int high){ int middleValue = num[high];//int middleValue = num[num.length-1]; while(low<high){ while(low<high&&num[low]<middleValue){ low++; } num[high] = num[low]; while(low<high&&num[high]>middleValue){ high--; } num[low] = num[high]; } num[low] = middleValue; return low; } public static void sort(int[] num,int low,int high){ int middle; if(low<high){ middle = getMiddle(num,low,high); getMiddle(num,low,middle-1); getMiddle(num,middle+1,high); } } }
以下是一开始按照自己的理解写的代码，很复杂，而且最后出现了错误，如果不加注释掉的那三行，能获取正确的middle，加上之后返回的middle就不对了。
public static int getMiddle(int[] num){ int temp = 0; int middle = 0; int j =0; int value = num[num.length-1]; for(int i =0;i<num.length-1;i++){ if(num[i]<value){ if(i==0){ continue; }else{if(j==0){ continue; }else{ temp = num[i]; num[i]= num[j]; num[j] = temp; j++; } } }else{ if(j==0){ j=i; } else{ continue; } } } middle =j; //int emp = value; //num[num.length-1] = num[j]; //num[j] = emp; return middle; }
5.简单选择排序
选择排序的方法：和冒泡法类似，冒泡法是便利num[i]之后的数字，遇见小的就换；选择排序是将较小数字的角标记录，然后继续遍历，遇见更小的就更新存储角标的变量，最后将变量中角标对应的数字变换位置。
public static void sort(int[] num){ for(int i=0;i<=num.length-2;i++){ int temp = i; for(int j=i+1;j<=num.length-1;j++){ if(num[j]<num[temp]){ temp = j; } else{ continue; } } if(temp!=i){ int cha = num[i]; num[i] = num[temp]; num[temp] = cha; } } }
6.堆排序（选择排序的改进）
完全二叉树：出最后一层之外，二叉树的每一层都是满的，在最后一层上只缺少右侧的结点。 
最大最小堆：最大就是从上至下结点值是按降序排列的，越往上越大，越往左越大。
构造堆的时候，结点都是有规律的，如上图，左子结点的序号等于父结点的2倍（从0开始就是2倍加1），右子结点的序号等于父结点序号的2倍+1（从0开始就是2倍加2），在构造堆的时候可以利用这一点。
堆主要有两种操作：1.结点插入：将插入结点放到最后的位置，然后维护堆（依次与父结点比较大小）。2.结点删除：删除操作只能删除根节点，然后让最后一个结点成为根结点，之后维护堆。
排序方法是在构造堆后，输出num[0]，然后将最后一个结点与根节点互换，然后重新构造长度减去1的堆，再输出num[0]，重复以上操作。
构造堆的过程就是将数列中最大值放到根节点。
public static void main(String[] args){ int[] num = {3,5,2,7,0,1,4,9}; makeHeap(num,num.length-1,(num.length-2)/2); adjustHeap(num); } private static void makeHeap(int[] num,int heapSize,int index) { int left,right,large; for(int i = index;i>=0;i--){ left = i*2+1; right = i*2+2; large = i; if(left<=heapSize&&num[left]>num[i]){ large = left; } if(right<=heapSize&&num[right]>num[i]){ if(num[right]>num[left]){ large = right; } } if(large!=i){ int temp =num[i]; num[i] = num[large]; num[large] = temp; } } } public static void adjustHeap(int[] num){ int a; for(int i=0;i<=num.length-1;i++){ a=num[0]; System.out.println(a); int temp = num[num.length-1-i]; num[0] = temp; num[num.length-1-i]=temp; makeHeap(num,num.length-2-i,(num.length-3-i)/2); } }
7.归并排序
归并排序的方法：数列不断的被分割，当分到只有两个或一个不能再分的时候，就开始合并，合并的结果一开始临时存入到result数组中，每一次合并完成，就把result中的数放到num中对应位置（i+start）上。
public static void main(String[] args){ int[] num = {3,5,2,7,0,1,4}; sort(num,0,num.length-1); for(int i = 0;i<num.length;i++){ System.out.println(num[i]); } } public static void sort(int[] num,int start,int end){ if(start<end){ sort(num,start,(start+end)/2); sort(num,(start+end)/2+1,end); merge(num,start,(start+end)/2,end); } } private static void merge(int[] num, int start, int mid, int end) { int[] result= new int[end -start+1]; int left = start; int right = mid+1; int index = 0; while(left<=mid&&right<=end){ if(num[left]<num[right]){ result[index++] = num[left++]; } else { result[index++] = num[right++]; } } while(left<=mid){ result[index++]= num[left++]; } while(right<=end){ result[index++] = num[right++]; } for(int i = 0;i<result.length;i++){ num[i+start] = result[i]; } }
8.计数排序 O(n)
计数排序的方法：将数列遍历，在一个新的数列A里记录下每个数重复出现的次数，A的长度等于最大元素的值加一,然后将A中数列值累加，反向填充新数列。
public static void main(String[] args){ int[] num = {3,3,5,6,3,5,6}; sort(num); } public static void sort(int[] num){ int a =num[0]; int sum = 0; for(int i = 0;i<num.length-1;i++){ if(num[i]>a){ a=num[i]; } } int[] num1 = new int[a+1]; for(int j = 0;j<num.length;j++){ num1[num[j]]+=1; }
int sum =0; for(int k=0;k<num1.length;k++){ num1[k]+=sum;
sum = num1[k];
}
int[] result = new int[num.length]; 反向填充for(int q = 0;q<result.length;q++){ System.out.println(result[q]); } }
9.基数排序 O(n)
类似于重新排好扑克牌，先把四组相同花色的放到一起，然后再按从小到大顺序排列。第一次的基数是花色，第二次是大小。或者是先把面值相同的放到一起，然后再按花色组合。
如果数列中数字是两位数，那么先取第二位为基数，将基数相同的放到一起，从小到大组成新的数列；然后将新数列以第一位为基数，重新把基数相同的放到一起，然后按照基数大小顺序组成新的数列就是排好的数列。
如果数的长度不一样，前面补0。
10.桶排序 O(n)
桶排序方法：把一定范围内的数放到一个桶中，然后将各个桶内的数据进行排序，然后将各个桶内的数据合并
