java排序算法

从今天开始补数据结构与算法！！！
详情点击标题跳转

选择排序

  private static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    swap(arr, i, j);
                }
            }
        }
    }

冒泡排序

 public static void Bubble(int[] arr) {
        for (int i = 0,count=0; i < arr.length - 1; 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;
                }

            }
            count++;
            System.out.println("第"+count+"次冒泡排序：");
            printArray(arr);
        }
    }

插入排序

private static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
                swap(arr, j, j - 1);
            }
        }
    }

希尔排序

  private static void sellSort(int[] arr) {
        //将a[]按升序排列
        int N = arr.length;
        int h = 1;
        while (h < N / 3) {
            h = 3 * h + 1;
        }
        while (h >= 1) {
            // 将数组变为h有序
            for (int i = h; i < N; i++) {
                for (int j = i; j >= h && arr[j] < arr[j - h]; j -= h) {
                    swap(arr, j, j - h);
                }
            }
            h = h / 3;
        }
    }

归并排序

  //分+合的方法
    private static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;//中间索引
            //向左递归进行分解
            mergeSort(arr, left, mid, temp);
            mergeSort(arr, mid + 1, right, temp);
            merge(arr, left, mid, right, temp);
        }
    }

    //合并
    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left;  //初始化i，左边有序序列的初始索引
        int j = mid + 1; //初始化j，右边有序序列的初始索引
        int t = 0; //临时数组的当前索引

        //一
        //先把左右两边（有序） 的数据按照规则填充到temp数组
        //直到左右两边的有序序列，又一遍处理完为止
        while (i <= mid && j <= right) {
            if (arr[i] < arr[j]) {
                temp[t++] = arr[i++];
            } else {
                temp[t++] = arr[j++];
            }
        }
        //二
        //把有剩余数据的一遍的数据依次全部填充到temp
        while (i <= mid) {
            temp[t++] = arr[i++];
        }
        while (j <= right) {
            temp[t++] = arr[j++];
        }
     
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft++] = temp[t++];
        }
    }

快速排序

   private static void quickSort(int[] arr, int low, int high) {
        int i, j, temp, t;
        if (low > high) {
            return;
        }
        i = low;
        j = high;
        //t是基准位
        t = arr[low];

        while (i < j) {
            //先看右边，依次往左递减
            while (t <= arr[j] && i < j) {
                j--;
            }
            //再看左边,依次往右递减
            while (t >= arr[i] && i < j) {
                i++;
            }

            //如果满足条件则交换
            if (i < j) {
                temp = arr[j];
                arr[j] =arr[i];
                arr[i]=temp;
            }
        }
        //最后将基准为i和j相等位置的数字交换
        arr[low] = arr[i];
        arr[i] = t;

        quickSort(arr,low,j-1);
        quickSort(arr,j+1,high);
    }