【算法与数据结构】链表、哈希表、栈和队列、二叉树（笔记二）

  最近博主学习了算法与数据结构的一些视频，在这个文章做一些笔记和心得，本篇文章就写了一些基础算法和数据结构的知识点，具体题目解析会放在另外一篇文章。在学习时已经有C， C++的基础。文章附上了学习的代码，仅供大家参考。如果有问题，有错误欢迎大家留言。算法与数据结构一共有三篇文章，剩余文章可以在 【CSDN文章】晚安66博客文章索引找到。

四、链表理论

  单链表：由一个个节点组成，每个节点由一个数据域和一个指针域组成，数据域放数据，指针域指向下一个节点，链表入口节点叫做head，最后一个节点的next指针指向NULL(空指针)。

  双链表：在单链表的基础上增加了一个指针域，这个指针域指向前一个节点，head的prev指针指向NULL。双链表既可以向前查，也可以向后查。

  循环链表：链表的首尾相连。循环链表可以解决约瑟夫环问题。

  数组在内存中是连续分布的，但是链表不是连续分布的，它通过指针域的指针链接在内存中的各个节点。
链表定义方式：

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

初始化链表：

// 法一 
ListNode* head = new ListNode(5);
// 法二
ListNode* head = new ListNode();
head->val = 5;

删除和添加节点：
  假如想删除图中D节点，那么我们将C节点指针指向E节点，然后释放D的内存（C++需要手动释放，Java，Python有内存回收机制，不需要手动释放）。

  假如要添加F节点，将C节点的指针指向F，F指针指向D即可。

查询：
  链表查询是比较费劲的，例如想找第10个节点，那么得从第一个节点开始，按指针域一个一个找，找到第九个节点才能找到第十个节点。因此，链表查询时间复杂度为 $O(n)$

项目	插入/删除	查询	使用场景
数组	$O(n)$	$O(1)$	数据量固定，频繁查询，较少增删
链表	$O(1)$	$O(n)$	数据量不固定，频繁增删， 较少查询

五、哈希表理论

  哈希表可以通过索引直接访问表中的元素。哈希表一般用来快速判断一个元素是否出现在集合里，但哈希法是牺牲空间换取时间，因为要使用额外的数组set或map才能实现快速查找。举个例子，班级里是否有小明这个同学，如果要用枚举时间复杂度为$O(n)$，但如果哈希表只需要$O(1)$就可以做到。

  在初始化时，只需要把全班的名字存在哈希表里，查询的时候通过姓名直接可以知道是否有这位同学。哈希表通过哈希函数(hash funciton)将学生姓名映射到哈希表上。

工作原理：如上图所示，哈希函数将姓名转换成数值索引（一般通过特定编码方式），然后按索引在哈希表上得到目标数据。同时为了保证哈希函数计算的索引一定落在哈希表中，还做了取模操作。有时候，学生数量会大于哈希表长度，不同学生会得到同一个索引，也就是映射到哈希表上同一个位置，也就出现所谓的哈希碰撞问题。

哈希碰撞解决办法：

• 1、拉链法：在碰撞位置引入链表，链表指向依次指向不同的学生。拉链法要注意适当选择哈希表大小，充分利用哈希表内存，同时不要生成太长的链表。
• 2、线性探测法：当发生碰撞时，就找表的下一个空位方置。因此，一定要保证哈希表大小大于数据大小。

常用的哈希表有：

• 数组
• 集合（set）
• 映射（map）

  在C++中，set和map提供了下面几种形式，使用集合来解决问题时，优先使用unordered_set，它底层用哈希表实现，查询效率和增删效率最高。只有处理有序数据时用set或者multiset（二者区别在于值能否重复）。

  虽然set、multiset、 map和multimap底层使用红黑树实现的，但是使用方式还是哈希表的key和value方式，同属于映射方法，同样可以归类到哈希法中。此外，红黑树是一种平衡二叉搜索树，key值是有序的，但key值不能修改，改动key值会导致整颗树错乱，所以智能删除和增加。map当中对key有限制，不可修改，value没有限制。

五、栈和队列理论

  首先是关于栈和队列的元素进出关系：栈是先进后出，队列是先进先出。栈提供push 和 pop 等等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器(iterator)。 不像是set 或者map 提供迭代器iterator来遍历所有元素。

  栈是以底层容器完成其所有的工作，对外提供统一的接口，我们可以控制使用哪种容器来实现栈的功能（栈是可插拔），例如vector，list，deque等等。所以STL中栈往往不被归类为容器，而被归类为container adapter（容器适配器）。目前最常见的SGI STL（STL库的其中一个版本），如果没有指定底层实现，默认以deque（双向队列）缺省为底层容器，只要封住一端，开通另一端就可以实现栈的逻辑。
  也可以指定vector为底层实现：

std::stack<int, std::vector<int> > third;  // 使用vector为底层容器的栈

  队列的情况是一样的，队列中先进先出的数据结构，同样不允许有遍历行为，不提供迭代器, SGI STL中队列一样是以deque为缺省情况下的底部结构。队列也不归为容器，也是容器适配器。

std::queue<int, std::list<int>> third; // 定义以list为底层容器的队列

5.1 单调栈

  单调栈问题长是针对一个一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置。单调栈可以在$O(n)$的时间复杂度内找到每一个元素的右边第一个比它大的元素位置。单调栈的本质是空间换时间，优点是整个数组只需遍历一次。我们使用一个栈来保存遍历过程中的元素。因为我们遍历数组的时候，我们不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以我们需要用一个容器（这里用单调栈）来记录我们遍历过的元素。

  单调栈问题需要考虑以下几点：

• 1. 单调栈里面存放的元素是什么？
• 2. 单调栈是递增还是递减的？
       这里的递增或者递减的顺序指的是从栈底到栈顶（栈头）的顺序，C++中使用STL库可以用st.top()来访问栈顶。

六、二叉树理论

6.1 树的定义

  首先引入树的度的概念：结点拥有的子树个数称为结点的度，比如下图中结点3和结点4的度分别为3和2。对于树而言，树的度是结点最大的度，下面这棵树的度为4（结点1的度）。

  二叉树是指树的度最大为2的树。满二叉树：如果一棵树只有度为0和度为2的节点，并且度为0的节点在同一层上，则这棵二叉树为满二叉树。如下图所示，这是一棵满二叉树。这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。

  完全二叉树：在完全二叉树中，除了最底层节点可能没有填满以外，其余每层节点数量都达到最大值，并且最下面一层节点都集中在该层的最左边若干位置。若底层为第k层，则该层包含$[1,2^{k-1}]$个节点。
  在【算法和数据结构】347、LeetCode前 K 个高频元素中提到的优先级队列。实际上，优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系。下图当中第三棵树就不是一棵完全二叉树。

  二叉搜索树：又叫二叉排序树。它具有下面三个特点：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉排序树

  平衡二叉排序树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。下图当中第三棵树就不是一棵平衡二叉树，左右两个子树的高度差绝对值超过了1。

  C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作的时间复杂度是$log(n)$。unordered_map、unordered_set底层实现是哈希表， 增删操作的时间复杂度为$O(1)$。详细内容可以看本文第五节。

6.2 二叉树的存储方式

  二叉树可以用链式存储，也可以顺序存储。那么链式存储方式就用指针， 顺序存储的方式就是用数组。链式存储如下图所示：

  顺序存储如下图所示，在遍历时，假设父节点为i那么它的左孩子就是$i\ast 2+1$，右孩子就是$i\ast 2+2$。相较于链式存储，顺序存储方式比较不容易理解，也不直观，所以一般我们用链式存储二叉树。

6.3 二叉树的遍历方式

二叉树主要有两种遍历方式，这两种也是图论当中最基本的两种遍历方式。

• 深度优先遍历：先往深处走，遇到叶子节点再往回走。
• 广度优先遍历：一层一层的去遍历。

在上面两种方式的基础之上进一步拓展，有如下的分类：

• 深度优先遍历

  • 前序遍历（递归法、迭代法）
  • 中序遍历（递归法、迭代法）
  • 后序遍历（递归法、迭代法）

• 广度优先遍历

  • 层次遍历（迭代法）

前中后是指中间节点的遍历顺序，是在前、中或者是后。例如，前序遍历：中左右；中序遍历：左中右；后序遍历：左右后。

  递归法和迭代法是这两种遍历的实现方法。深度优先遍历一般是用递归的方式实现，也就是说，用递归来实现前中后遍历比较方便。栈其实就是递归的一种实现结构，前中后遍历的逻辑也可以用栈使用非递归的方式来实现。广度优先遍历的实现一般使用队列来实现，队列是先进先出的结构，这样才能一层层的遍历二叉树。
  链式存储二叉树节点的定义方式如下，相较于链表节点，二叉树节点与其定义差不多，二叉树节点有两个指针分别指向了其左右孩子。
  树节点定义：

// 树节点定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

  迭代法实现前中后遍历：

class Solution {
public:
    // 前序遍历
    void traversal_preOrder(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        vec.push_back(cur->val);                // 中
        traversal_preOrder(cur->left, vec);     // 左
        traversal_preOrder(cur->right, vec);    // 右
    }
    // 中序遍历
    void traversal_midOrder(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;        
        traversal_midOrder(cur->left, vec);     // 左
        vec.push_back(cur->val);                // 中
        traversal_midOrder(cur->right, vec);    // 右
    }
    // 后序遍历
    void traversal_postOrder(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        traversal_postOrder(cur->left, vec);     // 左
        traversal_postOrder(cur->right, vec);    // 右
        vec.push_back(cur->val);                // 中
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal_preOrder(root, result);
        return result;
    }
};

6.4 高度和深度

  高度和深度是相反的表示，深度是从上到下数，而高度是从下往上数。深度指从根节点到该节点最长简单路径边数，而高度指从该节点到叶子节点的最长简单路径边数。叶子节点是指没有子节点的节点。假设根节点的深度和叶子节点的高度为1，那么树的深度和高度是相等的，而对其他节点来说高度和深度不一定相等。例如下图当中，8这个节点的深度为2，高度为4。

end