Java 排序算法练手

package DataStruct;

import java.util.*;

public class Array {
	public static void main(String[] args){
		int[] Data = {6,1,2,7,9,3,4,5,10,8};
		Array test = new Array();
		//test.showSort(Data);
		//test.BubbleSort(Data);//注意是值传递，copy了Data数组的引用，但改变是真实发生的
		//test.ChoiceSort(Data);
		//test.InsertSort(Data);
		//test.FastSort(Data,0,Data.length-1);
		//test.HeapSort(Data);
                //test.MergeSort(Data,0,Data.length-1);
		test.ShellSort(Data);
		test.showSort(Data);
	}
	public void showSort(int[] input){
		//int num = input.length;
		System.out.println(Arrays.toString(input));		
	}
	public void BubbleSort(int[] input){//冒泡排序
		// 时间复杂度 ：最坏O(n^2) 最好O(n) 平均O(n^2)
		// 空间复杂度 ：O(1)
		// 稳定
		int num = input.length;
		for(int i=1; i<num; i++){//从前往后冒泡
			int flag = 0;//设置标志位以观察序列是否变动过
			for(int j=0; j<num-i; j++){//每次冒泡完毕尾部都会新增一个有效数据
				if(input[j]>input[j+1]){//前面比后面大则需要进行交换
					exchange(j,j+1,input);
					flag = 1;
				}
			}
			if(flag == 0){//算是一个时间上的优化，但额外申请了一空间
				break;
			}
			//showSort(input);
		}
	}
	public void ChoiceSort(int[] input){//选择排序
		// 时间复杂度 ：固定为O(n^2)
		// 空间复杂度 ：O(1)
		// 每次只对最值进行交换，算是对冒泡排序的改进
		// 不稳定
		int num = input.length;	
		for(int i=0;i<num-1;i++){//从前往后
			int index = i;
			int min = input[i];
			for(int j=i+1;j<num;j++){//每次比较过程进行一次最小值记录与其下标，方便之后的交换
				if(min>input[j]){
					min = input[j];
					index = j;
				}
			}//求得min值
			exchange(i,index,input);//每次排序后队首都会新增一个有序数据		
			//showSort(input);
		}
	}
	public void InsertSort(int[] input){//插入排序 （简单直接插入法）（有序情况下O(n)就能解决问题）
		// 时间复杂度 ：最坏O(n^2) 平均O(n^2) 最好O(n)
		// 空间复杂度 ：O(1)
		// 稳定
		int num = input.length;
		for(int i=1;i<num;i++){//插入比较的次数
			int temp = input[i];
			int index = i;
			while(index>0&&temp<input[index-1]){//使用while更加方便
				input[index] = input[index-1];//注意比较一次，成立则后移一次，反正总要移动数组的
				index --;
			}
			input[index] = temp;//找到合适的位置插入			
			//showSort(input);
		}
	}
	public void ShellSort(int[] input){//希尔排序 （有序情况下O(n)就能解决问题）
		// 时间复杂度 ：最坏情况下和直接插入排序相同 O(n^2) 最好O(n) 平均O(n^1.3)
		// 空间复杂度 ：O(1)
		// 不稳定：虽然直接插入法是稳定的，但考虑到对整个数组进行了分组，故必然有可能出现不稳定的现象
		int num = input.length;
		int increment = input.length;
		while(increment>0){
			if(increment==1)//跳出循环
				break;
			increment = increment/3+1;//终究会等于1的
			//对每个划分使用插入排序,其实就是普通的插入排序法改变比较的间隔
			for(int i=increment;i<num;i++){//increment为1时其实就变成了普通的插入排序
				if(input[i]<input[i-increment]){//是否有进行插入排序的必要（之前的直接插入法没有这个判定）
					int temp = input[i];
					int index = i;
					while(index-increment>=0&&temp<input[index-increment]){//使用while更加方便
						input[index] = input[index-increment];//注意比较一次，成立则后移一次，反正总要移动数组的
						index -= increment;
					}
					input[index] = temp;//找到合适的位置插入	
				}
			}
		}
	}
	
    public void exchange(int a,int b,int[] input){//需要使用交换函数
        int temp = input[a];
        input[a] = input[b];
        input[b] = temp;
    }
	public void FastSort(int[] input,int start,int end){//快速排序(递归法+分治的思想)
		// 快速排序的最差时间复杂度和冒泡排序是一样的都是O(n^2)，它的平均时间复杂度为O(nlogn)->最好也是O(nlogn)
		// 空间复杂度 ：O(logn~n)(有递归栈)
		int temp =start;//设立基准数
		//两个哨兵
		int i = start;
		int j = end;
		if(i==j||j<start||i>end)return;
		while(i<j){
			while(i<j&&input[j]>=input[temp]){//找比input[temp]更小的值
				//j先动，这里有个注意点，为什么让j先动
				j--;
			}
			while(i<j&&input[i]<=input[temp]){//找比input[temp]更大的值
				//a)如果让i先动，有可能找不到比input[temp]更大的值，却依旧在最后交换位置了
				//b)有可能交换的是比input[temp]更大的值，违背算法的本意
				i++;
			}
			if(i<j){//没相遇则交换两个哨兵
				exchange(i,j,input);
			}
		}
		exchange(temp,j,input);//相遇则交换
		//showSort(input);
		FastSort(input,start,j-1);//分治
		FastSort(input,j+1,end);
	}
	
	public void MergeSort(int[] input, int start, int end){//归并排序
		// 时间复杂度 ：O(nlogn)
		// 空间复杂度 ：O(n)
		// 需要一个合并函数MergeHelper,将分治后的两个数组进行排序
		int mid = (end - start)/2 + start;//避免越界
		if(end>start){//只有存在可分性才能继续往下进行分治
			MergeSort(input, start, mid);
			MergeSort(input, mid+1, end);//不停的划分数组
			MergeHelper(input, start, end, mid);//将两个分数组排序后组合起来
		}
	}
	public void MergeHelper(int[] input, int start, int end, int mid){
		int[] temp = new int[end-start+1];//定义临时数组
		int aNum = start;//前半段
		int bNum = mid+1;//后半段
		int cNum = 0;
		int len1 = mid-start+1;
		int len2 = end-(mid+1)+1;
		while(aNum<len1+start && bNum<len2+mid+1){
			if(input[aNum]<input[bNum]){
				temp[cNum++] = input[aNum++];
			}else
				temp[cNum++] = input[bNum++];
		}
		while(aNum<len1+start){
			temp[cNum++] = input[aNum++];
		}
		while(bNum<len2+mid+1){
			temp[cNum++] = input[bNum++];
		}	
	    //把新数组中的数覆盖到input数组中
		System.arraycopy(temp, 0, input, start, end-start+1);//System.arraycopy方法更加效率
	}
	
	//20190104堆排序
	public void HeapSort(int[] input){
		// 时间复杂度 ：O(nlogn)
		// 空间复杂度 ：O(1)
		HeapBuild(input);//先建造大顶堆
		//showSort(input);
		for(int i=input.length-1;i>0;i--){
			exchange(0,i,input);//交换  堆顶数据（max）与堆尾当前最后一个无效数据
			HeapHelper(0,i,input);//调整交换后数据的堆，将下一个max顶至堆头
		}
	}
	public void HeapBuild(int[] input){//建造大顶堆
		for(int i=0;i<input.length;i++){
			int parent = 0;
			while(i!=0){
				parent = (i-1)/2;//堆的正确性只与父节点有关，依次对每个非叶进行调整即可
				if(input[parent]<input[i]){
					exchange(parent,i,input);
					i = parent;
				}else{
					break;
				}
			}
		}
	}
	public void HeapHelper(int i,int len,int[] input){
		//调整一次堆尾数据,len代表当前堆的未排序数据容量（也是下一次处理的堆容量）
		//尝试将下一个有效len容量内的max顶至堆头，方便下次交换
		int index = i;//当前不合格的堆数据的下标，初始为0，因为之前有一次堆顶元素与堆尾最后一个有效数据的交换
		int left = 2*i+1;//左孩子
		int right = 2*i+2;//右孩子
		while(left<len){//下标的有效范围是len
			if(input[left]>input[index]){
				index = left;
			}
			if(right<len&&input[right]>input[index]){
				index = right;
			}
			if(index!=i){
				exchange(index,i,input);
			}else
				break;//无需调整则直接退出循环即可
			i = index;
			left = 2*i+1;//左孩子
			right = 2*i+2;//右孩子
		}
	}
}