八大排序

插入排序

1.直接插入排序

   基本思想是将左边视为有序数组，遍历右边数字来不断插入左边有序数组，使得左边有序数组不断壮大。

public void insert(int[] arr){
		for(int i=1;i<arr.length;i++){
			for(int j=i-1;j>=0;j--){
				int cmp =arr[j+1];
				if(arr[j]>cmp){
					int rep = arr[j];
					arr[j] = cmp;
					arr[j+1] = rep;
				}
			}
		}
		
	}

---

2.希尔排序

   直接插入排序的变种，只是每次的尺度从1 变成k，逐渐递减到1.

public void heer(int []array){
        int n = array.length;
        while(n/3!=1){
        	insert(array, n/3);
        	n = n/3;
        }
        insert(array, 1);
	}
	
	public void insert(int[] arr,int k){
		for(int y=0;y<k;y++){
		for(int i=y+k;i<arr.length;i=i+k){
			for(int j=i-k;j>=0;j=j-k){
				int cmp =arr[j+k];
				if(arr[j]>cmp){
					int rep = arr[j];
					arr[j] = cmp;
					arr[j+k] = rep;
				}else
					break;
			}
		}
	}
	}

---

---

选择排序

1.简单选择排序

    按位置找对应的数，第一位找最小的数放在第一位，第二位找第二小的数放在第二位。

public void choose(int []array){
		int n = array.length;
		for(int i=0;i<n;i++){
			int cmp = array[i];
			for(int j=i+1;j<n;j++){
				
				if(array[j]<cmp){
					array[i] = array[j];
					array[j] = cmp;
					cmp = array[i];
				}
			}
		}
		
	}

---

2.堆排序

---

---

交换排序

1.冒泡排序

public void bubble(int []array){
         int n = array.length;
         
         int rep =0;
         for(int i=0;i<n;i++){
        	 for(int j=0;j<n-i-1;j++){ 
        		 if(array[j]>array[j+1]){
        			rep = array[j];
        			array[j] = array[j+1];
        			array[j+1]=rep;
        		 }
        	 }
         }	
	}

---

2.快速排序

快速排序的基本思想是每次取第一个元素作为中间元素，将原数组分为两部分，然后进行递归调用。

 public static void quickSort(int []array,int loS,int hiS){
		 int lo = loS;
		 int hi = hiS;
		 if(hi==lo)
			 return;
		 int cmp = array[lo];
		 
		 while(lo<hi){
			 while(array[hi]>cmp)
				 hi--;
			 if(lo>=hi)
				break;
			 array[lo] = array[hi];
			 array[hi] = cmp;
			 while(array[lo]<cmp)
			      lo++;
			 if(lo>=hi)
				 break;
			 array[hi] = array[lo];
			 array[lo] = cmp;
			 
		 }
		 if(lo>loS)
			 quickSort(array, loS, lo-1);
		 if(hi<hiS)
			 quickSort(array, hi+1, hiS);
	 
	 }

 

---

---

归并排序

 

基数排序