排序算法java示例

排序算法java示例

package test;

import java.util.Arrays;
import java.util.function.Consumer;
import java.util.function.Function;

public class SortTest {
    public static void main(String[] args) {
        int[] temp = new int[10];
        for (int i = 0; i < 10; i++) {
            temp[i] = (int) (Math.random() * 199) - 190;
        }
        System.out.println("希尔排序");
        doSort(temp, SortTest::shellSort);
        System.out.println("插入排序");
        doSort(temp, SortTest::insertSort);
        System.out.println("选择排序");
        doSort(temp, SortTest::selectSort);
        System.out.println("选择排序优化");
        doSort(temp, SortTest::selectSortMinMax);
        System.out.println("冒泡排序");
        doSort(temp, SortTest::bubbleSort);
        System.out.println("堆排序");
        doSort(temp, SortTest::heapSort);
        System.out.println("快速排序");
        doSort(temp, (Consumer<int[]>) SortTest::quickSort);
        System.out.println("合并排序");
        doSort(temp, SortTest::doMergeSort);
        System.out.println("计数排序");
        doSort(temp, SortTest::countingSort);
        System.out.println("桶排序");
        doSort(temp, SortTest::bucketSort);
        System.out.println("基数排序基于桶排序");
        doSort(temp, SortTest::radixSortByBucket);
        System.out.println("基数排序基于计数排序");
        doSort(temp,SortTest::radixSortByCounting);
    }

    private static void doSort(int[] temp, Consumer<int[]> consumer) {
        int[] ints = Arrays.copyOf(temp, temp.length);
        System.out.println("原数组:");
        Arrays.stream(temp).forEach(i -> System.out.print(i + " "));
        Long start = System.currentTimeMillis();
        consumer.accept(ints);
        System.out.println("耗时:" + (System.currentTimeMillis() - start));
        Arrays.stream(ints).forEach(i -> System.out.print(i + " "));
        System.out.println();
    }

    private static void doSort(int[] temp, Function<int[], int[]> function) {
        int[] ints = Arrays.copyOf(temp, temp.length);
        System.out.println("原数组:");
        Arrays.stream(temp).forEach(i -> System.out.print(i + " "));
        Long start = System.currentTimeMillis();
        ints = function.apply(ints);
        System.out.println("耗时:" + (System.currentTimeMillis() - start));
        Arrays.stream(ints).forEach(i -> System.out.print(i + " "));
        System.out.println();
    }

    /*
     * 插入排序：首先将第一个元素视为有序序列，其他元素视为无序序列，
     * 然后从做到右依次将无序序列的第一个元素与有序序列从后到前进行比较，
     * 直到找到小于或等于自己的元素插入该元素后面，如果全都大于自己则放到0的位置
     * */
    private static void insertSort(int[] ints) {
        for (int index = 1; index < ints.length; index++) {
            int i = ints[index];
            int temp = index - 1;
            for (; temp >= 0; temp--) {
                if (i < ints[temp]) {
                    ints[temp + 1] = ints[temp];
                } else {
                    break;
                }
            }
            ints[temp + 1] = i;
        }
    }

    /*
     * 希尔排序：先选出一个比N小的step，把所有距离为step的元素分为一组，分别对分组后的数据进行插入排序，然后降低step值，重复以上操作
     * 直至step等于1时距离为1的进行分组等于对整个序列进行插入排序，排序完成，平均复杂度比插入排序要低点，因为先进行预排序后才对整个序列进行插入排序
     * */
    private static void shellSort(int[] ints) {
        for (int step = ints.length / 2; step > 0; step /= 2) {
            for (int index = step; index < ints.length; index++) {
                int i = ints[index];
                int temp = index - step;
                for (; temp >= 0; temp -= step) {
                    if (i < ints[temp]) {
                        ints[temp + step] = ints[temp];
                    } else {
                        break;
                    }
                }
                ints[temp + step] = i;
            }
        }
    }

    /*
     * 选择排序：每次选出最大或最小的元素，放到边上，排序完所有元素即可，优化方案为：每次找出最大和最小的元素
     * */
    private static void selectSort(int[] ints) {
        int length = ints.length;
        for (int i = 0; i < length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < length; j++) {
                if (ints[min] > ints[j]) {
                    min = j;
                }
            }
            int temp = ints[min];
            ints[min] = ints[i];
            ints[i] = temp;
        }
    }

    private static void selectSortMinMax(int[] ints) {
        int length = ints.length;
        for (int i = 0; i < length / 2; i++) {
            int min = i;
            int max = length - i - 1;
            for (int j = i + 1; j < length - i; j++) {
                if (ints[min] > ints[j]) {
                    min = j;
                } else if (ints[max] < ints[j]) {
                    max = j;
                }
            }
            int temp;
            temp = ints[i];
            ints[i] = ints[min];
            ints[min] = temp;
            if (min == max) {//如果刚好min和max交换则应该将max只回i
                max = i;
            }
            temp = ints[length - i - 1];
            ints[length - i - 1] = ints[max];
            ints[max] = temp;

        }
    }

    /*
     * 冒泡排序：左右元素相比较，左边比右边大就交换，一轮下来最右边最大，排序序列长度减一，重复执行以上操作直到排序序列长度为1时候为有序队列
     * */
    private static void bubbleSort(int[] ints) {
        int length = ints.length;
        for (int j = length; j >= 0; j--) {
            int flag = 0;
            for (int i = 0; i < j - 1; i++) {
                if (ints[i] > ints[i + 1]) {
                    flag = 1;
                    int temp = ints[i];
                    ints[i] = ints[i + 1];
                    ints[i + 1] = temp;
                }
            }
            if (flag == 0) {
                break;
            }
        }
    }

    /*
     * 堆排序：先建堆，大堆父节点比子节点大，小堆父节点比子节点小，升序建大堆，降序建小堆
     * 然后排序，把根节点和最后一个节点交换，待排序序列长度减1，调整成堆，重复上述操作直到待排序序列长度为1，排序完成
     * */

    private static void heapSort(int[] ints) {
        int length = ints.length;
        for (int root = (length - 2) / 2; root >= 0; root--) {
            adjustDown(ints, length, root);
        }
        while (length > 1) {
            int temp = ints[0];
            ints[0] = ints[length - 1];
            ints[length - 1] = temp;
            length--;
            adjustDown(ints, length, 0);
        }
    }

    /*
     * ints 待排序数组
     * length 待排序数组长度
     * root 待排序数组的根*/
    private static void adjustDown(int[] ints, int length, int root) {
        //左右子堆已经是大堆，父节点比子节点小的话往下沉，直到父节点比子节点大，或者没有子节点
        for (int i = root; i < length; ) {
            int max = i * 2 + 1;
            if (max >= length) {
                return;
            }
            if (i * 2 + 2 < length && ints[i * 2 + 1] < ints[i * 2 + 2]) {
                max = i * 2 + 2;
            }
            if (ints[i] < ints[max]) {
                int temp = ints[i];
                ints[i] = ints[max];
                ints[max] = temp;
            } else {
                return;
            }
            i = max;
        }
    }

    /*
     * 快速排序选出key,一般选最左或者最右，最左最右两指针，左指针找到比key大的或者遇到右指针就停，右指针找到比key小的或者遇到左指针就停，
     * 如果两指针都停了并且没相遇那么两指针所在位置元素交换，然后继续上述操作，直到两指针相遇
     * 如果两指针相遇则该元素和key交换，将左右序列分别执行上述操作，重复上述操作直到左右序列长度为1或者不存在时候排序完成
     *
     * key在最左，右指针先动，因为指针停下的规则是左找到大于key的，右指针找到小于key的，或者两指针相遇，如果左指针先动，恰好路途中的元素比key小，直到遇到右指针，
     * 如果右指针所在位置的元素恰好比key大，然后和key交换，则key的左边存在比key大的元素,导致结果可能乱序，当然也有可能某些情况能碰巧对，譬如相遇的时候元素比key小，那样左边序列也都比key小就可以碰巧对，例如[2,1],[3,1,2],[4,1,2,3]类似规律的比较容易推出
     * */
    private static void quickSort(int[] ints) {
        if (ints.length <= 1) {
            return;
        }
        quickSort(ints, 0, 0, ints.length - 1);
    }

    private static void quickSort(int[] ints, int key, int left, int right) {
        if (left >= right) {
            return;
        }
        while (true) {
            while (ints[right] >= ints[key] && right > left) {
                right--;
            }
            while (ints[left] <= ints[key] && left < right) {
                left++;
            }
            if (right == left) {
                break;
            }
            int temp = ints[left];
            ints[left] = ints[right];
            ints[right] = temp;
        }
        int temp = ints[left];
        ints[left] = ints[key];
        ints[key] = temp;
        quickSort(ints, key, key, left - 1);
        quickSort(ints, left + 1, left + 1, ints.length - 1);
    }

    /*
     * 归并排序：主要包含分解，合并两个操作，
     * 分解：一个序列分解成左右两个序列进行排序也就是递归调用归并排序，直到序列长度为1
     * 合并：合并两个序列的过程就是两个指针分别指向两个序列的首个元素，对所指元素进行比较，将小的元素放到合并空间，对应指针向后移动，
     * 重复该操作直到其中一个指针遍历完所在序列，另一个序列直接把剩下的元素复制到合并空间
     * */
    private static int[]  doMergeSort(int[] ints) {
        return mergeSort(ints);
    }

    private static int[] mergeSort(int[] ints) {
        int length = ints.length;
        if (length < 2) {
            return ints;
        }
        int mid = length / 2;
        int[] left = Arrays.copyOf(ints, mid);
        int[] right = Arrays.copyOfRange(ints, mid, length);
        int[] result = merge(mergeSort(left), mergeSort(right));
        return result;
    }

    private static int[] merge(int[] left, int[] right) {
        int leftLength = left.length;
        int rightLength = right.length;
        int[] result = new int[leftLength + rightLength];
        int indexL = 0;
        int indexR = 0;
        int index = 0;
        while (indexL < leftLength && indexR < rightLength) {
            if (left[indexL] <= right[indexR]) {
                result[index++] = left[indexL++];
            } else {
                result[index++] = right[indexR++];
            }
        }
        while (indexL < leftLength) {
            result[index++] = left[indexL++];
        }
        while (indexR < rightLength) {
            result[index++] = right[indexR++];
        }
        return result;
    }

    /*
     * 基数排序：使用于小范围整数排序
     * 先找出最大和最小的数max，min，创建数组int[max-min+1]
     * 遍历待排序序列，值对应映射下标的int数组的元素++，下标为key-min
     * 从左到右遍历数组，插入到原来的待排序序列，从下标0开始逐一覆盖
     * */
    private static void countingSort(int[] ints) {
        int[] maxAndMin = findMaxAndMin(ints);
        int max = maxAndMin[0];
        int min = maxAndMin[1];
        int[] count = new int[max - min + 1];
        for (int i : ints) {
            count[i - min]++;
        }
        int index = 0;
        for (int i = 0; i < count.length; i++) {
            int value = min + i;
            while (count[i] > 0) {
                ints[index++] = value;
                count[i]--;
            }
        }
    }

    /*
     * 桶排序：将待排序数组按大小顺序放到不同的桶里，然后分别对桶里的序列进行排序，最后将桶里的序列拼接起来
     * */
    private static void bucketSort(int[] ints) {
        int[] maxAndMin = findMaxAndMin(ints);
        int max = maxAndMin[0];
        int min = maxAndMin[1];
        int bucketSize = 10;
        int bucketCount = (max - min) / bucketSize + 1;
        int[][] bucketArray = new int[bucketCount][0];
        for (int i : ints) {
            int index = (i - min) / bucketSize;
            bucketArray[index] = append(bucketArray[index], i);
        }
        for (int[] bucket : bucketArray) {
            if (bucket.length > 1) {
                insertSort(bucket);
            }
        }
        int index = 0;
        for (int[] bucket : bucketArray) {
            for (int i : bucket) {
                ints[index++] = i;
            }
        }
    }

    private static int[] append(int[] ints, int i) {
        int[] newInts = Arrays.copyOf(ints, ints.length + 1);
        newInts[newInts.length - 1] = i;
        return newInts;
    }

    private static int[] findMaxAndMin(int[] ints) {
        int max = ints[0];
        int min = ints[0];
        for (int i : ints) {
            if (max < i) {
                max = i;
            }
            if (min > i) {
                min = i;
            }
        }
        return new int[]{max, min};
    }

    /*
     * 基数排序：找出最大值的位数，
     * 从低位开始排序，因为就-9->9所以可以用桶排序或者计数排序，假设是桶排序，排完序之后将元素依次取出，重复此操作直到最高位排序结束
     * 如果是计数排序就麻烦点排完之后，遍历原序列找出当前的位对应数值的桶的大小，该大小就是本轮排序的位置，（不稳定）
     * */
    private static void radixSortByBucket(int[] ints) {
        int[] maxAndMin = findMaxAndMin(ints);
        int max = Math.abs(maxAndMin[0]);//记录最大值和最小值的绝对值
        int min = Math.abs(maxAndMin[1]);
        max = max>min?max:min;//位数最长的值
        int length = 0;
        while (max > 0) {
            length++;
            max /= 10;
        }
        int dev = 1;
        for (int i = 0; i < length; i++, dev *= 10) {
            int index = 0;
            int[][] bucketArray = new int[19][0];
            for (int j : ints) {
                index = j / dev % 10 + 9;
                bucketArray[index] = append(bucketArray[index], j);
            }
            index = 0;
            for (int[] bucket : bucketArray) {
                for (int b : bucket) {
                    ints[index++] = b;
                }
            }
        }
    }

    private static void radixSortByCounting(int[] ints) {
        int[] maxAndMin = findMaxAndMin(ints);
        int max = Math.abs(maxAndMin[0]);//记录最大值和最小值的绝对值
        int min = Math.abs(maxAndMin[1]);
        max = max>min?max:min;//位数最大的
        int length = 0;
        while (max > 0) {
            length++;
            max /= 10;
        }
        int dev = 1;
        for (int i = 0; i < length; i++, dev *= 10) {
            int[] count = new int[19];
            for (int j : ints) {
                count[j / dev % 10 + 9]++;
            }
            //统计下标对应的值排序后的起始下标
            int pre=count[0];
            count[0]=0;
            for(int index=1;index<count.length;index++){
                int temp=count[index];
                count[index]=pre+count[index-1];
                pre=temp;
            }

            int[] temp = Arrays.copyOf(ints,ints.length);
            for(int t:temp){
                int index = count[t / dev % 10 + 9]++;
                ints[index]=t;
            }
        }
    }
}