【数据结构】 面试复习

最新推荐文章于 2022-06-17 20:27:47 发布
最新推荐文章于 2022-06-17 20:27:47 发布
阅读量358 收藏 1
点赞数
分类专栏： 面试复习 文章标签： c++ 数据结构 排序 红黑树 B树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ambition_zhou/article/details/114265823
版权

1. C++

2. 计算机网络

3. 操作系统

4. 数据库

5. 数据结构

6. 杂项

1. 红黑树与AVL树

1.1 性质

5个属性：color, key, left, right, p
（能保证在最坏情况下，基本的动态几何操作的时间均为O(lgn)）

  1. 节点是红色或黑色。
  2. 根节点是黑色。
  3. 每个叶子节点都是黑色的空节点（NIL节点）。
  4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
  5. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。（红黑树从根到叶节点的最长路径都不会超过最短路径的两倍

红黑树是牺牲了严格的高度平衡的优越条件为代价，它只要求部分地达到平衡要求，降低了对旋转的要求，从而提高了性能。红黑树能够以O(log2 n)的时间复杂度进行搜索、插入、删除操作。

  • BST & RB-T： 相比于BST，因为红黑树可以能确保树的最长路径不大于两倍的最短路径的长度，所以可以看出它的查找效果是有最低保证的。在最坏的情况下也可以保证O(logN)的，这是要好于二叉查找树的。因为二叉查找树最坏情况可以让查找达到O(N)（只有左子树或者右子树，退化为链表）。

  • AVL & RB-T： 在AVL树中，从根到任何叶子的最短路径和最长路径之间的差异最多为1。在红黑树中，差异可以是2倍。两个都为O（log n）查找，但平衡AVL树可能需要O（log n）旋转，而红黑树将需要最多两次旋转使其达到平衡（尽管可能需要检查O（log n）节点以确定旋转的位置）。旋转本身是O（1）操作，因为你只是移动指针。插入多用红黑树，插入少用avl

1.2 应用

主要是用它来存储有序的数据，它的时间复杂度是O(lgn)，效率非常之高。例如，Java集合中的TreeSet和TreeMap，C++ STL中的set、map，以及Linux虚拟内存的管理，都是通过红黑树去实现的。

1.3 旋转

在这里插入图片描述
左旋
在这里插入图片描述
右旋代码类似。
时间复杂度：O(1)

1.4 插入

每次插入位置都是叶节点，
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
时间复杂度：O(lgn)

1.5 删除

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
时间复杂度：O(lgn)

2. B树与B+树

2.1 性质

B树：关键字分布在整颗树中，M阶B树

  1. 非叶节点最多有m棵子树，
  2. 根结点最少有两个子树，非根非叶节点最少有m/2棵子树
  3. 非叶子结点中保存的关键字，等于该结点子树指针的个数-1
  4. 关键字大小有序，关键字的左子树都小于该关键字，右子树都大于该关键字
  5. 叶子结点都在同一层
    在这里插入图片描述
    在这里插入图片描述

2.2 操作

插入 删除 分裂节点

2.3 B+树：

  1. 非叶子结点的子树指针对关键字个数相同
  2. 非叶子结点的子树子树指针p[i]指向关键字区间[ k[i],k[i+1] )开区间（关键字是子树最小）
  3. 叶子结点增加一个链指针
  4. 非叶子结点只是个索引，所有关键字都在叶子结点出现。

3. 排序

3.1 冒泡排序

  1. 如果遇到相等的值不进行交换，那这种排序方式是稳定的排序方式。

1. 原理： 比较两个相邻的元素，将值大的元素交换到右边

2. 思路： 依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。

(1)第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。

(2) 比较第2和第3个数，将小数 放在前面，大数放在后面。

…

(3)如此继续，知道比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成

(4)在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。

(5)在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较中，最后两个数是不参与比较的。

(6)依次类推，每一趟比较次数减少依次
3. 举例　　　　
　　　　在这里插入图片描述
4. 代码实现

void BubbleSort(int arr[], int a){
    if(arr == NULL || a < 0) return;
    int temp;
    for(int i = 0; i < a; i++){
        for(int j = i + 1; j < a; j++){
            if(arr[i] > arr[j]){
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    print(arr, a);
}

3.2 选择排序

1. 概念 选择排序（Select Sort）是直观的排序，通过确定一个 Key 最大或最小值，再从带排序的的数中找出最大或最小的交换到对应位置。再选择次之。双重循环时间复杂度为 O(n^2)

2. 算法描述：
在一个长度为 N 的无序数组中，第一次遍历 n-1 个数找到最小的和第一个数交换。
第二次从下一个数开始遍历 n-2 个数，找到最小的数和第二个数交换。
重复以上操作直到第 n-1 次遍历最小的数和第 n-1 个数交换，排序完成。
3. 代码实现

void SelectSort(int arr[], int a){
    if(arr == NULL || a <= 0) return;
    for(int i = 0; i < a; i++){
        int MinKey = arr[i];
        for(int j = i; j < a; j++){
            if(MinKey > arr[j]){
                int temp = arr[j];
                arr[j] = MinKey;
                MinKey = temp;
            }
        }
        arr[i] = MinKey;
    }
}

3.3 插入排序

1. 实现思路：

  1. 从数组的第二个数据开始往前比较，即一开始用第二个数和他前面的一个比较，如果 符合条件（比前面的大或者小，自定义），则让他们交换位置。
  2. 然后再用第三个数和第二个比较，符合则交换，但是此处还得继续往前比较，比如有 5个数8，15，20，45, 17,17比45小，需要交换，但是17也比20小，也要交换，当不需 要和15交换以后，说明也不需要和15前面的数据比较了，肯定不需要交换，因为前 面的数据都是有序的。
  3. 重复步骤二，一直到数据全都排完。
    2. 代码实现
void InsertSort(int a[], int n){  //直接插入排序
    int i,j,temp=0;
    for(i=1;i<n;i++){
        if(a[i]<a[i-1]){
            temp = a[i];
            for(j=i-1;j>=0 && a[j]>temp;j--) {
                a[j+1]=a[j];
            }
            a[j+1]=temp;
        }
    }
}

3.4 快排

1. 基本概念
快速排序(Quick Sort)使用分治法策略。它的基本思想是：选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小。然后，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

2. 算法流程：

  • (1) 从数列中挑出一个基准值。
  • (2) 将所有比基准值小的摆放在基准前面，所有比基准值大的摆在基准的后面(相同的数可以到任一边)；在这个分区退出之后，该基准就处于数列的中间位置。
  • (3) 递归地把"基准值前面的子数列"和"基准值后面的子数列"进行排序。
    3. 图解

在这里插入图片描述
4. 随机快排
经典快速排序总是指定数组或者某部分的最后一个元素作为基准值，随机快速排序指定数组或者某一部分中的随机值作为基准值。快排随机版本只需要 先使用rand()方法找到一个随机下标，接着swap(nums[left], nums[i])，然后和普通版本代码一模一样

5. 代码实现

LeetCode 215.数组中的第k个最大元素

int findKthLargestQuick(vector<int>& nums, int k, int left, int right){
    // 快排思想
    int n = nums.size();
    
    // 随机版本
    int i = rand() % (right - left + 1) + left;
    swap(nums[left], nums[i]);
    
    int l = left, r = right, mark = nums[left];
    while(l < r){
        while(l < r && nums[r] >= mark) r--;
        while(l < r && nums[l] <= mark) l++;
        swap(nums[l], nums[r]);
    }
    swap(nums[left], nums[l]);
    if(right - l + 1 < k) return findKthLargestQuick(nums, k - (right - l + 1), left, l - 1);
    else if(right - l + 1 == k) return nums[l];
    else return findKthLargestQuick(nums, k , l + 1, right);
}

3.5 堆排序

1. 堆
堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。如下图：
在这里插入图片描述
同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子
在这里插入图片描述
该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是：
大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]
2. 算法思想
　堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
3. 算法流程（以大顶堆为例）

  1. 堆调整maxHeapify
    在这里插入图片描述
    在这里插入图片描述
 void maxHeapify(vector<int>& nums, int i, int heapSize){
        int l = i * 2 + 1, r = i * 2 + 2, largest = i;
        // 找到最大的一个元素
        if(l < heapSize && nums[l] > nums[i]) largest = l;
        if(r < heapSize && nums[r] > nums[largest]) largest = r;
        // nums[i]符合堆要求，然后递归调整堆
        if(largest != i){
            swap(nums[largest], nums[i]);
            maxHeapify(nums, largest, heapSize);
        } 
    }
  1. 建堆
    在这里插入图片描述
    举例
    在这里插入图片描述
// nums(n/2+1..n)都是叶节点，可以看做已经满足了堆的性质，无需调整
void buildMaxHeap(vector<int>& nums, int heapSize){
    for(int i = heapSize / 2; i >= 0; i--){
        maxHeapify(nums, i, heapSize);
    }
}
  1. 堆排序
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    4. 题目举例
    LeetCode 215.数组中的第k个最大元素
    buildMaxHeap 初始构建堆
    maxHeapfy 堆调整
class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        // 一、快排
        // return findKthLargestHelp(nums, k, 0, nums.size() - 1);
        // 二、堆排
        // 1. 构建size = nums.size()的大根堆，删除size - k + 1次，最后一个删除的
        // 2. 构建size = k的小根堆，构建n次，最后一个堆的根
        // return findKthLargestMaxHeap(nums, k);
        return findKthLargestMinHeap(nums, k);
    }

    // quickSort 快排
    int findKthLargestQuick(vector<int>& nums, int k, int left, int right){
        // 快排思想
        int n = nums.size();
        int i = rand() % (right - left + 1) + left;
        swap(nums[left], nums[i]);
        int l = left, r = right, mark = nums[left];
        while(l < r){
            while(l < r && nums[r] >= mark) r--;
            while(l < r && nums[l] <= mark) l++;
            swap(nums[l], nums[r]);
        }
        swap(nums[left], nums[l]);
        if(right - l + 1 < k) return findKthLargestQuick(nums, k - (right - l + 1), left, l - 1);
        else if(right - l + 1 == k) return nums[l];
        else return findKthLargestQuick(nums, k , l + 1, right);
    }
    
  	// maxheap 大顶堆解决
    int findKthLargestMaxHeap(vector<int>& nums, int k){
        int heapSize = nums.size();
        buildMaxHeap(nums, heapSize);
        for(int i = nums.size() - 1; i >= nums.size() - k + 1; i--){
            swap(nums[i], nums[0]);
            --heapSize;
            maxHeapify(nums, 0, heapSize);
        }
        return nums[0];
    }
    // 构建大顶堆
    // nums(n/2+1..n)都是叶节点，可以看做已经满足了堆的性质，无需调整
    void buildMaxHeap(vector<int>& nums, int heapSize){
        for(int i = heapSize / 2; i >= 0; i--){
            maxHeapify(nums, i, heapSize);
        }
    }
    // 堆调整
    void maxHeapify(vector<int>& nums, int i, int heapSize){
        int l = i * 2 + 1, r = i * 2 + 2, largest = i;
        // 找到最大的一个元素
        if(l < heapSize && nums[l] > nums[i]) largest = l;
        if(r < heapSize && nums[r] > nums[largest]) largest = r;
        // nums[i]符合堆要求，然后递归调整堆
        if(largest != i){
            swap(nums[largest], nums[i]);
            maxHeapify(nums, largest, heapSize);
        } 
    }
    
    // minHeap 小顶堆解决
    int findKthLargestMinHeap(vector<int>& nums, int k){
        int heapSize = k;
        // 构建k大小的小根堆
        for(int i = heapSize / 2; i >= 0; i--){
            minHeapify(nums, i, heapSize);
        }
        for(int i = k; i < nums.size(); i++){
            if(nums[0] < nums[i]){
                swap(nums[0], nums[i]);
                minHeapify(nums, 0, heapSize);
            }
        }
        return nums[0];
    }
    void minHeapify(vector<int>& nums, int i, int heapSize){
        int l = i * 2 + 1, r = i * 2 + 2, smallest = i;
        if(l < heapSize && nums[l] < nums[i]) smallest = l;
        if(r < heapSize && nums[r] < nums[smallest]) smallest = r;
        if(smallest != i){
            swap(nums[smallest], nums[i]);
            minHeapify(nums, smallest, heapSize);
        }
    }
};

3.6 归并排序

1. 基本概念
**归并排序（MERGE-SORT）**是建立在归并操作上的一种有效的排序算法,该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)，将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序，若将两个有序表合并成一个有序表，称为二路归并。
归并排序其实要做两件事：

  • （1）“分解”——将序列每次折半划分（递归实现）
  • （2）“合并”——将划分后的序列段两两合并后排序
    2. 基本思想
    将待排序序列R[0…n-1]看成是n个长度为1的有序序列，将相邻的有序表成对归并，得到n/2个长度为2的有序表；将这些有序序列再次归并，得到n/4个长度为4的有序序列；如此反复进行下去，最后得到一个长度为n的有序序列
    3.算法描述
  • 第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
  • 第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
  • 第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
  • 重复步骤3直到某一指针超出序列尾，将另一序列剩下的所有元素直接复制到合并序列尾
    4. 图解
    在这里插入图片描述
    5. 代码实现
/* 将序列对半拆分直到序列长度为1*/
void MergeSort_UptoDown(int *num, int start, int end){
    int mid = start + (end - start) / 2;
    if (start >= end) return;
    MergeSort_UptoDown(num, start, mid);
    MergeSort_UptoDown(num, mid + 1, end);
    Merge(num, start, mid, end);
}

void Merge(int *num, int start, int mid, int end){
    int *temp = (int *)malloc((end-start+1) * sizeof(int));    //申请空间来存放两个有序区归并后的临时区域
    int i = start;
    int j = mid + 1;
    int k = 0;
    while (i <= mid && j <= end) {
        if (num[i] <= num[j]) temp[k++] = num[i++];
        else temp[k++] = num[j++];
    }
    while (i <= mid)
        temp[k++] = num[i++];
    while (j <= end)
        temp[k++] = num[j++];

    //将临时区域中排序后的元素，整合到原数组中
    for (i = 0; i < k; i++)
        num[start + i] = temp[i];
    free(temp);
}

3.7 总结

在这里插入图片描述

_ambition_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法面试知识点汇总（超全）
CSDN_dzh的博客
01-31 1万+
文章目录哈希函数和哈希表哈希函数哈希表 哈希函数和哈希表 哈希函数 哈希函数（散列函数）：类似于函数调用一样，给一个字符串作为输入，返回一个哈希码 性质： 1）输入域是无穷大的 2）输出域是有穷的，输出域要比输入域小 3）哈希函数不是一个随机函数，只要输入一样，输出就一样 4）输入域这么大而输出域这么小，而由于特性3的关系，就会导致输入不一样也有可能得到输出一样的值（哈希碰撞） 5）虽然有哈希...
数据结构复习.docx
09-04
本文将详细讨论数据结构复习中的几个关键算法：阶乘算法、斐波那契数列、汉诺塔问题以及它们的迭代与递归实现。 1. **阶乘算法**： - **迭代法**：计算一个数的阶乘通常可以使用循环来实现，例如，对于正整数`n`，...
数据结构面试复习总结
weixin_43015194的博客
05-09 430
根据https://www.cnblogs.com/yuxiaoba/p/8718167.html 以及https://www.cnblogs.com/zhaoshuai1215/p/3448154.html 整理。 1、数组和链表的区别。 从逻辑结构上来看，数组必须实现定于固定的长度，不能适应数据动态增减的情况，即数组的大小一旦定义就不能改变。当数据增加是，可能超过原先定义的元素的个数；当数据减少时，造成内存浪费；链表动态进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。 从内存存
数据结构面试复习题
make a wish
03-30 948
对数据结构中常见算法进行总结，主要涉及1、图：最小生成树求法PRIM/kruskal。2、图：最短路径：dijsktra，Floyd。3、递归、分治、动态规划、贪心的辨析和常见应用实现
数据结构面试复习指导
isakwong的博客
04-14 355
最近一个月一直在准备暑期实习的面试，不过前几天拿到了网易游戏的实习offer，以及完美世界暑期实习的offer。3月制作了一份数据结构的复习蓝图，在这里做个记录，也是为秋招做一个备份。...
数据结构复习（夏令营面试准备）
weixin_44134344的博客
06-30 842
第一章 绪论 1.数据结构的三要素：逻辑结构，存储结构，数据的运算 2.数据元素是数据的基本单位，数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如：学生记录就是一个数据元素，它由学号姓名性别等数据项组成。 3.逻辑结构是指数据元素之间的逻辑关系，与数据存储无关，独立于计算机。逻辑结构分为线性结构和非线性结构，线性结构包含线性表，栈和队列，串等数据结构，非线性结构包含集合，树，图等数据结构。 4.存储结构是指数据结构在计算机中的表示（又称映像），也称物理结构。主要有顺序存储.
面试复习——数据结构（一）：数据结构和算法的基本概念
weixin_45770491的博客
06-12 202
数据结构复习（一）：数据结构和算法的基本概念
数据结构期末复习大纲
02-08
本复习大纲旨在帮助学生全面掌握数据结构的基本概念、原理及其实现方法，为期末考试做好充分准备。 一、绪论 1.1 数据结构的定义与类型：理解数据结构的基本概念，包括逻辑结构（如线性结构、树形结构、图结构和...
西南交大-计算机-超级全面-数据结构期末复习资料.zip
11-18
西南交通大学的这份"超级全面"数据结构期末复习资料包含了丰富的学习资源，旨在帮助学生充分理解和掌握这一领域的关键概念。 文档“算法！.docx”和“算法！.pdf”很可能包含了各种数据结构相关的经典算法详解，如...
数据结构复习题.doc
06-05
在编程和面试中，数据结构的知识是必不可少的，特别是在考研和求职过程中，对数据结构的深入理解和熟练应用常常是评估候选人技术能力的重要指标。因此，熟练掌握数据结构及其操作是成为优秀程序员的关键步骤，正如...
数据结构复习资料自用版本
02-08
总的来说，这份“数据结构复习资料自用版本”涵盖了数据结构与算法的核心内容，对于准备面试、提升编程能力或是进一步学习计算机科学的人来说，都是一份极具价值的学习资源。通过系统地学习和练习，可以为解决实际...
数据结构面试知识点汇总
我只钓小鱼的博客
08-20 2086
数据结构面试常见定义
面试复习——数据结构（七）：树与二叉树
weixin_45770491的博客
06-17 598
数据结构复习（七）：树与二叉树
保研面试复习之数据结构篇
abtgu的博客
10-24 3440
数据项、数据元素和数据结构的概念。 数据项是组成数据元素的，有独立含义的，不可分割的最小单位。数据元素是数据的基本单位。数据结构是带结构的数据元素的集合。数据结构包括逻辑结构和存储结构两个层次。 数据结构的三要素是逻辑结构，存储结构和数据的运算。 逻辑结构和存储结构区别。 逻辑结构包括集合结构、线性结构、树结构和图结构。 存储结构包括顺序存储结构、链式存储结构、索引存储结构、散列存储结构。 顺序存储结构是逻辑上相邻的元素在物理位置上也是相邻的。链式存储结构是在逻辑上相邻的元素物理位置不一定相邻.
面试宝典系列：一篇文章带你复习数据结构
BUG
10-06 295
一篇详细的讲解数据结构的文章，包括set，map，list三个集合的知识，然后带着手把手解决树，链表，队列与栈相关的数据操作
数据结构_刷面经前必了解-个人复习（简单篇）
weixin_46489853的博客
08-21 255
1 数组、链表 方式一 静态初始化 int[] arr0 = new int[]{2,4,6,8}; 方式二 隐式初始化 double[] arr1 = {2.2,3.3,4.4}; 方式三 动态初始化 int[] arr2 = new int[3];//[3]代表这个数组可以存放3个元素 arr[0] = 2;//[0]代表数组的第1个数据 将2存进去到数组第1个位置 arr[1] = 4;//[1]代表数组的第2个数据 将4存进去到数组第2个位置 arr[2] = 6;//[2]代表数组的第3个
常考算法与数据结构--面试准备
m0_37294840的博客
05-29 524
一、算法 1.算法思想 1）最长公共子序列问题--动态规划 2）贪心算法 3）分治算法 4）随机划分算法 5）回溯算法 2.排序问题   插入排序：直接插入、shell排序   选择排序：直接选择、堆排序   交换排序：冒泡排序、快速排序   归并排序   基数排序 3.查找算法   二分查找 4.hash算法 二、数据结构部分： 1、数组和链表的区别
数据结构经典面试题——概念
ax1274669874的博客
12-22 2014
一、算法的基本概念 计算机解题的过程实际上是在实施某种算法，这种算法称为计算机算法。 1.算法的基本特征：可行性，确定性，有穷性，拥有足够的情报。 2.算法的基本要素：算法中对数据的运算和操作、算法的控制结构。 3.算法设计的基本方法：列举法、归纳法、递推、递归、减半递推技术、回溯法。 4.算法设计的要求：正确性、可读性、健壮性、效率与低存储量需求 二、算法的复杂度
面试 数据结构 算法
zht_304的专栏
04-27 2505
From: blog.chinaunix.net/u3/100577/showart.php?id=2204671 面试常考的常用数据结构与算法     数据结构与算法，这个部分的内容其实是十分的庞大，要想都覆盖到不太容易。在校学习阶段我们可能需要对每种结构，每种算法都学习，但是找工作笔试或者面试的时候，要在很短的时间内考察一个人这方面的能力，把每种结构和算法都问一遍不太现实。所以，实
数据结构与算法复习资料
最新发布
05-23
以下是一些数据结构与算法的复习资料，供您参考： 1.《算法》（第四版）- 算法基础知识的经典教材，包括排序、查找、图、字符串等内容 2.《数据结构与算法分析》（C语言描述）- 适合初学者，介绍了常见的数据结构...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值