java数据结构之常用排序算法

冒泡排序

private void maopao(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 = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

选择排序

    private void xuanze(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int min = arr[i];
            int x = -1;
            boolean b = false;
            for (int j = i; j < arr.length; j++) {
                if (arr[j] < min) {
                    b = true;
                    min = arr[j];
                    x = j;
                }
            }
            if (b) {
                int temp = arr[i];
                arr[i] = min;
                arr[x] = temp;
            }

        }
    }

插入排序

     private void charu(int[] arr2) {
         int[] arr = new int[arr2.length];
         for (int i = 0; i < arr2.length; i++) {
             arr[i] = arr2[i];
             for (int j = 0; j < i; j++) {
                 if (arr[i] >= arr[j] && arr[i] <= arr[j + 1]) {
                     arr = houyi(arr, j, i);
                 }
             }
         }
     }

     /**
      * 指定位置后移
      *
      * @param arr
      * @param j
      * @param i
      * @return
      */
     private int[] houyi(int[] arr, int j, int i) {
         int temp = arr[i];
         for (int k = i; k > j; k--) {
             arr[k] = arr[k - 1];
         }
         arr[j] = temp;
         return arr;
     }

希尔排序

     /**
      * 希尔排序
      *
      * @param arr
      */
     private void xier(int[] arr) {
         for (int i = arr.length / 2; i > 0; i = i / 2) {
             for (int j = i; j < arr.length; j++) {
                 for (int k = j - i; k >= 0; k -= i) {
                     if (arr[k] > arr[i + k]) {
                         int temp = arr[k];
                         arr[k] = arr[k + i];
                         arr[k + i] = temp;
                     }
                 }
             }
         }
     }

快速排序

     /**
      * 快速排序
      *
      * @param arr
      * @param left
      * @param right
      */
     private void kuaisu(int[] arr, int left, int right) {
         int l = left;
         int r = right;
         int pivot = arr[(left + right) / 2];
         int temp = 0;
         while (l < r) {
             while (arr[l] < pivot) {//寻找左边第一个不小于pivot的索引
                 l += 1;
             }
             while (arr[r] > pivot) {//寻找右边第一个不大于pivot的索引
                 r -= 1;
             }
             if (l >= r) {
                 break;
             }
             temp = arr[l];
             arr[l] = arr[r];
             arr[r] = temp;//左右位置的值互换
             if (arr[l] == pivot) {
                 r -= 1;
             }
             if (arr[r] == pivot) {
                 l += 1;
             }
         }
         if (l == r) {
             l += 1;
             r -= 1;
         }
         if (left < r) {
             kuaisu(arr, left, r);
         }
         if (right > l) {
             kuaisu(arr, l, right);
         }
     }

基数排序（桶排序）

  private static void radix(int[] arr) {
         int max=arr[0];
         for (int i = 1; i <arr.length ; i++) {
             if (arr[i]>max){
                 max=arr[i];
             }
         }
         int maxleng=(max+"").length();
         for (int i = 0,n=1; i <maxleng ;n*=10, i++) {
             int[][] arr2=new int[10][arr.length];
             int[] indexs=new int[10];
             int index=0;
             for (int j = 0; j <arr.length ; j++) {
                 int yushu=arr[j]/n%10;
                 arr2[yushu][indexs[yushu]]=arr[j];
                 indexs[yushu]++;
             }
             for (int j = 0; j <arr2.length ; j++) {
                 for (int a = 0; a <indexs[j] ; a++) {
                         arr[index++]=arr2[j][a];
                 }
             }
         }
     }