常用排序Java实现

常用排序Java实现

冒泡排序

基本思想：每次将最大的放到未排序序列的最后，序列后部是保持有序的

 //冒泡排序
    public static int[] maopao(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            //每次将最大的放到最后，所以j每次循环的最大值是减小的
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    arr[j] = arr[j + 1] + 0 * (arr[j + 1] = arr[j]);
                }
            }
        }
        return arr;
    }

插入排序

基本思想：由后向前遍历未排序的序列，每次保存基准值，将大于基准值的向后移动一位，遇到小于基准值的则进行交换。序列前部保持有序

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（前面已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

//插入排序
    public static int[] charu(int[] arr) {
        int temp, j;
        for (int i = 0; i < arr.length; i++) {
            temp = arr[i];
            //插入到前面已排序的中，所有j=i
            for (j = i; j > 0 && temp < arr[j - 1]; j--) {
                arr[j] = arr[j - 1];
            }
            arr[j] = temp;
        }
        return arr;
    }

选择排序

基本思想：从前向后每次找出未排序中最小的的元素，将它与未排序的序列第一位互换。这样就可以保证前面是有序的。序列前部保持有序

1. 从未排序序列中，找到关键字最小的元素
2. 如果最小元素不是未排序序列的第一个元素，将其和未排序序列第一个元素互换
3. 重复1、2步，直到排序结束。

//选择排序
    public static int[] xuanze(int[] arr) {
        int i, min;
        for (i = 0; i < arr.length; i++) {
            min = i;
            //从后部未排序中查询出最小的
            for (int j = i; j < arr.length; j++) {
                if (arr[j] <= arr[min]) {
                    min = j;
                }
            }
            if (i != min) {
                arr[i] = arr[min] + 0 * (arr[min] = arr[i]);
            }

        }
        return arr;
    }

快速排序

基本思想：将比基准值大的和小的放在基准值的边，之后递归两编的子序列。

1. left = low; right = high; 将基准数挖出形成第一个坑a[left ]。

2. right–，由后向前找比它小的数，找到后挖出此数填前一个坑a[left ]中。

3. left++，由前向后找比它大的数，找到后也挖出此数填到前一个坑a[right]中。

4. 再重复执行2，3二步，直到left==right，将基准数填入a[left]中

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

//快速排序
    public static int[] kuaisu(int[] arr) {
        quick(arr, 0, arr.length - 1);
        return arr;
    }

    public static void quick(int[] arr, int low, int high) {
        //非常重要的判断
        if (low > high) {
            return;
        }
        int left = low;
        int right = high;
        int temp = arr[low];
        while (left < right) {
            //从后面开始判断
            while (left < right && arr[right] >= temp) {
                right--;
            }
            arr[left] = arr[right];
            while (left < right && arr[left] <= temp) {
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = temp;
        quick(arr, low, left - 1);
        quick(arr, left + 1, high);
    }