排序算法总结

1.插入排序

一个list分为有序数组和无序数组，每次将一个无序数组的数字插入有序数组中，时间复杂度O(n2)空间复杂度O(1)

package sort;

public class InsertSort {
	
	public int[] sort(int[] list){
		for(int i=1;i<list.length;i++){
			int temp=i;
			int tempValue=list[i];
			for(int j=i-1;j>=0;j--){
				if(list[j]>list[i]){
					temp=j;
				}
			}
			for(int j=i;j>temp;j--){
				int t=list[j];
				list[j]=list[j-1];
				list[j-1]=t;
			}
			list[temp]=tempValue;
		}
		return list;
	}

}

2.希尔排序

将序列以一个增量分割成多个组分别进行插入排序，逐步减小增量直至1

public class HillSort {
	
	public void sort(int[] list,int num){
		while(num>0){
			this.hill(list, num);
			num/=2;
		}
	}
	
	public void hill(int[] list,int num){
		for(int i=num;i<list.length;i++){
			if(list[i]<list[i-num]){
				int temp=i;
				int tempValue=list[i];
				boolean flag=true;
				for(int j=i-num;j>=0;j-=num){
					if(list[j]<tempValue){
						temp=j+num;
						flag=false;
						break;
					}
				}
				if(flag){
					temp=i%num;
				}
				for(int j=i;j>temp;j-=num){
					int t=list[j];
					list[j]=list[j-num];
					list[j-num]=t;
				}
			}
		}
	}

}

3.冒泡排序

相邻之间的数字进行比较，从头至尾将较大的数替换到尾部

public class BubbleSort {
	
	public void sort(int[] list){
		for(int i=0;i<list.length-1;i++){
			for(int j=0;j<list.length-i-1;j++){
				if(list[j]>list[j+1]){
					int t=list[j];
					list[j]=list[j+1];
					list[j+1]=t;
				}
			}
		}
	}
}

4.快速排序

以第一个数为flag，大的右小的左，递归进行

	public void sort(int[] list,int l,int r){
		if(l<r){
			int temp=list[l];
			int slot=l;
			int a=l;
			int b=r;
			while(a<b){
				while(a<b&&list[b]>temp)
					b--;
				if(a<b){
					list[slot]=list[b];
					slot=b;
				}
				while(a<b&&list[a]<temp)
					a++;
				if(a<b){
					list[slot]=list[a];
					slot=a;
				}
			}
			list[slot]=temp;
			sort(list,l,slot-1);
			sort(list,slot+1,r);
		}
	}
}

5.直接选择排序

每次选择无序中的最小数与无序中的第一个数交换

public class DirectSelectSort {
	
	public void sort(int[] list){
		for(int i=0;i<list.length;i++){
			int min=i;
			for(int j=i;j<list.length;j++){
				if(list[min]>list[j])
					min=j;
			}
			int t=list[min];
			list[min]=list[i];
			list[i]=t;
		}
	}
}

6.堆排序

初始化最小堆，取堆顶，堆顶和堆底调换，调整堆，继续

public class HeapSort {
	
	public void initHeap(int[] list){
		for(int i=list.length-1;i>0;i--){
			int t=i;
			while(t>0){
				if(list[t]<list[(t-1)/2]){
					int temp=list[t];
					list[t]=list[(t-1)/2];
					list[(t-1)/2]=temp;
				}
				t=(t-1)/2;
			}
		}
	}
	
	public void adjustHeap(int[] list,int last){
		int temp=0;
		while(temp<=(last-1)/2){
			int min=temp*2+1;
			if(list[temp*2+1]>list[temp*2+2]&&temp*2+2<=last){
				min=temp*2+2;
			}
			if(list[min]<list[temp]){
				int t=list[min];
				list[min]=list[temp];
				list[temp]=t;
				temp=min;
			} else break;
		}
	}
	
	public void sort(int[] list){
		this.initHeap(list);
		int[] heap=new int[list.length];
		for(int i=0;i<list.length;i++){
			heap[i]=list[i];
		}
		int flag=0;
		int last=heap.length-1;
		while(last>= 0){
			list[flag]=heap[0];
			heap[0]=heap[last];
			last--;
			flag++;
			this.adjustHeap(heap, last);
		}
	}
}

7.归并排序

public class MergeSort {
	
	public void sort(int[] list){
		mergeSort(list,0,list.length-1);
	}
	
	public void mergeSort(int[] list,int left,int right){
		int[] temp=new int[list.length];
		if(left<right){
			mergeSort(list,left,(left+right)/2);
			mergeSort(list,(left+right)/2+1,right);
			merge(list,left,right,temp);
		}
	}
	
	public void merge(int[] list,int left,int right,int[] temp){
		int i=left;
		int j=(left+right)/2+1;
		int flag=left;
		while(i<=(left+right)/2||j<=right){
			if((i<=(left+right)/2&&j<=right&&list[i]<list[j])||(i<=(left+right)/2&&j>right)){
				temp[flag]=list[i];
				i++;
			}
			else if((i<=(left+right)/2&&j<=right&&list[i]>=list[j])||(i>(left+right)/2&&j<=right)){
				temp[flag]=list[j];
				j++;
			}
			flag++;
		}
		for(int k=left;k<=right;k++){
			list[k]=temp[k];
		}
	}
}