day04_ JavaSE03 常用排序算法

常用排序算法

面試中經常會被問到或現場寫：冒泡、快速

---

（1）冒泡排序 Bubble Sort

• •    /**
       - 冒泡排序
         - @param arr 需要排序的數組 
           */
       public void bubbleSort(int[] arr){ 
           for(int i= 0;i<arr.length;i++){
           	for(int j = 0;j<arr.length-1;j++){
           		if(arr[j]  > arr[j+1]){
           			int temp;
           			temp = arr[j];
           			arr[j] = arr[j+1];
           			arr[j+1] = temp;
           		}				 
           	}
           	System.out.print(arr[i]  + ",");
           }
       }
    

---

（2）插入排序 Insert Sort

   /**
	- 插入排序
    - @param arr 需要排序的數組 
    */
    public static void insertSort(int[] arr){  
      int length=arr.length; //數組長度  
      int j;               //當前值的位置  
      int i;               //指向j前的位置  
      int key;             //當前要進行插入排序的值  
         //61,19,56,37,20     ,66,50,34,37,3
        // 19 37 56 61 
        /*
        	key  = 20
        	j =4;
        	i = j-1 = 3
        	a[4] = a[3]
        	19 37 56 61 61
        	i = 2 56 > 20
        	a[3]=a[2]
        	19 37 56 56 61
        	i = 1 37 > 20
        	a[2] = a[1]
        	19 37 37 56 61
        	i =0 19 > 20 false
        	a[1] = key =20
        	
        */
      //從數組的第二個位置開始遍歷值  
      for(j=1;j<length;j++){  
       key=arr[j];  
       i=j-1;  
       //a[i]比當前值大時，a[i]後移一位,空出i的位置，好讓下一次循環的值後移  
       while(i>=0 && arr[i]>key){  
           arr[i+1]=arr[i]; //將a[i]值後移  
           i--;         //i前移  
       }//跳出循環(找到要插入的中間位置或已遍歷到0下標)  
       arr[i+1]=key;    //將當前值插入  
      }  
     }  

---

（3）選擇排序 Select Sort

/**
- 選擇排序
  - @param arr 需要排序的數組 
*/
 public static void selectSort(int[] arr) { 
     for (int i = 0; i < arr.length; i++) {  
         int min = i; / 將當前下標定義爲最小值下標 
  		 for (int j = i + 1; j < arr.length; j++) {  
                if (arr[min] > arr[j]) { /* 如果有小於當前最小值的關鍵字 */  
                    min = j; /* 將此關鍵字的下標賦值給min */  
                }  
          }  
          if (i != min) {/* 若min不等於i，說明找到最小值，交換 */  
                int tmp = arr[min];  
                arr[min] = arr[i];  
                arr[i] = tmp;  
          }  
        }  
    }  

---

（4）歸併排序 Merge Sort

/**
	- 歸併排序 
    - @param a 需要排序的數組
    - @param s 第一個有序表的起始下標 
    - @param m 第二個有序表的起始下標 
    - @param t 第二個有序表的結束下標 
    - */  
 public static void merge(int[] arr, int s, int m, int t) {  
  int[] tmp = new int[t - s + 1];  

    int i = s, j = m, k = 0;  
	  while (i < m && j <= t) {  
	   if (arr[i] <= arr[j]) {  
	    tmp[k] = arr[i];  
	    k++;  
	    i++;  
	   } else {  
	    tmp[k] = arr[j];  
	    // sum += (j - i) - (j - m);  
	    j++;  
	    k++;  
	   }  
	  }  
	  while (i < m) {  
	   tmp[k] = arr[i];  
	   i++;  
	   k++;  
	  }  
	  
	  while (j <= t) {  
	   tmp[k] = arr[j];  
	   j++;  
	   k++;  
	  }  	  
	  System.arraycopy(tmp, 0, arr, s, tmp.length);  
} 

---

（5）快速排序 Quick Sort

  /**
	  * 獲得基礎的下標
	  * @param arr 需要排序的數組
	  * @param low 數組待排序的最小的下標
	  * @param high 數組待排序的最大的下標
	  * @return 返回中軸值（該值大於左邊值，小於右邊值）
	  */
	  public static  int getMiddle(int[] arr,int low,int high){
        int temp = arr[low];// temp = 12 = arr[0]
        while(low <high){// 0<1
            while(low <high && arr[high] > temp){//0<1  && 14>12
                high--;//h  = 0
            }
            arr[low] = arr[high]; // a[0] = a[0];
            while(low <high && arr[low] <=temp){//
                low++;
            }
            arr[high] = arr[low];//a[0] = a[0]
        }
        arr[low] = temp;//a[0] = 12
        return low;//0
    } 

    public  static void quickSort(int[] arr,int low, int high){
    if(low <high){//0,1
        //將數組一份爲二
        int middle = getMiddle(arr, low, high);// arr 0,9  m = 4

        System.out.println("middle = " + middle);//m =4
        //左邊進行遞歸 快速排序
        quickSort(arr,low,middle -1);  // arr 0,3
        //右邊進行遞歸 快速排序
        quickSort(arr,middle + 1,high);// arr 5,9
    }
}

//再次封裝，對外調用  12，14
public static void quick(int[] arr){
    if(arr.length  >=2)
        quickSort(arr, 0, arr.length -1);// 0,9
}

int[] a ={}
int[] a ={65}
int[] a ={65,76}