leetcode 排序

最新推荐文章于 2020-09-15 15:29:58 发布
最新推荐文章于 2020-09-15 15:29:58 发布
阅读量119 收藏
点赞数
分类专栏： 算法 文章标签： java 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/powerful_ren/article/details/104839209
版权

文章目录

归并排序

21.合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

JAVA代码:

//类似于归并排序的归并部分
//迭代法
//没有头指针
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
//类似于归并排序的归并部分
//迭代法
//没有头指针
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
            ListNode head  = new ListNode(-1);
            ListNode p = head;
        while (l1!=null && l2!=null){
            if (l1.val<=l2.val){
                p.next = l1;
                p = p.next;
                l1 = l1.next;
            }
            else{
                p.next = l2;
                p = p.next;
                l2 = l2.next;
            }
        }
        //有且仅有一个列表没有遍历完
        p.next = l1 == null ? l2 : l1;
        return head.next;
    }
}

148.排序链表

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。
示例 1:

输入: 4->2->1->3
输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

解答：
有时间复杂度O(nlogn), 想到归并排序
在这里插入图片描述

  1. 对链表进行切分并归并排序。
    将链表切分成大小为1的多个子链表，两两排序合并，共2个元素合并。
    将链表切分成大小为2的多个子链表，两两排序合并，共4个元素合并。
    将链表切分成大小为4的多个子链表，两两排序合并，共8个元素合并。
    一共切分 logn 次。 .
    JAVA代码：
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        //dummyhead：一次排序后链表
        //curr:无序链表。
        //prev: 当前排好的有序链表的尾结点。
        
        ListNode dummyhead = new ListNode(-1);
        dummyhead.next = head;   //dummyhead的后面一个结点指向head
        
        //链表长度
        int len = listLength(head);
        
        for (int step=1; step<=len; step<<=1){
            ListNode curr = dummyhead.next;
            ListNode prev = dummyhead;
            
            while (curr!=null){
                ListNode left = curr;
                ListNode right = split(left, step);  //从left切掉step个结点得到left.并返回切点，即right链表头结点
                curr = split(right, step);  //从right切掉step个结点得到right，并返回切点。
                prev.next = merge(left, right); 
                while(prev.next!=null) prev = prev.next;
            }
        }
        
        return dummyhead.next;
    }
    
    //切分链表: head前step个结点切掉作为left部分，返回后一个切点，即right部分的头节点
    public ListNode split(ListNode head, int step){
        ListNode curr = head;
        for (int i=1; i<step && curr!=null; i++){
            curr = curr.next;
        }
        if (curr==null) return null;
        ListNode right = curr.next;
        curr.next = null;
        return right;
    }
    
    //二路归并
    public ListNode merge(ListNode left, ListNode right){
        ListNode dummy = new ListNode(-1);
        ListNode curr = dummy;
        while(left!=null && right!=null){
           if (left.val<= right.val){
               curr.next = left;
               left = left.next;
               curr = curr.next;
           }
           else{
               curr.next = right;
               right = right.next;
               curr = curr.next;
           }
        }
        curr.next = left==null? right: left;
        return dummy.next;
    }
    
    //求链表长度
    public int listLength(ListNode head){
        int length = 0;
        ListNode curr = head;
        while (curr!=null){
            curr = curr.next;
            length++;
        }
        return length;
    }
}

快速排序

75. 颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:
不能使用代码库中的排序函数来解决这道题。

示例:

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

JAVA代码：

class Solution {
    public void sortColors(int[] nums) {
        int red = -1;
        int blue = nums.length;
        int i = 0;
        while (i<blue){
            if (nums[i]==0){
                swap(nums, i++, ++red);
            }
            else if(nums[i]==2){
                swap(nums, i, --blue);
            }
            else i++;
        }
    }
    public void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }   
}

堆排序

347. 前 K 个高频元素

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

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

示例 2:

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

说明：
你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。

题解：

1. 哈希表 + 小根堆

  1. 使用哈希表，统计每个元素出现的次数，元素作为键，出现的次数作为值。
  2. 将元素放入小根堆中，根据元素出现的次数进行排序，维持小根堆大小为k，最后得到的小根堆中的元素即为前k高频的元素。
  3. 遍历k个元素的小根堆，放入结果数组中。
class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 使用字典，统计每个元素出现的次数，元素为键，元素出现的次数为值
        Map<Integer, Integer> map = new HashMap<>();
        for (int num: nums){
            map.put(num, map.getOrDefault(num, 0)+1);
        }
        
        // 堆排序：将元素放入小根堆中，按照元素的频率排序，并维持堆大小为k
        
        // 重写compare方法
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
            public int compare(Integer a, Integer b){
                return map.get(a)-map.get(b);
            }
        });
        
        // 小根堆，维持大小为k
        for (int key: map.keySet()){
            pq.offer(key);
            if (pq.size() > k){
                 pq.poll();
            }
        }
        
        // 访问小根堆中的元素
        int[] res = new int[k];
        int i = 0;
        while(!pq.isEmpty()){
            res[i++] = pq.poll();
        }
        return res;
        
    }
}

时间复杂度O(n*logk)
空间复杂度O(n)

2. 哈希表 + 桶

  1. 哈希表存放各数字出现的频率。
  2. 准备若干个桶，每个桶存放出现次数相同的数字，桶的下标表示出现的次数。
  3. 只要倒序遍历k个非空桶即可得到前K个高频元素。
class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int num: nums){
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        
        // 频率作为下标，将数放在桶中，频率越大的数越在后面
        List<Integer>[] buckets = new ArrayList[nums.length + 1];
        for (int key : map.keySet()) {  // 返回map中所有key值的列表
            int frequency = map.get(key);
            if (buckets[frequency] == null){
                buckets[frequency] = new ArrayList<>();
            }
            buckets[frequency].add(key);
        }
        
        // 获取频率前k高的元素
        int[] res = new int[k];
        int index = 0;
        for (int i = buckets.length-1; index < k; i--){
            if (buckets[i] == null)
                continue;
            for(int j = 0; j<buckets[i].size(); j++){
                res[index++] = buckets[i].get(j);
            }
        }
        return res;
    }
}

时间复杂度O(n)
空间复杂度O(n)

215. 数组中的第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
说明:

你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

题解：
1. 直接排序

class Solution {
    public int findKthLargest(int[] nums, int k) {
        Arrays.sort(nums);
        return nums[nums.length-k];
    }
}

时间复杂度O(nlogn)
空间复杂度O(1)

2. 堆排序：优先队列
维护小根堆的大小为k，最后队列中第一个元素即为第k大的元素。

 class Solution{
     public int findKthLargest(int[] nums, int k){
         PriorityQueue<Integer> pq = new PriorityQueue<>();
         for (int num: nums){
            pq.add(num);
             // 维护堆的大小
             if (pq.size()>k){
                 pq.poll();
             }
         }
         return pq.peek();
     }
 }

时间复杂度O(nlogk)
空间复杂度O(1)

3. 堆排序：大根堆
先对数组所有元素形成大根堆，然后再根下沉直到排好最大的k的元素。

class Solution{
    public int findKthLargest(int[] nums, int k){
        // 形成大根堆
        for (int i = 0; i<nums.length; i++){
            heapInsert(nums, i);
        }
        int heapSize = nums.length;
        swap(nums, 0, --heapSize);
        while(heapSize > nums.length-k){
            heapify(nums, heapSize);
            swap(nums, 0, --heapSize);
        }
        return nums[nums.length-k];
    }
    public void heapInsert(int[] nums, int index){
        while(nums[index] > nums[(index-1)/2]){
            swap(nums, index, (index-1)/2);
            index = (index-1)/2;
        }
    }
    
    public void heapify(int[] nums, int heapSize){
        int index = 0;
        int left = 1;
        while(left < heapSize){
            int right = left + 1;
            int largest = right < heapSize && nums[left]<nums[right]
                          ? right
                          : left;
            largest = nums[largest] < nums[index]? index:largest;
            if (largest == index) 
                break;
            
            swap(nums, largest, index);
            index = largest;
            left = index*2+1;   
        }
    }
    public void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

时间复杂度O(nlogk)
空间复杂度O(1)

4. 快速选择
将无序部分nums[L: R]的最后一个元素作为基准，小于等于基准的放在左边，大于基准的放在右边，如此就能知道该基准是第几小的数。设基准下标为posi

  • 若posi<k ，那么第k大的数在nums[L+1, R]区间
  • 若posi>k, 那么第k大的数在nums[L, R-1]区间
  • 若posi == k, 那么nums[posi]正好为第k大的数。

思路过程类似与快速排序，不同于快排的是，快速选择只要排左右其中一个区间，而快速排序左右两个区间都要排序。

class Solution{
    public int findKthLargest(int[] nums, int k){
        k = nums.length - k;
        int L = 0;
        int R = nums.length-1;
        int posi = 0;
        while(L<=R){
            posi = position(nums, L, R);
            if (posi == k){
                break;
            }
            else if (posi < k){
                L = posi + 1;
            }
            else 
                R = posi - 1;
        }
        return nums[posi];
    }
    
    public int position(int[] nums, int L, int R){
        int less = L-1;
        int more = R;
        int i = L;
        while(i < more){
            if (nums[i] <= nums[R]){
                i++;
                less++;
            }
            else {
                swap(nums, i, --more);
            }
        }
        swap(nums, more, R);
        int posi = more;
        return posi;
    }
    
    public void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

时间复杂度平均情况O(n)， 最坏情况O(n^2)
空间复杂度O(1)

桶排序

451. 根据字符出现频率排序

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

示例 1:

输入:
"tree"

输出:
"eert"

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

示例 2:

输入:
"cccaaa"

输出:
"cccaaa"

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

示例 3:

输入:
"Aabb"

输出:
"bbAa"

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

题解：哈希表 + 桶

  1. 将字符和对应出现的频率存放在哈希表中：{字符：频率}
  2. 将不同频率的字符装进相应的桶中，桶的下标表示不同的频率
  3. 倒序遍历桶中的字符，即按照频率降序的方式遍历，根据字符及对应的频率拼接成结果字符串。
class Solution {
    public String frequencySort(String s) {
        Map<Character, Integer> map = new HashMap<>();
        
        for (int i = 0; i<s.length(); i++){
            char ch = s.charAt(i);
            map.put(ch, map.getOrDefault(ch, 0)+1);
        }
        
        List<Character>[] buckets = new ArrayList[s.length()+1];
        
        // 将不同频率的字符装进相应的桶中
        for (Character key: map.keySet()){
            int fq = map.get(key);
            if (buckets[fq] == null){
                buckets[fq] = new ArrayList<>();
            }
            buckets[fq].add(key);
        }
        
        // 倒序遍历桶
        StringBuffer sb = new StringBuffer();
        for(int i = buckets.length-1; i>0; i--){
            if (buckets[i] == null)
                continue;
            for (int j = 0; j<buckets[i].size(); j++){
                for (int k = 0; k<i; k++){
                    sb.append(buckets[i].get(j));
                }
            }
            
        }
        return sb.toString();
        
    }
}

时间复杂度O(n)
空间复杂度O(n)

糖糖rh
关注
专栏目录
leetcode思维导图-排序
08-13
leetcode思维导图-排序
Leetcode 搜索旋转排序数组.m
02-21
LeetCode 问题 33 是一个关于在旋转排序数组中搜索一个给定目标值的问题。如果目标值存在返回它的索引，否则返回 -1。数组可能在某个未知的轴心上进行了旋转（例如 [0,1,2,4,5,6,7] 可能变成 [4,5,6,7,0,1,2]）。你...
LeetCode Solutions
最新发布
06-13
在LeetCode中，很多问题都涉及到了数据结构的使用，如查找、排序、连接等操作。 3. **算法**：包括排序算法（快速排序、归并排序、插入排序、选择排序等）、搜索算法（深度优先搜索DFS、广度优先搜索BFS、回溯法、...
php-leetcode题解之插入排序.zip
06-07
7. **实践应用**：在LeetCode等平台上，通过编写插入排序的代码，可以锻炼对基本算法的理解和实现能力，有助于面试和实际项目开发。 综上所述，这个压缩包包含的文件“php_leetcode题解之插入排序”很可能是一个PHP...
php-leetcode题解之希尔排序.zip
06-11
- 用LeetCode平台上的问题来测试希尔排序的性能和适应性，LeetCode是一个在线编程练习平台，提供各种算法题目，包括排序算法。 - 可能还包含了单元测试，用于确保排序功能的正确性，以及不同边界条件和输入情况下的...
leetcode 数组—幂集
powerful_ren的博客
03-02 837
幂集。编写一种方法，返回某集合的所有子集。集合中不包含重复的元素。 说明：解集不能包含重复的子集。 示例: 输入： nums = [1,2,3] 输出： [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ] 题解：二进进制 首先知道n个元素的集合的幂集个数为: n^2 nums = [1,2,3], 长度为...
leetcode_动态规划
powerful_ren的博客
09-15 786
目录1. 斐波那契数列70. 爬楼梯198. 打家劫舍213. 打家劫舍 II信件错排母牛生产2. 矩阵路径64. 最小路径和62. 不同路径3. 数组区间303. 区域和检索 - 数组不可变413. 等差数列划分343. 整数拆分*279. 完全平方数91. 解码方法5. 最长递增子序列300. 最长上升子序列* (中等)646. 最长数对链* 1. 斐波那契数列 70. 爬楼梯 假设你正在爬...
leetcode_位运算
powerful_ren的博客
05-15 737
文章目录原理基本原理位与运算技巧移位运算mask 计算Java 中的位操作461. 汉明距离136. 只出现一次的数字268. 缺失数字 原理 基本原理 0s 表示一串 0，1s 表示一串 1。 x ^ 0s = x x & 0s = 0 x | 0s = x x ^ 1s = ~x x & 1s = x x | 1s = 1s x ^ x = 0 x & x = x x | x = x 利用 x ^ 1s = ~x 的
二叉树
powerful_ren的博客
03-23 712
实现二叉树的先序、中序、后续遍历，包括递归方式和非递归方式
leetcode_数组与矩阵
powerful_ren的博客
05-06 552
文章目录283. 移动零566. 重塑矩阵485. 最大连续1的个数 283. 移动零 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。 示例: 输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 说明: 必须在原数组上操作，不能拷贝额外的数组。 尽量减少操作次数。 题解： 1. 冒泡思想 每一趟扫描遇到0就将其与后一个数交换，直...
leetcode_字符串
powerful_ren的博客
04-09 469
字符串循环移位包含 编程之美 3.1 s1 = AABCD, s2 = CDAA Return : true 题解： 给定两个字符串 s1 和 s2，要求判定 s2 是否能够被 s1 做循环移位得到的字符串包含。 s1 进行循环移位的结果是 s1s1 的子字符串，因此只要判断 s2 是否是 s1s1 的子字符串即可。 字符串循环移位 编程之美 2.17 s = "abcd123" k = 3 R...
leetcode_链表
powerful_ren的博客
04-08 462
目录160. 相交链表206. 反转链表(简单)83. 删除排序链表中的重复元素 （简单）19. 删除链表的倒数第N个节点 (中等)24. 两两交换链表中的节点 (中等)445. 两数相加 II * （中等）234. 回文链表*（中等）725. 分隔链表* （中等）328. 奇偶链表 （中等） 160. 相交链表 编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1...
leetcode_贪心思想
powerful_ren的博客
06-10 380
文章目录455. 分发饼干435. 无重叠区间452. 用最少数量的箭引爆气球 455. 分发饼干 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj >= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。 注意： 你可以假设胃口值为正。 一个小朋友最多只
算法——高频题
powerful_ren的博客
03-15 369
桶 用数组结构实现大小固定的队列和栈 队列：先进先出 假设固定大小为len，size为当前队列大小，start表示队头，end表示队尾。 若size<0 或 size>len, 则越界。 出队，end+1位置覆盖一个数。size++; 若end到达数组尾部，则end 返回到数组首部；否则end++ 入队，start 位置减去一个数。start–; size– 栈：先进后出 假设固定...
leetcode_二分查找
powerful_ren的博客
07-28 329
文章目录69. x 的平方根744. 寻找比目标字母大的最小字母540. 有序数组中的单一元素 69. x 的平方根 实现 int sqrt(int x) 函数。 计算并返回 x 的平方根，其中 x 是非负整数。 由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。 示例 1: 输入: 4 输出: 2 示例 2: 输入: 8 输出: 2 说明: 8 的平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。 题解： 1. 从0开始枚举 class Solution
leetcode_图
powerful_ren的博客
05-09 281
文章目录785. 判断二分图207. 课程表 785. 判断二分图 给定一个无向图graph，当这个图为二分图时返回true。 如果我们能将一个图的节点集合分割成两个独立的子集A和B，并使图中的每一条边的两个节点一个来自A集合，一个来自B集合，我们就将这个图称为二分图。 graph将会以邻接表方式给出，graph[i]表示图中与节点i相连的所有节点。每个节点都是一个在0到graph.length...
二叉搜索树
powerful_ren的博客
03-31 258
二叉搜索树
leetcode_双指针
powerful_ren的博客
05-18 194
文章目录
并查集
powerful_ren的博客
03-26 184
概念： 检查两个元素是否属于同一个集合. 两个元素所属集合合并成同一个集合. 设元素A属于集合 set1。 元素B属于集合set2. 直观思路：用list结构分别装载两个集合，则有 list1 对应集合set1, list2对应集合set2 查看list1中是否存在B，即可判断A和B是否同属于一个集合。 合并：将list1 和list2连接起来 缺点：无法做到迅速查找和迅速合并. 采用树状结构...
leetcode排序
10-13
LeetCode上的排序算法有很多种，包括冒泡排序、选择排序、插入排序、归并排序、快速排序等等。其中，归并排序和快速排序是比较常用的高效排序算法。 归并排序的基本思想是将待排序的序列分成若干个子序列，每个子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值