第四章：排序算法

常用排序算法：

快速排序

package LeetCode.test4_paixusuanfa.demo;

import java.util.Arrays;

/**
 * 快速排序
 * 将小于基准数的放置于基准数左边，大于基准数的放置于基准数右边
 */
public class 快速排序 {
    public static void main(String[] args) {
        int[] num = {7, 1, 3, 5, 13, 9, 3, 6, 11};
        quick_sort(num, 0, num.length - 1);
        System.out.println(Arrays.toString(num));
    }

    public static void quick_sort(int[] num, int l, int r) {
        if (l > r) {
            return;
        }
        int left = l;
        int right = r;
        int res = num[left];
        while (left < right) {
            while (left < right && num[right] >= res) {
                right--;
            }
            if (left < right) {
                num[left] = num[right];
            }
            while (left < right && num[left] <= res) {
                left++;
            }
            if (left < right) {
                num[right] = num[left];
            }
            if (left == right) {
                num[left] = res;
            }
        }
        quick_sort(num, l, right - 1);
        quick_sort(num, right + 1, r);
    }
}

归并排序

package LeetCode.test4_paixusuanfa.demo;

import java.util.Arrays;

public class 归并排序 {
    public static void main(String[] args) {
        int[] num = {7, 1, 3, 5, 13, 9, 3, 6, 11};
        int[] temp = new int[num.length];
        merge_sort(num, temp, 0, num.length - 1);
        System.out.println(Arrays.toString(num));
    }

    public static void merge_sort(int[] num, int[] temp, int left, int right) {
        if (left < right) {
            int mid = left + ((right - left) >> 1);
            merge_sort(num, temp, left, mid); //左边归并排序，使得左子序列有序
            merge_sort(num, temp, mid + 1, right); //右边归并排序，使得右子序列有序
            merge(num, temp, mid, left, right); //将两个有序子数组合并操作
        }
    }

    public static void merge(int[] num, int[] temp, int mid, int left, int right) {
        int i = left;
        int j = mid + 1;
        int t = 0;
        while (i <= mid && j <= right) {
            if (num[i] < num[j]) {
                temp[t++] = num[i++];
            } else {
                temp[t++] = num[j++];
            }
        }
        while (i <= mid) { //将左边剩余元素填充进temp中
            temp[t++] = num[i++];
        }
        while (j <= right) { //将右序列剩余元素填充进temp中
            temp[t++] = num[j++];
        }
        t = 0;
        while (left <= right) { //将temp中的元素全部拷贝到原数组中
            num[left++] = temp[t++];
        }
    }
}

插入排序

package LeetCode.test4_paixusuanfa.demo;

import java.util.Arrays;

public class 插入排序 {
    public static void main(String[] args) {
        int[] num = {7, 1, 3, 5, 13, 9, 3, 6, 11};
        insert_sort(num);
        System.out.println(Arrays.toString(num));
    }

    public static void insert_sort(int[] num) {
        for (int i = 1; i < num.length; i++) {
            for (int j = i; j > 0; j--) {
                if (num[j] < num[j - 1]) {
                    int temp = num[j];
                    num[j] = num[j - 1];
                    num[j - 1] = temp;
                }
            }
        }
    }
}

冒泡排序

package LeetCode.test4_paixusuanfa.demo;

import java.util.Arrays;

public class 冒泡排序 {
    public static void main(String[] args) {
        int[] num = {7, 2, 3, 5, 13, 9, 3, 1, 6, 11};
        bubble_sort(num);
        System.out.println(Arrays.toString(num));
    }

    public static void bubble_sort(int[] num) {
        for (int j = 0; j < num.length; j++) {
            for (int i = j+1; i < num.length; i++) {
                if (num[i] < num[j]) {
                    int temp = num[i];
                    num[i] = num[j];
                    num[j] = temp;
                }
            }
        }
    }
}

选择排序

package LeetCode.test4_paixusuanfa.demo;

import java.util.Arrays;

public class 选择排序 {
    public static void main(String[] args) {
        int[] num = {7, 2, 3, 5, 13, 9, 3, 1, 6, 11};
        select_sort(num);
        System.out.println(Arrays.toString(num));
    }

    public static void select_sort(int[] num) {
        for (int i = 0; i < num.length; i++) {
            int res = i;
            for (int j = i + 1; j < num.length; j++) {
                if (num[j] < num[res]) {
                    res = j;
                }
            }
            int temp = num[res];
            num[res] = num[i];
            num[i] = temp;
        }
    }
}

1、寻找两个正序数组的中位数

问题：给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
示例 3：

输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000
示例 4：

输入：nums1 = [], nums2 = [1]
输出：1.00000
示例 5：

输入：nums1 = [2], nums2 = []
输出：2.00000

package LeetCode.test4_paixusuanfa;

public class ques_4_寻找两个正序数组的中位数 {
    public static void main(String[] args) {
        int[] nums1 = {1, 2};
        int[] nums2 = {3, 4};
        System.out.println(findMedianSortedArrays(nums1, nums2));
    }

    public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int[] temp = new int[nums1.length + nums2.length];
        int t = 0, n1 = 0, n2 = 0;
        while (n1 < nums1.length && n2 < nums2.length) {
            temp[t++] = nums1[n1] < nums2[n2] ? nums1[n1++] : nums2[n2++];
        }
        while (n1 < nums1.length) {
            temp[t++] = nums1[n1++];
        }
        while (n2 < nums2.length) {
            temp[t++] = nums2[n2++];
        }
        int l = nums1.length + nums2.length;
        int mid = l / 2;
        return l % 2 == 0 ? ((double)(temp[mid - 1] + temp[mid])) / 2 : temp[mid];
    }
}

2、数组中的第K个最大元素

 问题：给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

package LeetCode.test4_paixusuanfa;

public class ques_215_数组中的第K个最大元素 {
    public static void main(String[] args) {
        int[] nums = {3, 2, 1, 5, 6, 4};
        int k = 2;
        System.out.println(findKthLargest(nums, k));
    }

    public static int findKthLargest(int[] nums, int k) {
        if (k > nums.length) {
            return -1;
        }
        quick_sort(nums, k, 0, nums.length - 1);
        return nums[k - 1];
    }

    public static void quick_sort(int[] nums, int k, int l, int r) {
        int left = l;
        int right = r;
        int res = nums[left];
        while (left < right) {
            while (left < right && nums[right] <= res) {
                right--;
            }
            if (left < right) {
                nums[left] = nums[right];
            }
            while (left < right && nums[left] >= res) {
                left++;
            }
            if (left < right) {
                nums[right] = nums[left];
            }
            if (left == right) {
                nums[left] = res;
            }
        }
        if ((k - 1) < right) {
            quick_sort(nums, k, l, right - 1);
        } else if ((k - 1) > right) {
            quick_sort(nums, k, right + 1, r);
        }
    }
}

3、前K个高频元素

问题：给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:

输入: nums = [1], k = 1
输出: [1]

package LeetCode.test4_paixusuanfa;

import java.util.*;

public class ques_347_前K个高频元素 {
    public static void main(String[] args) {
        int[] nums = {1, 1, 1, 2, 2, 3, 4};
        int k = 2;
        System.out.println(Arrays.toString(topKFrequent(nums, k)));
    }

    public static int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        for (Integer num : nums) { // 统计频率
            map.put(num, map.getOrDefault(num, 0) + 1);
        } // {1=3, 2=2, 3=1, 4=1}

        //桶的索引指的就是元素的个数  eg:value值为3，就把1放在索引为3的桶里
        List<Integer>[] bucket = new List[nums.length + 1];
        // 遍历map，根据value值放到对应的桶中
        for (Map.Entry<Integer, Integer> e : map.entrySet()) {
            Integer value = e.getValue();
            if (bucket[value] == null) {
                bucket[value] = new ArrayList<>();
            }
            bucket[value].add(e.getKey());
        } // [null, [3, 4], [2], [1], null, null, null, null]

        List<Integer> list = new ArrayList<>();
        for (int i = bucket.length - 1; i >= 0 && list.size() < k; i--) {
            if (bucket[i]!=null){
                list.addAll(bucket[i]);
            }
        }
        int[] arr = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            arr[i] = list.get(i);
        }
        return arr;
    }
}

4、根据字符出现频率排序

问题：给定一个字符串，请将字符串里的字符按照出现的频率降序排列。

示例 1:

输入:
"tree"

输出:
"eert"

解释:
'e'出现两次，'r'和't'都只出现一次。
因此'e'必须出现在'r'和't'之前。此外，"eetr"也是一个有效的答案。
示例 2:

输入:
"cccaaa"

输出:
"cccaaa"

解释:
'c'和'a'都出现三次。此外，"aaaccc"也是有效的答案。
注意"cacaca"是不正确的，因为相同的字母必须放在一起。
示例 3:

输入:
"Aabb"

输出:
"bbAa"

解释:
此外，"bbaA"也是一个有效的答案，但"Aabb"是不正确的。
注意'A'和'a'被认为是两种不同的字符。

package LeetCode.test4_paixusuanfa;

import java.util.*;

public class ques_451_根据字符出现频率排序 {
    public static void main(String[] args) {
//        String s = "Aabb";
//        String s = "tree";
        String s = "cccaaa";
        System.out.println(frequencySort(s));
    }

    public static String frequencySort(String s) {
        char[] chars = s.toCharArray();
        Map<Character, Integer> map = new HashMap<>();
        for (char c : chars) { // 统计频率
            map.put(c, map.getOrDefault(c, 0) + 1);
        }

        List<Character>[] bucket = new List[chars.length + 1];
        for (Map.Entry<Character, Integer> m : map.entrySet()) {
            Integer value = m.getValue();
            if (bucket[value] == null) {
                bucket[value] = new ArrayList<>();
            }
            bucket[value].add(m.getKey());
        }

        List<Character> list = new ArrayList<>();
        for (int i = bucket.length - 1; i >= 0; i--) {
            if (bucket[i] != null) {
                for (int j = 0; j < bucket[i].size(); j++) {
                    for (int k = 0; k < i; k++) {
                        list.add(bucket[i].get(j));
                    }
                }
            }
        }
        StringBuilder res = new StringBuilder();
        for (Character c : list) {
            res.append(c);
        }
        return res.toString();
    }
}

5、颜色分类

问题：给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

示例 1：

输入：nums = [2,0,2,1,1,0]
输出：[0,0,1,1,2,2]
示例 2：

输入：nums = [2,0,1]
输出：[0,1,2]
示例 3：

输入：nums = [0]
输出：[0]
示例 4：

输入：nums = [1]
输出：[1]

package LeetCode.test4_paixusuanfa;

import java.util.Arrays;

public class ques_75_颜色分类 {
    public static void main(String[] args) {
        int[] nums = {2, 0, 2, 1, 1, 0};
        sortColors(nums);
        System.out.println(Arrays.toString(nums));
    }

    public static void sortColors(int[] nums) {
        quick_sort(nums, 0, nums.length - 1);
    }

    public static void quick_sort(int[] nums, int l, int r) {
        if (l > r) {
            return;
        }
        int left = l;
        int right = r;
        int res = nums[left];
        while (left < right) {
            while (left < right && nums[right] >= res) {
                right--;
            }
            if (left < right) {
                nums[left] = nums[right];
            }
            while (left < right && nums[left] <= res) {
                left++;
            }
            if (left < right) {
                nums[right] = nums[left];
            }
            if (left == right) {
                nums[left] = res;
            }
        }
        quick_sort(nums, l, right - 1);
        quick_sort(nums, right + 1, r);
    }
}