排序

算法都是可以互换的，每个算法都将接收包含一些元素的数组。被排序的对象属于类型。N是被排序元素的个数。

 

 

1.插入排序

插入排序由N-1趟排序组成，插入排序保证从位置0到位置p上的元素为已排序状态。

在第p趟，我们将位置p上的元素向左移动，直到它在前p+1个元素中的正确位置被找到的地方

注意：1.数组参数传入方法

           2.数组排序需写入：java.util.Arrays.sort(数组名称);

 

 

2.希尔排序：（插入排序的优化）

它通过比较相距一定间隔的元素来工作；各趟比较所用的距离随着算法的进行而减小，直到只比较相邻元素的最后一趟排序为止。

因此也叫 缩减增量排序

结果：

 

 

 

3.冒泡排序：比较相邻两个数的大小，大的下沉，小的上浮。

public class Test{
	
	public static void main(String[] args) {
		int[] a=new int[] {42,20,17,13,28,14,23,15};
		java.util.Arrays.sort(a);
		bubbleSort(a);
		System.out.println(Arrays.toString(a));
	}
	public static void bubbleSort(int[] a) {
		
		int tmp;
		for(int i=0;i<a.length-1;i++) {
			for(int j=a.length-1;j>i;j--) {
			if(a[j]<a[j-1]) {
				tmp=a[j];
				a[j]=a[j-1];
				a[j-1]=tmp;
			}
		}
		}
	} 
}

 

 

 

4.选择排序：

第一次找到最小的数，放在第一个位置。

从第二个位置起，找到第二个数，放到第二个位置。

以此类推

public class Test{
	
	public static void main(String[] args) {
		int[] a=new int[] {42,20,17,13,28,14,23,15};
		java.util.Arrays.sort(a);
		selectionSort(a);
		System.out.println(Arrays.toString(a));
	}
	public static void selectionSort(int[] a) {
		
		
		for(int i=0;i<a.length;i++) {
			int min=a[i];
			for(int j=i+1;j<a.length;j++) {
				if(a[j]<a[i]) {
					min=a[j];
				}
			}
		}
	} 
}

 

5.快速排序

取出一个key值（一般是第一个），把比它小的值放在它的左边，比它大的数放在它的右边。然后按照此方法，排列它左右两个子列，以此类推。

public class Test{
	public static void main(String[] args) {
		int[] a=new int[] {72,6,57,88,60,42,83,73,48,85};
		int l=0;
		int r=a.length-1;
		java.util.Arrays.sort(a);
		quickSort(a,l,r);
		System.out.println(Arrays.toString(a));
	}
	public static void quickSort(int a[],int l,int r){
		
	     if(l>=r)
	       return;

	     int i = l; int j = r; int key = a[l];//选择第一个数为key

	     while(i<j){

	         while(i<j && a[j]>=key) {//从右向左找第一个小于key的值
	             j--;
	         }
	         if(i<j){
	             a[i] = a[j];
	             i++;
	         }

	         while(i<j && a[i]<key) {//从左向右找第一个大于key的值
	             i++;
	         }
	         if(i<j){
	             a[j] = a[i];
	             j--;
	         }
	     }
	     //i == j
	     a[i] = key;
	     quickSort(a, l, i-1);//递归调用
	     quickSort(a, i+1, r);//递归调用
	 }
}

 

6.归并排序

基础：如果排序两个有序的子数组，可以比较两个数组的第一个数的大小，谁小取谁放到临时数组中，然后继续往下走。依次。

归并排序就是先把数组从中间分成两个数组，然后在将这两组各自再分成两组，依次，直到每组剩下一个数，然后就是最简单的有序数组了。接下来就可以按照基础那个方法排好了。

public class Test{
	public static void main(String[] args) {
		int[] a=new int[] {72,6,57,88,60,42,83,73,48,85};
		int first=0;
		int last=a.length-1;
		java.util.Arrays.sort(a);
		int[] temp=new int[a.length];
		merge_sort(a, first, last, temp);
		System.out.println(Arrays.toString(a));
	}
	public static void merge_sort(int a[],int first,int last,int temp[]){

		  if(first < last){
		      int middle = (first + last)/2;
		      merge_sort(a,first,middle,temp);//左半部分排好序
		      merge_sort(a,middle+1,last,temp);//右半部分排好序
		      mergeArray(a,first,middle,last,temp); //合并左右部分
		  }
		}
	public static void mergeArray(int a[],int first,int middle,int end,int temp[]){     
		  int i = first;
		  int m = middle;
		  int j = middle+1;
		  int n = end;
		  int k = 0; 
		  while(i<=m && j<=n){
		      if(a[i] <= a[j]){
		          temp[k] = a[i];
		          k++;
		          i++;
		      }else{
		          temp[k] = a[j];
		          k++;
		          j++;
		      }
		  }     
		  while(i<=m){
		      temp[k] = a[i];
		      k++;
		      i++;
		  }     
		  while(j<=n){
		      temp[k] = a[j];
		      k++;
		      j++; 
		  }

		  for(int ii=0;ii<k;ii++){
		      a[first + ii] = temp[ii];
		  }
		}
}

7.基数排序

先new一个下标为0到9的数组，再按个位数字把数字放在对应的下标中，然后再按十位把数字放在对应的下标中。

public class Test{

public static void main(String[] args) {
	int[] A=new int[] {27,91,1,97,17,23,84,28,72,5,67,25};
	int[] temp=new int[A.length];
	
	int n=A.length;
	int k=2;
	int r=10;
	int[] cnt=new int[A.length];
	java.util.Arrays.sort(A);
	radixSort(A,temp,n,k,r,cnt);
	System.out.println(Arrays.toString(A));
}

	public static void radixSort(int A[],int temp[],int n,int k,int r,int cnt[]){

		   //A:原数组
		   //temp:临时数组
		   //n:序列的数字个数
		   //k:最大的位数2
		   //r:基数10
		   //cnt:存储bin[i]的个数

		   for(int i=0 , rtok=1; i<k ; i++ ,rtok = rtok*r){

		       //初始化
		       for(int j=0;j<r;j++){
		           cnt[j] = 0;
		       }
		       //计算每个箱子的数字个数
		       for(int j=0;j<n;j++){
		           cnt[(A[j]/rtok)%r]++;
		       }
		       //cnt[j]的个数修改为前j个箱子一共有几个数字
		       for(int j=1;j<r;j++){
		           cnt[j] = cnt[j-1] + cnt[j];
		       }
		       for(int j = n-1;j>=0;j--){      //重点理解
		           cnt[(A[j]/rtok)%r]--;
		           temp[cnt[(A[j]/rtok)%r]] = A[j];
		       }
		       for(int j=0;j<n;j++){
		           A[j] = temp[j];
		       }
		   }
		
	
	
} 
}