面试中经常会被问到或现场写：冒泡、快速Java 常用排序算法_i++
（1）冒泡排序 Bubble Sort
[Java] 纯文本查看 复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
/**
- 冒泡排序
  - @param arr 需要排序的数组
    */
public void bubbleSort(int[] arr){
    for(int i= 0;i<arr.length;i++){
            for(int j = 0;j<arr.length-i-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
[Java] 纯文本查看 复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/**
      - 插入排序
  - @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
[Java] 纯文本查看 复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
/**
- 选择排序
  - @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
[Java] 纯文本查看 复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/**
        - 归并排序
    - @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
[Java] 纯文本查看 复制代码
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
  /**
          * 获得基础的下标
          * @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}

//再次封装，对外调用 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}