冒泡、插入、选择、快速、希尔、归并排序

准备找工作了，复习数据结构时，排序这一块，具体的算法思想就不细说了，网上一查一大堆。具体参考代码在下，如有错误，望指出。

冒泡排序`

冒泡排序：

	public static void bubb_sort(int[] a ) {
		int n=a.length;
		int temp;
		for(int i=0;i<n-1;i++) {
			for(int j=i+1;j<n;j++) {
				if(a[i]>a[j]) {
					temp=a[i];
					a[i]=a[j];
					a[j]=temp;
				}
			}
		}
	}

测试：

public static void main(String[] args) {
		int[] a= {1,5,3,6,8,4,1,7,5};
		System.out.println(Arrays.toString(a));
		bubb_sort(a);
		System.out.println(Arrays.toString(a));
}

插入排序

插入排序：

public static void insert_sort(int[] a) {
	int l=a.length;
	
	int temp;
	//i是有序序列长度 a[i]要插入的数
	for(int i=1;i<l;i++) {
		//拿到前i个数
		temp=a[i];//拿到要插入的数
		int j = i-1;//拿temp  从a[j]开始向左比  
		// 比temp大向后移动  直到比temp小或者到头了.
		while(j>=0&&a[j]>temp) {
			a[j+1] = a[j--];
		}
		//把temp放到空的位置上
		a[j+1]=temp;
	}
	
}

测试：

public static void main(String[] args) {
	int[] a= {1,5,3,6,8,4,1,7,5,12};
	System.out.println(Arrays.toString(a));
	insert_sort(a);
	System.out.println(Arrays.toString(a));
	
}

选择排序

选择排序：

	public static void choose_sort(int[] a) {
		for(int i=0;i<a.length-1;i++) {
			//保存当前最小值
			int min = a[i];
			//保存最小值的下标
			int t=i;
			for(int j=i+1;j<a.length;j++) {
				if(a[j]<min) {
					//保存当前最小值
					min = a[j];
					//保存最小值的下标
					t= j;
				}
			}
			//最小值与第i位交换
			a[t] = a[i];
			a[i] = min;
			
		}
	}

测试：

	public static void main(String[] args) {
		int [] a = {6,3,52,1,2,7,2,};
		choose_sort(a);
		System.out.println(Arrays.toString(a));
	}

快速排序

快速排序：

	public static void Quick_Sort(int a[],int left,int right) {
		//一个数的时候
		if(left>=right) {
			return;
		}
		//拿到中轴
		int key=a[left];
		int i=left;
		int j=right;
		
		while(i<j) {
			//右边起找到比中轴小的数
			while(a[j]>=key&&i<j) {
				j--;
			}
			//从左边起找到比中轴大的数
			while(a[i]<=key&&i<j) {
				i++;
			}
			//交换2个数字
			if(i<j) {
				int temp;
				temp=a[i];
				a[i]=a[j];
				a[j]=temp;
			}
			
			
		}
		//把中轴和a[j]交换
		a[left]=a[j];
		a[j]=key;
		Quick_Sort(a,left,j-1);
		Quick_Sort(a,j+1,right);
		return;
		
	}

测试:

	public static void main(String[] args) {
		int[] a= {1,5,3,6,8,4,1,7,5};
		System.out.println(Arrays.toString(a));
		Quick_Sort(a,0,a.length-1);
		System.out.println(Arrays.toString(a));
		
	}

希尔排序

希尔排序：

		public static void shellsort(int[] a) {
		int l =a.length;
		int temp;
		//增量gap为数组长度一般，每次递减一半
		for(int gap=l/2; gap>0 ; gap/=2) {
			//i是有序序列长度 a[i]要插入的数
			for(int i=gap;i<l;i++) {
				//拿到前i个数
				temp=a[i];//拿到要插入的数
				int j = i-gap;//拿temp  从a[j]开始向左比  
				// 比temp大向后移动  直到比temp小或者到头了.
				while(j>=0&&a[j]>temp) {
					a[j+gap] = a[j];
					j-=gap;
				}
				//把temp放到空的位置上
				a[j+gap]=temp;
			}
			
		}
		
	}

测试：

	public static void main(String[] args) {
		int[] a= {1,5,3,6,8,4,1,7,5,12,2,3,4,5,521,5};
		System.out.println(Arrays.toString(a));
		shellsort(a);
		System.out.println(Arrays.toString(a));	
	}

归并排序

	//两路排序合并
	public static void merge_sort(int[] a,int left,int mid,int right) {//a是数组， left mid right是2个序列的划分【left,mid】,(mid,right]
		int[] temp = new int[a.length];//数组
		int i=left, j=mid+1 , k=left;
		//直到2个序列有一个或两个序列空了为止，不然就把小的放进中间数组
		while(i<=mid&&j<=right) {
			if(a[i]<a[j]) {
				temp[k]=a[i];
				k++;
				i++;
			}
			else {
				temp[k]=a[j];
				k++;
				j++;
			}
		}
		//把另一个序列剩下的接上
		while(i<=mid) {
			temp[k]=a[i];
			k++;
			i++;
		}
		while(j<=right) {
			temp[k]=a[j];
			k++;
			j++;
		}
		
		//复制数组给a
		for(int t=left;t<right;t++){
			a[t]=temp[t];
		}
	}
	//把数组拆分成两部分       拆分完调用两路合并排序  并返回结果
	public static void merge(int[] a,int l,int r) {
		
		if(l<r) {
			int mid = (l+r)/2;
			//左序列
			merge(a,l,mid);
			//右序列
			merge(a,mid+1,r);
			merge_sort(a, l, mid, r);
		}
		
	}

测试：

	public static void main(String[] args) {
		int[] a= {1,5,3,6,8,4,1,7,5,12};
		System.out.println(Arrays.toString(a));
		merge(a,0,a.length-1);
		System.out.println(Arrays.toString(a));
	}