一周刷爆LeetCode，左程云老师-认识O(N * logN)的排序

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量661 收藏 1
点赞数
分类专栏： 数据结构 算法 文章标签： 算法 数据结构
原文链接：https://www.nowcoder.com/study/live/716/2/7
版权

认识O(N * logN)的排序

归并排序

1）整体就是一个简单递归，左边排好序、右边排好序、让其整体有序

2）让其整体有序的过程里用了排外序方法
3）利用master公式来求解时间复杂度

4 ）归并排序的实质

时间复杂度O(N*logN)，额外空间复杂度0(N)

在这里插入图片描述

package Unit2;

public class Code1_MergeSort
{
    public static void mergeSort(int []arr)
    {
        if (arr == null || arr.length < 2)
        {
            return;
        }
        mergeSort(arr, 0, arr.length - 1);
    }

    private static void mergeSort(int[] arr, int l, int r)
    {
        // 先左边排好顺序，再右边排好顺序，然后合并
        if (l == r)
        {
            return ;
        }
        // mid = (l + r) / 2 = l + (r - l) / 2 = l + (r - l) >> 1
        int mid = l + ((r - l) >> 1);
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }

    private static void merge(int[] arr, int l, int mid, int r)
    {
        int []help = new int[r - l + 1];
        int index = 0;
        int p1 = l;
        int p2 = mid + 1;
        // 两段都没有走完
        while (p1 <= mid && p2 <= r)
        {
            help[index++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        // 剩下的部分复制
        while (p1 <= mid)
        {
            help[index++] = arr[p1++];
        }
        while (p2 <= r)
        {
            help[index++] = arr[p2++];
        }
        // 拷贝到原函数
        for (index = 0; index < help.length; index++)
        {
            arr[l + index] = help[index];
        }
    }

    public static void printArray(int[] arr)
    {
        if (arr == null)
        {
            return ;
        }
        for (int i = 0; i < arr.length; i ++)
        {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args)
    {
        int []a = {1,3, 8, 4,2,9};
        printArray(a);
        System.out.println("====Sorting====");
        mergeSort(a);
        printArray(a);
    }
}
/*
1 3 8 4 2 9 
====Sorting====
1 2 3 4 8 9 
*/
归并排序的拓展（小和问题和逆序对问题）

小和问题 ——在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组 的小和。求一个数组 的小和。 例子:[1,3,4,2,5] 1左边比1小的数，没有; 3左边比3小的数，1; 4左 边比4小的数，1、3; 2左边比2小的数，1; 5左边比5小的数，1、3、4、 2; 所以小和为1+1+3+1+1+3+4+2=16

逆序对问题 ——在一个数组中，左边的数如果比右边的数大，则折两个数 构成一个逆序对，请打印所有逆序

小和问题解题思路：我们可以利用归并排序的算法求和，把数组分成左半部分和右半部分，当左半部分和右半部分排好序后，我们假设左边数M比右边数N小，假设左边数组下标范围[L…Mid]右边数组下标范围[Mid+1…R] 则相加(R-N的下标+1)*左边数M的值

package Unit2;

public class Code2_SmallSum
{
    public static int MergeSort(int []arr)
    {
        if (arr == null || arr.length < 2)
        {
            return 0;
        }
        return MergeSort(arr, 0, arr.length - 1);
    }

    private static int MergeSort(int[] arr, int l, int r)
    {
        if (l == r)
        {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        return MergeSort(arr, l, mid)+
        MergeSort(arr, mid + 1, r)+
        Merge(arr, l, mid, r);

    }

    private static int Merge(int[] arr, int l, int mid, int r)
    {
        int []help = new int[r - l + 1];
        int index = 0;
        int p1 = l, p2 = mid + 1;
        int sum = 0;
        while (p1 <= mid && p2 <= r)
        {
            sum += (arr[p1] < arr[p2]) ? (r - p2 + 1) * arr[p1]: 0;
            help[index++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }

        while (p1 <= mid)
        {
            help[index++] = arr[p1++];
        }
        while (p2 <= r)
        {
            help[index++] = arr[p2++];
        }
        for (index = 0; index < help.length; index++)
        {
            arr[l + index] = help[index];
        }
        return sum;
    }

    public static void PrintArray(int[] arr)
    {
        if (arr == null)
        {
            return ;
        }
        for (int i = 0; i < arr.length; i++)
        {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    public static void main(String[] args)
    {
        int []a = {1,3,4,2,5};
        int sum = MergeSort(a);
        PrintArray(a);
        System.out.println("sum = " + sum);
    }
}
/*1 2 3 4 5 
16
*/

逆序对问题解题思路：前面思路都一样，重点是给数组左右两边排好序后，假设arr[p1] > arr[p2], 则在p1 - mid之间的所有元素都可以和p2构成逆序对, 个数是mid - p1 + 1

package Unit2;

public class Code2_0_ReverseOrder
{
    public static int MergeSort(int []arr)
    {
        if (arr == null || arr.length < 2)
        {
            return 0;
        }
        return MergeSort(arr, 0, arr.length - 1);
    }

    private static int MergeSort(int[] arr, int l, int r)
    {
        if (l == r)
        {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        int cnt = MergeSort(arr, l, mid)+
                MergeSort(arr, mid + 1, r)+
                Merge(arr, l, mid, r);
        return cnt;
    }

    private static int Merge(int[] arr, int l, int mid, int r)
    {
        int []help = new int[r - l + 1];
        int index = 0;
        int p1 = l, p2 = mid + 1;
        int cnt = 0;
        while (p1 <= mid && p2 <= r)
        {
            if (arr[p1] > arr[p2])
            {
                cnt += (mid - p1 + 1);
                for (int i = 0; i < mid - p1 + 1; i++)
                {
                    System.out.print(arr[p1 + i] + " " + arr[p2]);
                    System.out.println();
                }
            }
            help[index++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }

        while (p1 <= mid)
        {
            help[index++] = arr[p1++];
        }
        while (p2 <= r)
        {
            help[index++] = arr[p2++];
        }
        for (index = 0; index < help.length; index++)
        {
            arr[l + index] = help[index];
        }
        return cnt;
    }

    public static void PrintArray(int[] arr)
    {
        if (arr == null)
        {
            return ;
        }
        for (int i = 0; i < arr.length; i++)
        {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    public static void main(String[] args)
    {
        int []a = {1,3,4,2,5};
        System.out.print("a[] = ");
        PrintArray(a);
        int cnt = MergeSort(a);
        System.out.println("===sorting===");
        PrintArray(a);
        System.out.println("cnt = " + cnt);
    }

}

堆的定义

堆

1，堆结构就是用数组实现的完全二叉树结构

2，完全二叉树中如果每棵子树的最大值都在顶部就是大根堆

3，完全二叉树中如果每棵子树的最小值都在顶部就是小根堆

4，堆结构的heapInsert与heapify操作

5，堆结构的增大和减少

6，优先级队列结构，就是堆结构

堆排序

1，先让整个数组都变成大根堆结构，建立堆的过程

​ 1)从上到下的方法，时间复杂度为O(N*logN)

​ 2)从下到上的方法，时间复杂度为O(N)

2，把堆的最大值和堆末尾的值交换，然后减少堆的大小之后，再去调 整堆，一直周而复始，时间复杂度为O(N*logN)

3，堆的大小减小成0之后，排序完成

在这里插入图片描述

package Unit2;

public class Code3_HeapSort
{
    public static void HeapSort(int[] a)
    {
        if (a == null && a.length < 2)
        {
            return ;
        }
        for (int i = 0; i < a.length; i++)
        {
            HeapInsert(a, i);
        }

        // 把堆首放到最后，然后有效下边-1
        int size = a.length;
        swap(a, 0, --size);
        while(size > 0)
        {
            Heapify(a, 0, size);
            swap(a, 0, --size);
        }
        PrintArray(a);
    }

    private static void Heapify(int[] a, int index, int size)
    {
        // 堆的头往下放
        // 大根堆
        int left = 2 * index + 1; // 下边为0的堆左孩子的下标
        while (left < size)
        {
            int largest = (left + 1 < size && a[left + 1] > a[left]) ? left + 1 : left;
            largest = (a[largest] > a[index]) ? largest : index;
            if (largest == index)
            {
                break;
            }
            swap(a, index, largest);
            index = largest;
            left = index * 2 + 1;
        }

    }

    private static void swap(int[] a, int i, int j)
    {
        // 利用异或把两个数交换
        a[i] = a[i] ^ a[j];
        a[j] = a[i] ^ a[j];
        a[i] = a[i] ^ a[j];
    }

    private static void HeapInsert(int[] a, int i)
    {
        // 最后插入的节点分别和它的父节点pk，
        while (a[(i - 1) / 2] < a[i])
        {
            swap(a, i, (i - 1) / 2);
            i = (i - 1) / 2;
        }
    }

    public static void PrintArray(int[] a)
    {
        if (a == null)
        {
            return ;
        }
        for (int i = 0; i < a.length; i++)
        {
            System.out.print(a[i] + " ");
        }
        System.out.println();

    }
    public static void main(String[] args)
    {
        int []a = {1,3,4,2,5};
        PrintArray(a);
        System.out.println("====Heap Sorting====");
        HeapSort(a);
        PrintArray(a);
    }
}

堆排序的拓展问题

已知一个几乎有序的数组，几乎有序是指，如果把数组排好顺序的话，每个元 素移动的距离可以不超过k，并且k相对于数组来说比较小。请选择一个合适的 排序算法针对这个数据进行排序。

解题思路：1.建立由k可元素的小顶堆，然后取出顶上元素

2.堆顶用没有建堆的下一元素替代，重新建堆

3.反复调用，完成排序，此算法因为每个元素移动都在k以内，所以时间复杂度为O（nlogk）

public static void sortedArrDistanceLessK(int[] arr, int k) {
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        int index = 0;
        for (; index < Math.min(arr.length, k); index++) {
            heap.add(arr[index]);
        }
        int i = 0;
        for (; index < arr.length; i++, index++) {
            heap.add(arr[index]);
            arr[i] = heap.poll();
        }
        while (!heap.isEmpty()) {
            arr[i++] = heap.poll();
        }
    }

荷兰国旗问题

问题一
给定一个数组arr，和一个数num，请把小于等于num的数放在数组的左边，大于num的数放在数组的右边。要求额外空间复杂度0(1)，时间复杂度O(N)
问题二(荷兰国旗问题)
给定一个数组arr，和一个数num，请把小于num的数放在数组的左边，等于num的数放在数组的中间，大于num的数放在数组的右边。要求额外空间复杂度0(1)，时间复杂度o(N)

在这里插入图片描述

package Unit2;

public class Code5_NetherlandsFlag
{

   public static int[] partition(int []arr, int l, int r, int p)
   {
       int less = l - 1;
       int more = r;
       int index = l;
       while (index < more) {
           if (arr[index] < p) {
               swap(arr, ++less, index++);
           } else if (arr[index] > p) {
               swap(arr, --more, index);
           } else {
               index++;
           }
       }
       return new int[] { less + 1, more - 1 };

   }

   public static void swap(int []arr, int p, int q)
   {
       arr[p] = arr[p] ^ arr[q];
       arr[q] = arr[p] ^ arr[q];
       arr[p] = arr[p] ^ arr[q];
   }

   public static int[] generateArray()
   {
       int[] arr = new int[10];
       for (int i = 0; i < arr.length; i++) {
           arr[i] = (int) (Math.random() * 3);
       }
       return arr;

   }
   public static void PrintArray(int []a)
   {
       for (int i = 0; i < a.length; i++)
       {
           System.out.print(a[i] + " ");
       }
       System.out.println();
   }
   public static void main(String[] args)
   {
        int []test = generateArray();
        PrintArray(test);
        int []p =partition(test, 0, test.length, 1);
        PrintArray(test);
       System.out.println("p[0] = " + p[0] + " p[1] = " + p[1]);
   }
}

不改进的快速排序

不改进的快速排序
1）把数组范围中的最后一个数作为划分值，然后把数组通过荷兰国旗问题分成三个部分:
左侧<划分值、中间==划分值、右侧>划分值

2)对左侧范围和右侧范围，递归执行
分析
1）划分值越靠近两侧，复杂度越高;划分值越靠近中间，复杂度越低
2）可以轻而易举的举出最差的例子，所以不改进的快速排序时间复杂度为0(N^2)

改进的快速排序

1）在数组范围中，等概率随机选一个数作为划分值，然后把数组通过荷兰国旗问题分成三个部分:
左侧<划分值、中间==划分值、右侧>划分值

2）对左侧范围和右侧范围，递归执行
3）时间复杂度为O(N*logN)

package Unit2;

public class Code6_QuickSort {

    public static void QuickSort(int []a)
    {
        if (a == null && a.length < 2)
        {
            return ;
        }
        QuickSort(a, 0, a.length - 1);
    }
    public static void QuickSort(int []arr, int l, int r)
    {
        if (l == r)
        {
            return ;
        }
        // Math.random()产生大于等于0，小于1的小数
        int random = l + (int)(Math.random() * (r - l + 1));
        swap(arr, random, r);
        int []p = partition(arr, 1, r);
        QuickSort(arr, l, p[0] - 1);
        QuickSort(arr, p[1] + 1, r);
    }
    public static int[] partition(int []arr, int l, int r)
    {
        int less = l - 1;
        int more = r;
        int index = l;
        while (index < more)
        {
            if (arr[index] < arr[r])
            {
                swap(arr, index++, ++less);
            }
            else if (arr[index] > arr[r])
            {
                swap(arr, index, --more);
            }
            else
            {
                index++;
            }
        }
        swap(arr, more, r);
        return new int[]{less + 1, more};
    }
    public static void swap(int []a, int i, int j)
    {
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
    }
    public static void PrintArray(int[] a)
    {
        if (a == null)
        {
            return ;
        }
        for (int i = 0; i < a.length; i++)
        {
            System.out.print(a[i] + " ");
        }
        System.out.println();

    }

    public static void main(String[] args) {
        int []a = {1, 3, 4, 2, 5};
        QuickSort(a);
        PrintArray(a);
    }
}
zcgcmx
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【leetcode/力扣】178.分数排名
hts558458的博客
08-08 800
总体来说稍微偏难的一道题。其实花了我最多时间的反而是写法上的小细节，还要多注意，这个题可以以后多联几遍。呃，其实还有个更简单的方法直接用dense_rank() over就行了···
左程云一周刷爆LeetCode 视频笔记 01.认识复杂度和简单排序算法
zoking_的博客
08-23 164
由于满足交换律，可让偶数次的数先异或，得0，奇数次的数异或后得本身，0与任何数异或得这个数。假设eor第八位是1，不妨设a的第八位为1，则b的第八位为0，偶数次的others里也有第八位为0或1的，分别划入指定位置。创建变量eor’=0，然后让eor’与第八位是1的所有数异或，偶数次异或为0，则eor’=a。由于满足交换律，可让偶数次的数先异或，得0，奇数次的数异或后得本 身，0与任何数异或得这个数。（1）一个数组 int arr[]，一种数出现奇数次，其余数全部出现偶数次，求奇数次的数。
leetcode 左程云笔记
Blue_Whale2020的博客
02-13 1758
P5 二叉树 0：0：53 两链表相交问题：可能有环可能无环，要求时间复杂度o（n） 4：42 判断一个链表是否有环的方法： 使用哈希表：每到一个节点就查询节点在不在哈希表里，不在就添加在表中 12：21快慢指针法 快指针如果指向null，那么链表无环，如果有环，快慢指针会在环上相遇 20：56 解决了两个链表各自有没有环这个问题之后，开始解决链表相交问题 25：33 如果两个链表的结尾不相同，那两个链表一定不会相交，因为不会有类似“X”形状的分叉结构 28：40 链表1无环 链表2无环
左神一周刷爆LeetCode 3 详解桶排序以及排序内容大总结
谢谢你们的关注
02-01 167
左神一周刷爆LeetCode 3 详解桶排序以及排序内容大总结
左程云leetcode-LeetCode:力扣解决方案
06-30
左程云leetcode LeetCode 王争的算法课堂 # Title Languages 题型 纯编程题 第一讲：纯编程题      [1108. IP 地址无效化（简单）][]    [344. 反转字符串（简单）][]    [剑指 Offer 58 - I. 翻转单词顺序（简单）][]               [剑指 Offer 05. 替换空格（简单）][]              经典atoi()，注意范围越界处理    题型 找规律题 第二讲：找规律题 [面试题 01.08. 零矩阵 （简单）][]    [剑指 Offer 61. 扑克牌中的顺子(中等)][]    [面试题 16.11. 跳水板（简单）][]    [面试题 01.05. 一次编辑（中等）][]    [面试题 16.15. 珠玑妙算 （中等）][]                                           题型 链表 第三讲：数组、链表                                              [369. 给单链表加一（中等）][]
左程云leetcode-algorithm-and-data-structure:算法+数据结构=程序
06-30
左程云leetcode 数据结构和算法学习笔记 一、简介 1. 2. 3. 4. 5. 6. 二、数据结构 1. 二维数组（Array2D） 位数组（Bit Set） 静态数组（Fixed Size Array） 有序表（Ordered Array） 2. 队列（Queues） （后进先出...
左程云leetcode-LeetCode:Leetcode刷题
06-30
左程云leetcode 前言 刷leetcode过程中的代码，每个题目尽量把代码写的易于理解，方便自己后序的复习。 数据结构相关 树 链表 栈和队列 算法思想相关 DP 搜索 二分查找 参考资料 leetcode 左程云 《程序员代码面试...
左程云leetcode-algorithm-java:leetcode答案使用java
06-30
【左程云LeetCode算法Java实现】是针对程序员在面试中常常遇到的算法问题而进行的一个项目。这个项目由左程云老师指导，目的是帮助学习者掌握并实践各种常见的编程算法，尤其是用Java语言实现。《程序员算法面试指南...
左程云leetcode-algo-in-java:java中的东西
06-30
左程云leetcode Algo In Java 数据结构和算法练习仓库 . ├── books │  └── codinginterviewguide 程序员算法面试指南-左程云 ├── ds ├── leetcode ├── nodes └── sortalgo
左程云leetcode-github:github
06-30
左程云leetcode [js,css,html]mdn [fileSeek工具] vue - 满足各种移动端优雅的滚动插件 [better-scroll]: (https://ustbhuangyi.github.io/better-scroll/#/) 考点 vue：1.<keep></keep> 缓存 typescript 1.npm ...
LeetCode:LeetCode刷题记录与面试整理
04-06
LeetCode翻译分类与面试问题整理 译文分类 哈希相关 链表操作 双指针遍历/滑动窗口 快慢指针遍历 区间合并 弦操作 数字操作 斑点操作 栈相关 堆相关 递归 分治法/二分法 动态规划 回溯法 字典树（一致树） 树的遍历 二叉搜索树相关 面试问题整理
leetcode题库-algorithm_qa:左程云老师算法最优解Python实现
06-29
leetcode题库 algorithm questions and answers 这个仓库会记录我使用Python解答 这本书上的算法题，左老师提供了Java版本的解答，可以点击下载Java版本的答案。 使用Python来实现的话，主要有两个原因：1）在实现之前思考是否可以直接使用Python标准库来实现，进一步熟悉标准库，当然为了理解算法，并不会真正 使用标准库的API来实现关键算法 2）左老师已经实现了Java版本，自己再使用Java来做的话，就会忍不住去参考左老师的代码。 本来这个项目完全不用单独开一个repo的，但是怕自己半途而废，所以希望使用这种方式来自勉，从而一直坚持下去。 update 刷了一些题目之后，发现了部分题目有固定的模式和套路，为了让自己能够将这种情况的解题思路牢记于心， 所以添加了一个部分套路总结 目前大概刷完了 程序员代码面试指南 和 剑指offer，下一步计划是刷leetcode中低难度的题。 由于左神的书上的题目已经十分具有代表性了，所以 剑指offer 和 leetcode 中的题目只会挑选 部分具有代表性的题目进行记录和分类总结
LeetCode 分数排名
hestyle的博客
09-14 4211
编写一个 SQL 查询来实现分数排名。如果两个分数相同，则两个分数排名（Rank）相同。请注意，平分后的下一个名次应该是下一个连续的整数值。换句话说，名次之间不应该有“间隔”。 +----+-------+ | Id | Score | +----+-------+ | 1 | 3.50 | | 2 | 3.65 | | 3 | 4.00 | | 4 | 3.85 | | 5 |...
LeetCode(178)-分数排名
Fly_Fly_Zhang的博客
07-10 373
题目： 编写一个 SQL 查询来实现分数排名。如果两个分数相同，则两个分数排名（Rank）相同。请注意，平分后的下一个名次应该是下一个连续的整数值。换句话说，名次之间不应该有“间隔”。 ±—±------+ | Id | Score | ±—±------+ | 1 | 3.50 | | 2 | 3.65 | | 3 | 4.00 | | 4 | 3.85 | | 5 | 4.0...
LeetCode算法—左程云—2021-08-19
张老师的博客
04-03 353
视频链接 一.：（1～） 1：：    1）：     -1：     -2：     -3：     -4：     -5：    2）：     -1：     -2：     -3：     -4：     -5：    3）：     -1：     -2：     -3：     -4：     -5：    4）：     -1：     -2：     -3：     -4：     -5：    5）：     -1：     -2：     -3：     -4：     -
一周刷爆LeetCode，算法da神左神（左程云）耗时100天打造算法与数据结构基础到高级全家桶教程，直击BTAJ等一线大厂必问算法面试题真题详解 笔记
sinat_39448069的博客
01-15 6546
一周刷爆LeetCode，算法大神左神（左程云）耗时100天打造算法与数据结构基础到高级全家桶教程，直击BTAJ等一线大厂必问算法面试题真题详解 笔记教程与代码地址P1 出圈了！讲课之外我们来聊聊算法和数据结构！以及未来！P2 1.认识复杂度和简单排序算法P3 2.认识O(NlogN)的排序P4 3.详解桶排序以及排序内容大总结P5 4.链表P6 5.二叉树P7 6. 图P8 7.详解前缀树和贪心算法P9 8. 暴力递归P10 9. 补充视频P11 10.基础提升 哈希函数与哈希表等P12 11.基础提升
LeetCode刷题之分数排名
CharlesYan的博客
03-13 1869
编写一个 SQL 查询来实现分数排名。如果两个分数相同，则两个分数排名（Rank）相同。请注意，平分后的下一个名次应该是下一个连续的整数值。换句话说，名次之间不应该有“间隔”。
几乎有序数组的排序方法
weixin_43923436的博客
05-08 3493
题目描述 已知一个几乎有序的数组，几乎有序指的是，如果把数组排好序的话，每个元素移送的距离不超过k，也就是说，所有元素都与它最终排序后的位置相距不到k，请选择一个时间复杂度最低的排序算法对此问题排序。 思路分析 排序算法，常见的效率比较高的，快排，不过，对于基本有序的数据，快排效率反而很低，排除掉。对于冒泡排序，有哨兵一说，如何已经有序，能直接返回，但是，此题只是在附近k的位置内，并不是说已经有部分有序，因此，也不符合。 因此，分析此题的特殊情况，每个数都在其最终位置k步以内，也就是说，最小值的话，最终排序
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 849
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
一周刷爆leetcode,算法大神左神
09-06
一周刷爆LeetCode的算法大神左神是指左程云。他耗时100天打造了算法与数据结构基础到高级全家桶教程，详细解析了一线大厂必问的算法面试题真题，并提供了相关的代码和讲义。他的教程中包括了复杂度和简单排序算法的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值