排序算法总结
排序算法
1. 直接插入排序
基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。
public static void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int temp = array[i];
int pre = i - 1;
for (; pre >= 0 && array[pre] > temp; pre--) {
//将大于temp的值整体后移一个单位
array[pre+1] = array[pre];
}
array[pre+1] = temp;
}
System.out.println(Arrays.toString(array) + " insertSort");
}2. 希尔排序
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。
先取一个正整数d1 < n, 把所有相隔d1的记录放一组，每个组内进行直接插入排序；然后d2 < d1，重复上述分组和排序操作；直至di = 1，即所有记录放进一个组中排序为止。
public static void shellSort(int[] array) {
int pre = 0;
int temp = 0;
int len = array.length;
for (int gap= len/2; gap> 0; gap/= 2) {
System.out.println("gap:" + gap);
for (int i=gap; i<len; i++) {
temp = array[i];
for (pre=i-gap; pre>=0 && array[pre]>temp; pre-=gap) {
//将大于temp的值整体后移gap个单位
array[pre+gap] = array[pre];
}
array[pre+gap] = temp;
}
}3. 简单选择排序
基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
public static void selectSort(int[] array) {
int position = 0;
for(int i=0;i<array.length;i++){
int after = i+1;
int temp = array[i];
//找出当前点后面比当前点最小的数字
for(;after<array.length && array[after]<temp; after++){
temp = array[after];
position = after;
}
//当前点与后面最小的点（position）交换位置
array[position] = array[i];
array[i] = temp;
}
System.out.println(Arrays.toString(array) + " selectSort");
}4. 最大堆排序
基本思想：堆排序是一种树形选择排序，是对直接选择排序的有效改进。
堆的定义如下：具有n个元素的序列（h1,h2,…,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,…,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
[ wiki]
[ 参考blog ]
public static void heapSort(int[] array) {
int len = array.length - 1;
int beginIndex = (len-1)/2;
//第一步，最大堆化
for(int i=beginIndex; i>=0; i--){
maxHeapify(i,len,array);
}
//最大堆化之后，树的根节点是最大的数，将它放在最后面
for(int j=len;j>0;j--){
swap(0,j,array);//将根节点与第j个树交换
maxHeapify(0, j-1, array);
}
System.out.println(Arrays.toString(array) + " heapSort");
}
public static void swap(int i, int j, int[] arr){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void maxHeapify(int index, int len, int [] arr){
int li = (index*2) + 1;//乘以2
int ri = li + 1;
int cMax = li;//子节点值最大索引，初始化为左节点
if(li>len){
return;
}
if(ri<=len && arr[ri]>arr[li]){
cMax = ri;
}
if(arr[cMax]>arr[index]){
swap(cMax, index, arr);
maxHeapify(cMax, len, arr);//继续判断替换后的父节点是否符合堆的特性
}
}
5. 冒泡排序
1 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3 针对所有的元素重复以上的步骤，除了最后一个。
4 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
public static void bubbleSort(int[] array) {
int temp = 0;
for(int i=0; i<array.length-1; i++){
for(int j=0; j<array.length-1-i; j++){
if(array[j]>array[j+1]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(array) + " bubbleSort");
}6. 快速排序
1.先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对除了该点以外的左右区间重复第二步，直到各区间只有一个数。
public static void quickSort(int[] array) {
sort(array, 0, array.length-1);
System.out.println(Arrays.toString(array) + " quickSort");
}
public static void sort(int[] list, int low, int high){
if(low < high){
int middle = getMiddle(list, low, high);
sort(list, low, middle-1);
sort(list, middle+1, high);
}
}
public static void getMiddle(int [] list, int low, int high){
int temp = list[low];//取区间第一个数为基准数
while(low<high){
//从后往前找比当前点(temp)小的数
while(low<high && list[high]>= temp){
high--;
}
if(low < high){
list[low] = list[high];//填坑，把比当前点小的数移到左边
low++;
}
//从前往后找比当前点(temp)大或者等于的数
while(low<high && list[low]<temp){
low++;
}
if(low<high){
list[high] = list[low]//填坑，把比当前点大的数移到右边
high--;
}
}//end while
//结束后，low=high
list[low] = temp;
return low;
}
7. 归并排序
首先考虑下将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。
[ 参考1]
[ 参考2]
public static void mergeSort(int [] array){
sort(array, 0, array.length-1);
System.out.println(Arrays.toString(array) + " mergeSort");
}
private static void sort(int[] list, int li, int ri){
if(li<ri){
int center = (li + ri)/2;
sort(list, li, center);
sort(list, center+1, ri);
merge(list, li, center, ri);
}
}
private static void merge(int [] list, int li, int center, int ri){
int [] tempArr = new int[list.length];
int k =0;
int mid = center + 1;
while(li<=center && mid<=ri){
//左边的第一个数 <= 右边第一个数，所以把左边第一个数取出来
if(list[li]<=list[mid]){
tempArr[k] = list[li];
k++;
li++
}else{
tempArr[k] = list[mid];
k++;
mid++;
}
}
//当右边的Array为空，将左边Array依次放入tempArr
while(li<=center){
tempArr[k++] = list[li++];
}
//当左边的Array为空，将右边的Array依次放入tempArr
while(mid<=ri){
tempArr[k++] = list[mid++];
}
for(int i=0; i<k; i++){
list[i+li] = tempArr[i];
}
}