各种排序算法总结

暂做笔记，以后再详细整理。

一、插入排序

1、直接插入排序

public class InsertSort {
    public static void insertSort(int[] nums) {
        int size = nums.length;
        for (int i = 1; i < size; i++) {
            if (nums[i] < nums[i - 1]) {
                int j = i;
                int tmp = nums[j];
                while (j > 0 && tmp < nums[j - 1]) {
                    nums[j] = nums[j - 1];
                    j--;
                }
                nums[j] = tmp;
            }
        }
    }

    public static void main(String[] args) {
        int[] a = {1,0,63,2,58,42,6,31,12,13,2,13,0,15};
        //InsertSort.insertSort(a);
        ShellSort.shellSort(a);
        System.out.println(Arrays.toString(a));
    }
}

2、希尔排序

public class ShellSort {
    public static void shellSort(int[] nums) {
        int gap = nums.length / 2;
        while (gap >= 1) {
            InsertInShell(nums, gap);
            gap /= 2;
        }
    }

    private static void InsertInShell(int[] nums, int gap) {
        int size = nums.length;
        for (int i = gap; i < size; i++) {
            if (nums[i] < nums[i - gap]) {
                int j = i;
                int tmp = nums[j];
                while (j - gap >= 0 && tmp < nums[j - gap]) {
                    nums[j] = nums[j - gap];
                    j -= gap;
                }
                nums[j] = tmp;
            }
        }
    }

    public static void main(String[] args) {
        int[] a = {1,0,63,2,58,42,6,31,12,13,2,13,0,15};
        //InsertSort.insertSort(a);
        ShellSort.shellSort(a);
        System.out.println(Arrays.toString(a));
    }
}

二、选择排序
1、简单选择

public class SimpleSelectSort {
    public static void simpleSelectSort(int[] nums) {
        int size = nums.length;
        for (int i = 0; i < size; i++) {
            int k = selectMin(nums, i, size);
            if (k != i) {
                int tmp = nums[i];
                nums[i] = nums[k];
                nums[k] = tmp;
            }
        }
    }

    private static int selectMin(int[] nums,int start, int end) {
        int k = start;
        for (int i = start + 1; i < end; i++) {
            if (nums[k] > nums[i]) {
                k = i;
            }
        }
        return k;
    }

    public static void main(String[] args) {
        int[] a = {1,0,63,2,58,42,6,31,12,13,2,13,0,15};
        //SimpleSelectSort.simpleSelectSort(a);
        SimpleSelectSort.selectSort2(a);
        System.out.println(Arrays.toString(a));
    }
}

双向简单选择

public class SimpleSelectSort {
    public static void selectSort2(int[] nums) {
        int min = 0, max = 0, tmp;
        int size = nums.length;
        for (int i = 0; i <= size/2; i++) {
            max = i;
            min = i;
            for (int j = i; j < size - i; j++) {
                if (nums[max] < nums[j]) {
                    max = j;
                    continue;
                }
                if (nums[min] > nums[j]) {
                    min = j;
                }
            }
            //最大值在区间最左边，最小值在区间最右边，直接交换两个值就可以了。
            if (max == i && min == size - i - 1) {
                tmp = nums[min];
                nums[min] = nums[max];
                nums[max] = tmp;
            } else if (max == i) {
                //最大值在区间最左边，最小值在区间内。
                // 这时候是最左、最右、最小三个值交换
                tmp = nums[min];
                nums[min] = nums[size - i - 1];
                nums[size - i - 1] = nums[max];
                nums[max] = tmp;
            } else if (min == size - i - 1) {
                //最小值再区间最右边，最大值在区间内。
                // 这时候也是三个值交换
                tmp = nums[max];
                nums[max] = nums[i];
                nums[i] = nums[min];
                nums[min] = tmp;
            } else {
                //最大值、最小值均在区间内。这时候是四个值交换
                tmp = nums[i];
                nums[i] = nums[min];
                nums[min] = tmp;
                tmp = nums[size - i - 1];
                nums[size - i - 1] = nums[max];
                nums[max] = tmp;
            }
        }
    }
    public static void main(String[] args) {
        int[] a = {1,0,63,2,58,42,6,31,12,13,2,13,0,15};
        //SimpleSelectSort.simpleSelectSort(a);
        SimpleSelectSort.selectSort2(a);
        System.out.println(Arrays.toString(a));
    }
}

2、堆排序

public class HeapSort {
    public static void heapSort(int[] nums) {
        int size = nums.length - 1;
        for (int i = (size - 1) / 2; i >= 0; i--) {
            adjustHeap(nums, size, i);
        }
        for (int i = size - 1; i > 0; i--) {
            int tmp = nums[i];
            nums[i] = nums[0];
            nums[0] = tmp;
            adjustHeap(nums, i, 0);
        }
    }

    private static void adjustHeap(int[] nums, int size, int pos) {
        int lchild = pos * 2 + 1;
        int rchild = lchild + 1;
        int position = pos;
        if (lchild < size && nums[lchild] > nums[pos]) {
            position = lchild;
        }
        if (rchild < size && nums[rchild] > nums[position]) {
            position = rchild;
        }
        if (position != pos) {
            int tmp = nums[pos];
            nums[pos] = nums[position];
            nums[position] = tmp;
            adjustHeap(nums, size, position);
        }
    }
    public static void main(String[] args) {
        int[] a = {1,0,63,2,58,42,6,31,12,13,2,13,0,15};
        HeapSort.heapSort(a);
        System.out.println(Arrays.toString(a));
    }
}

三、交换排序

1、冒泡排序（包括优化后的冒泡和双向冒泡）

public class BubbleSort {
    public static void bubbleSort(int[] nums) {
        int size = nums.length;
        boolean exchange = true;
        int band = size - 1;
        while (exchange) {
            exchange = false;
            int k = 0;
            for (int i = 0; i < band; i++) {
                if (nums[i] > nums[i + 1]) {
                    int tmp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = tmp;
                    k = i;
                    exchange = true;
                }
            }
            band = k;
        }
    }

    public static void doubleBubbleSort(int[] nums) {
        int low = 0;
        int high = nums.length - 1;
        while (low < high) {
            for (int i = low; i < high; i++) {
                if (nums[i] > nums[i + 1]) {
                    int tmp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = tmp;
                }
            }
            high--;
            for (int i = high; i > low; i--) {
                if (nums[i] < nums[i - 1]) {
                    int tmp = nums[i];
                    nums[i] = nums[i - 1];
                    nums[i - 1] = tmp;
                }
            }
            low++;
        }
    }

    public static void main(String[] args) {
        int[] a = {1,0,63,2,58,42,6,31,12,13,2,13,0,15};
        //bubbleSort(a);
        doubleBubbleSort(a);
        System.out.println(Arrays.toString(a));
    }
}

2、快速排序

public class QuickSort {
    public static void quickSort(int[] nums) {
        sort(nums, 0, nums.length - 1);
    }

    private static void sort(int[] nums, int left, int right) {
        if (left < right) {
            int low = left;
            int high = right;
            int key = nums[left];
            while (low < high) {
                while (low < high && key <= nums[high]) {
                    high--;
                }
                nums[low] = nums[high];
                while (low < high && key >= nums[low]) {
                    low++;
                }
                nums[high] = nums[low];
            }
            nums[low] = key;
            sort(nums, left, low - 1);
            sort(nums, low + 1, right);
        }
    }
    public static void main(String[] args) {
        int[] a = {1,0,63,2,58,42,6,31,12,13,2,13,0,15};
        QuickSort.quickSort(a);
        System.out.println(Arrays.toString(a));
    }
}

四、归并排序

public class MergeSort {
    public static void mergeSort(int[] nums, int first, int end, int[] tmp) {
        if (first < end) {
            int mid = (first + end) / 2;
            mergeSort(nums, first, mid, tmp);
            mergeSort(nums, mid + 1, end, tmp);
            merge(nums, first, mid, end, tmp);
        }
    }

    public static void merge(int[] nums, int first, int mid, int end, int[] tmp) {
        int i = first, m = mid, j = mid + 1, n = end;
        int k = 0;
        while (i <= m && j <= n) {
            if (nums[i] <= nums[j]) {
                tmp[k++] = nums[i++];
            } else {
                tmp[k++] = nums[j++];
            }
        }
        while (i <= m) {
            tmp[k++] = nums[i++];
        }
        while (j <= n) {
            tmp[k++] = nums[j++];
        }
        for (int p = 0; p < k; p++) {
            nums[first + p] = tmp[p];
        }
    }
    public static void main(String[] args) {
        int[] a = {1,0,63,2,58,42,6,31,12,13,2,13,0,15};
        MergeSort.mergeSort(a, 0, a.length - 1, new int[a.length]);
        System.out.println(Arrays.toString(a));
    }
}

五、拓扑排序

public class Topological {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        Map<Integer, List<Integer>> graph = new HashMap<>();
        for (int i = 0; i < numCourses; i++) {
            graph.put(i, new ArrayList());
        }
        for (int[] prerequisite : prerequisites) {
            graph.get(prerequisite[1]).add(prerequisite[0]);
        }
        int[] preNum = new int[numCourses];
        for (int i = 0; i < numCourses; i++) {
            for (Integer integer : graph.get(i)) {
                preNum[integer]++;
            }
        }
        for (int i = 0; i < numCourses; i++) {
            int j;
            for (j = 0; j < numCourses; j++) {
                if (preNum[j] == 0) {
                    break;
                }
            }
            if (j == numCourses) {
                return false;
            }
            preNum[j] = -1;
            for (Integer integer : graph.get(j)) {
                preNum[integer]--;
            }
        }
        return true;
    }
}