Cpp on pipo's site

0-1 Package

Sun, 24 Nov 2024 00:00:00 +0000

例题讲解

基础的零一背包

给定背包容量和两个数组.两数组分别代表各物品的价值和体积.

求给定背包容量内的最大价值

零一背包中的零一指的是两种状态 0:不选择 1:选择每次不同的容量和不同的物品都要作出一次零一判断

而最终结果由之前的状态或者选择所决定决定最终背包中所装物品的属性两个容量价值 dp[物品][容量] 最终返回时返回的 dp[最后一个物品][给定背包容量]

有 a b c d 物品属性分别是
c(体积) 1 3 2 v(价值) 2 4 6 给定背包容量为 5

0	1	2	3	4	5
a	2	2	2	2	2
b	2	2	4	6	6
c	2	6	8	8	10

横向0 1 2 3 4 5代表着当背包容量为n时的最大价值纵向 a b c 则代表着当前选择放入的物品 (x, y) –> (a, 1) == 当容量为 1 时当前是否放入物品 a 判断过程: 1 >= a 体积可选择放入当放入后剩余空间 1-a 体积 == 0, 比较空间为 0 时的最大价值 + a 的价值和上一个物品的在当前容量下的最大价值. 返回最大值

for (int i = 1; i <= obj.size(); i++) {
    for (int j = 0; j < cap; j++) {
        if (j < c[i-1]) {
            dp[i][j] = dp[i-1][j];
        }
        else{
            dp[i][j] = max(dp[i-1][j], dp[i-1][j-c[i-1]]+ v[i-1]);
        }
            
    }
}

应先初始化 dp[0][j] = 0; 因为当容量为0时,价值只能为0

LC416 分割等和子集

给定一个非0正整数数组, 判断是否可以分为n两个子数组使得 arr1 == arr2 也就是 arr1 + arr2 = sum 首先可以通过和是否为偶数来判断 sum & 1 == 1 return false;

题目要求判断是否可分而不是要求找出两个子集所以问题可转化成是否可以在数组中凑出和为 sum / 2 就可以转换成容量为n的背包是否可以找出一系列物品恰好装满因为每次是在判断能否恰好装满,所以只需要记录是否可以装满即可 c(体积) 1 3 2

0	1	2	3	4	5
a	true	false	false	false	false
b	true	false	true	true	false
c	true	true	true	true	true

dp[arr.size()+1][sum/2 + 1];

此处也应先初始化 dp[0][j] = true; 因为 0 无需放入元素即可满足. 判断过程当前物品体积 > 容量 –> 不满足,填入上一行的结果当前物品体积 <= 容量 –> 满足,填入上一行减去物品体积后对应结果

 for (int i = 1; i < arr.size()+1; i++) {
    for (int j = 0; j < sum/2 +1; j++) {
        if (j < arr[i-1]) dp[i][j] = dp[i-1][j];
        dp[i][j] = dp[i][j - arr[i-1]];

    }
 }

若按这种方式遍历会出现严重逻辑错误,因为当从左到右更新时可能会使用到前一次更新的值. 因此需要倒序遍历,避免这种情况.

    for (int i = 1; i < arr.size() + 1; i++){
        for (int j = sum/2; j >= 0; j--) {
            if (j < arr[i-1]) dp[i][j] = dp[i-1][j];
            else dp[i][j] = dp[i-1][j- arr[i-1]] || dp[i-1][j];
            if (dp[i][sum/2] == 1) return true;
        }
    }

采用倒序遍历后有许多点需要注意:

初始化问题,采用正序遍历时因为从下标 1 开始所使用的值都是已经正确赋值过的, 所以可以不初始化后续,但后续遍历就会出现相应问题, 所以需要统一初始化或者使用 STL 中的 vector 解决初始化问题.
1. 倒序遍历时不能在同一行"减去"容量,因为i此时i还没有继承上一行已更新的值, 所以为规范写法统一为dp[i][j] = dp[i-1][j - arr[i-1]].
2. 继承问题,与第二点相同,“减去"容量后发现无法凑出不会去继承上一行已有的结果,所以加入|| dp[i-1][j];.

LC1049 最后一块石头的重量 II

给定一个数组 arr, 每次选出两个数 “碰撞” 返回abs(x-y),直至只剩一个数字返回它可能的最小值.

要求最小的最后一块石头重量,我们可以模拟一下步骤.

[31,26,33,21,40]

33 - 31 = 2 40 - 26 = 14 21 - 14 = 7 14 - 7 = 7 7 - 2 = 5

可以发现我们每次是进行如下操作分为两堆石头

[33, 40] - [31, 26] 将剩余石头放回 [2, 14, 21]

[21] - [14] [7, 2]

[7] - [2] [5]

假设有 n个石头那么可以分成 [a1, a2, ..., an/2] - [b1, b2, ..., bn/2] 但是每次这样分放太过麻烦,其实可以直接转化成两个子序列问题,此时就与 LC416基本相同.

可以转化的推导过程如下:

(a1+a2+a3+a4) - (b1+b2+b3+b4) = sum if a1-b1 > 0 (a2+a3+a4+(a1-b1)) - (b2+b3+b4) —> (a1+a2+a3+a4) - b1 -(b2+b3+b4)

if a1 - b1 < 0 (a2+a3+a4) - (-(a1-b1)+b2+b3+b4) —> (a2+a3+a4) + a1 - (b1+b2+b3+b4) 从推导过程可看出每次碰撞产生的新石头再次加入到碰撞中与之前相同,所以无需每次分放.

那么任务就是找出arr1 + arr2 = arr并且使得 arr1 - arr2最小,这时我们发现其与 LC416的相似处. 可以通过找arr1 == sum/2 然后 sum -= 2*arr1 获得最小值.

for (int i = 1; i < stones.size()+1; i++) {
    for (int j = 1; j < sum/2 +1; j++) {
        if (j >= stone[i-1]) {
            dp[i][j] = dp[i-1][j] || dp[i-1][j-stones[i-1]];
        }
        else {
            dp[i][j] = dp[i-1][j];
        }
    }
}

 for (int j = sum/2 ; j >= 0; j--) {
            if (dp[stones.size()][j] == true) {
                sum -= 2*j;
                break;
            }
        }

LC494.目标和

给定一个数组和一个目标值,要求对这些数添加”+“和”-",找出使和为目标值的所有组合次数.

一组数如 1, 1, 1, 1, 1; 目标值为3, 那么就有 1 - 1 + 1 + 1 + 1 = 3 1 + 1 - 1 + 1 + 1 = 3 1 + 1 + 1 - 1 + 1 = 3 1 + 1 + 1 + 1 - 1 = 3 -1 + 1 + 1 + 1 + 1 = 3 所有能组合为3的情况有5种

此时问题就是必须把所有物品放入背包,每个物品有两种状态"+“和”-",这两种状态与0与1基本一致,那么背包的容量范围就是[-sum, sum],于是可以写出如下代码.(这里很像一次操作,是在背包内减去或者加入体积为arr[index]的物品)

vector<<vector<int>> dp(arr.size()+1, vector<int>(sum*2+1, 0));
dp[0][sum] = 1;

这里需要强调的是初始化问题,在之前的题中我们基本是将所有行的 0 处初始化,而这里只初始化 0 行的 sum 为一.

首先因为容量范围是 -sum 到 sum ,下标是 0 到 sum*2+1,产生了偏移,所以和为 0 时下表对应着 sum.

其次是只初始化 0 行的问题, 每行中的一个数都是代表着在(-1, index-1]的子序列中可以组合出当前数的次数,当index = 0 + sum; 时表示arr的子序列 { },此时不存在元素所以可以使得和为 0, 如果将所有行的sum处初始化为零就不符合情况了.

比如当前子序列是 {1},不可能出现和为0的情况.

for (int i = 1; i < arr.size()+1; i++) {
    for (int j = 0; j < 2*sum+1; j++) {
		if (j - arr[i] >= 0) { //防止越界
            dp[i][j] += dp[i-1][j-arr[i-1]];
        }
        if (j + arr[i] <= 2*sum) {
            dp[i][j] += dp[i-1][j+arr[i-1]];
        }
    }
}

LC.474 一和零

给一个二进制字符串和两个整数m与n,找出一个该数组的最长子集,子集内部的 0和1数量小于等于m和n,返回该子集长度.

再次回顾一下零一背包, 零一背包通常是在有限的容量求最大价值,或是特定的容量求特定价值.

一般的零一背包只有一个限制,而本题则同时有两个限制m和n,相当于既要能装入最大容量为m的背包又能装入最大容量为n的背包.

所以我们需要初始化一个三维数组

int dp[arr.size()+1][m+1][n+1]; //vector<vector<vector<int>>> dp(strs.size()+1, vector<vector<int>>(m+1,vector<int>(n+1,0)));

然后是核心逻辑的实现,我们要同时满足m和n,所以额外的判断如下

if (j >= msize && k >= nsize) { 
    //.....
}

其余部分和普通零一背包基本相同

for (int k = 1; k < strs.size()+1; k++) {
                int msize = count(strs[k-1].begin(), strs[k-1].end(), '0');
                int nsize = strs[k-1].size() - msize;
    
            for (int i = m; i >= 0; i--) {
                for (int j = n; j >= 0; j--) {
                    if (j >=  nsize && i >= msize) {
                        dp[k][i][j] = max(dp[k-1][i][j], dp[k-1][i-msize][j-nsize]+1);
                    }
                    else {
                        dp[k][i][j] = dp[k-1][i][j];
                    }
                }
            }
        }

问题的基本解法已经讲完,我们现在来对每个问题进行梳理.

问题分析

特征提取

原始零一背包
- 给定物品(体积 + 价值) 和背包容量
- 求最大价值(选择物品体积小于等于背包容量时的最大价值)
分割等和子集
- 给定物品(只有体积) 和背包容量(需要凑出的sum/2)
- 求最大容量是否可以装满(选择物品体积是否可以等于背包最大容量)
最后一块石头重量II
- 给定物品(只有体积) 和背包容量
- 求最大容量(能够凑出的最大体积)
目标和
- 给定物品(只有体积) 和背包(容量不定)
- 求特定体积(让背包体积刚好等于目标值)
一和零
- 给定物品(价值相同,体积不同) 和两个背包
- 求最大价值(选择物品体积同时小于等于两个背包的最大体积)

通过上面对比和上述题解可以发现,零一背包的特征总是:

给定的数据为离散数据,且只能选择一次不可复用.
决策通常只有选择与不选择且常受条件限制(比如当前容量)
求解目标往往是求最优解或者验证最优解是否可行
每一个解都由前一步和当前情况共同决定,最终结果由初始结果递推得来.
获得最终解往往需要穷尽所有组合

思考过程

示例

金明的预算方案

题目描述

金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过 $n$ 元钱就行”。今天一早，金明就开始做预算了，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：

主件	附件
电脑	打印机，扫描仪
书柜	图书
书桌	台灯，文具
工作椅	无

如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 $0$ 个、$1$ 个或 $2$ 个附件。每个附件对应一个主件，附件不再有从属于自己的附件。金明想买的东西很多，肯定会超过妈妈限定的 $n$ 元。于是，他把每件物品规定了一个重要度，分为 $5$ 等：用整数 $1 \sim 5$ 表示，第 $5$ 等最重要。他还从因特网上查到了每件物品的价格（都是 $10$ 元的整数倍）。他希望在不超过 $n$ 元的前提下，使每件物品的价格与重要度的乘积的总和最大。

设第 $j$ 件物品的价格为 $v_j$，重要度为 $w_j$，共选中了 $k$ 件物品，编号依次为 $j_1,j_2,\dots,j_k$，则所求的总和为：

$$v_{j_1} \times w_{j_1}+v_{j_2} \times w_{j_2}+ \dots +v_{j_k} \times w_{j_k}$$

请你帮助金明设计一个满足要求的购物单。

输入格式

第一行有两个整数，分别表示总钱数 $n$ 和希望购买的物品个数 $m$。

第 $2$ 到第 $(m + 1)$ 行，每行三个整数，第 $(i + 1)$ 行的整数 $v_i$，$p_i$，$q_i$ 分别表示第 $i$ 件物品的价格、重要度以及它对应的的主件。如果 $q_i=0$，表示该物品本身是主件。

输出格式

输出一行一个整数表示答案。

样例 #1

样例输入 #1

样例输出 #1

数据规模与约定

对于全部的测试点，保证 $1 \leq n \leq 3.2 \times 10^4$，$1 \leq m \leq 60$，$0 \leq v_i \leq 10^4$，$1 \leq p_i \leq 5$，$0 \leq q_i \leq m$，答案不超过 $2 \times 10^5$。

给定的数据为离散数据，且只能使用一次
物品只有买与不买的选择，而且受到最大金额限制
求解目标是使总和（$$v_{j_k} \times w_{j_k}$$)最大

首先我们读题可以知道附件的必须跟随主件购买而且每个主件最多只有两个附件，所以我们可以将题目数划分为${ \text{主件}_1, \text{附件}_1, \text{附件}_2 },\quad { \text{主件}_2, \text{附件}_1, \text{附件}_2 },\quad \dots ,\quad { \text{主件}_n, \text{附件}_1, \text{附件}_2 }$。

于是我们每次进行决策时有以下情况

$$\text{选择：} \left{ \begin{aligned} &\text{购买主件} \quad \left{ \begin{aligned} &\text{购买附件 1} \quad \left{ \begin{aligned} &\text{购买附件 2} \ &\text{不购买附件 2} \end{aligned} \right. \ &\text{不购买附件 1}\quad\left{ \begin{aligned} &\text{购买附件 2} \ &\text{不购买附件 2} \end{aligned} \right. \end{aligned} \right. \ &\text{不购买主件} \end{aligned} \right.$$

我们秩序要将在每次作出是否购买主件的决策后再进行附件的购买决策即可

for (int i = 1; i < mainItemsValue.size(); i++) {
        for (int j = budget; j >= mainItemsValue[i]; --j) {
            if (j >= mainItemsValue[i]) dp[j] = max(dp[j], mainItemsWeight[i] + dp[j - mainItemsValue[i]]);
            if (j >= mainItemsValue[i] + accessoryItemsValue[i][1]) dp[j] = max(dp[j], mainItemsWeight[i] +
                                                                                        accessoryItemsWeight[i][1] +
                                                                                        dp[j - mainItemsValue[i] - 		   																								accessoryItemsValue[i][1]]);
            if (j >= mainItemsValue[i] + accessoryItemsValue[i][2]) dp[j] = max(dp[j], mainItemsWeight[i] +
                                                                                        accessoryItemsWeight[i][2] +
                                                                                        dp[j - mainItemsValue[i] - 																										accessoryItemsValue[i][2]]);
            if (j >= mainItemsValue[i] + accessoryItemsValue[i][1] + accessoryItemsValue[i][2]) dp[j] = max(dp[j], 																										mainItemsWeight[i] +
                                                                                        accessoryItemsWeight[i][1] +
                                                                                        accessoryItemsWeight[i][2] +
                                                                                         dp[j - mainItemsValue[i] -
                                                                                         accessoryItemsValue[i][1] -
                                                                                         accessoryItemsValue[i][2]]);


        }
    }

完整AC代码

int main(int argc, char *argv[]) {
    int budget, numsOfItems;
    vector<int> mainItemsValue(61);
    vector<int> mainItemsWeight(61);
    vector<vector<int>> accessoryItemsValue(61, vector<int>(3, 0));
    vector<vector<int>> accessoryItemsWeight(61, vector<int>(3, 0));

    cin >> budget >> numsOfItems;
    vector<int> dp(budget+1, 0);
    for (int i = 1; i <= numsOfItems; i++) {
        int value, importance, itemType;
        cin >> value >> importance >> itemType;
        if (itemType == 0) {
            mainItemsWeight[i] = importance * value;
            mainItemsValue[i] = value;
        }
        else {
            accessoryItemsValue[itemType][0]++;
            int index = accessoryItemsValue[itemType][0];
            accessoryItemsValue[itemType][index] = value;
            accessoryItemsWeight[itemType][index] = importance * value;
        }

    }
    for (int i = 1; i < mainItemsValue.size(); i++) {
        for (int j = budget; j >= mainItemsValue[i]; --j) {
            if (j >= mainItemsValue[i]) dp[j] = max(dp[j], mainItemsWeight[i] + dp[j - mainItemsValue[i]]);
            if (j >= mainItemsValue[i] + accessoryItemsValue[i][1]) dp[j] = max(dp[j], mainItemsWeight[i] +
                                                                                        accessoryItemsWeight[i][1] +
                                                                                        dp[j - mainItemsValue[i] - 		   																								accessoryItemsValue[i][1]]);
            if (j >= mainItemsValue[i] + accessoryItemsValue[i][2]) dp[j] = max(dp[j], mainItemsWeight[i] +
                                                                                        accessoryItemsWeight[i][2] +
                                                                                        dp[j - mainItemsValue[i] - 																										accessoryItemsValue[i][2]]);
            if (j >= mainItemsValue[i] + accessoryItemsValue[i][1] + accessoryItemsValue[i][2]) dp[j] = max(dp[j], 																										mainItemsWeight[i] +
                                                                                        accessoryItemsWeight[i][1] +
                                                                                        accessoryItemsWeight[i][2] +
                                                                                         dp[j - mainItemsValue[i] -
                                                                                         accessoryItemsValue[i][1] -
                                                                                         accessoryItemsValue[i][2]]);


        }
    }
        cout << dp[budget] << endl;
}

BinaryTree 迭代层序遍历

Sat, 05 Oct 2024 00:00:00 +0000

二叉树的迭代遍历法（基于栈实现）

题目链接

144.二叉树的前序遍历

94.二叉树的中序遍历

145.二叉树的后序遍历

前序遍历法

不通过递归来实现二叉树的遍历，就需要一种数据结构能够记录我们的遍历顺序，并能按照某种顺序输出。

其中栈便是一种实现这种功能的数据结构，遵循着FILO规则我们可以轻易想到如果按照 右左前 的顺序放入栈，那么再依次弹出即可。

但是我们知道，这里的 右左 内部都包含这各自的 右左前，要想全部装填好后再弹出是不现实的，只能一边弹出一边填入。

因为是前序遍历，所以我们可以在装入stack后立即弹出加入res数组，接着将 右左 ,装入stack，这时我们就需要将 左 看作完整树，那么重复上述步骤，弹出元素，将这个节点的 右左 装入stack。

我们可以写出如下代码

vector<int> preorderTraversal(TreeNode* root) {
        std::stack<TreeNode*> st;
	    std::vector<int> res;
	    if(root != nullptr ) st.push(root); //将 `前` 加入
	    while(!st.empty()){
            root = st.top();//选择最后一个元素
            res.push_back(root->val); //进入res数组
            st.pop(); //弹出
            if (root->right != nullptr)
            {
                st.push(root->right);
            }
            if (root->left != nullptr)
            {
                st.push(root->left);
            }

        }
        return res;
    }

前序遍历的迭代方式是最简单理解的，其他中序后序难度相较其稍高，需要多理解找出相似点与不同点。

中序遍历法

我们知道前序遍历会沿着左侧方向不断遍历直到为空，此时回到父节点，然后再进入右子树，向左不断遍历，如图所示。

我们可以根据这个图来写基本的框架

while !root or !st.empty() 
    while root is not Null  
    //这里对应1， 将当前树的所有左节点加入栈
        st.push(root)
        root = root->left
//此时已全部加入，开始返回加入res数组，并将右子树加入栈
    root = st.top()
    res.push(root->val)
    st.pop()
    root = root->right

我们可以写出如下代码

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        std::stack<TreeNode*> st;
	    std::vector<int> res;
       while(root != nullptr || !st.empty()){
	    while(root != nullptr){
            st.push(root);
            root = root->left;
        }
            root = st.top();
            st.pop();
            res.push_back(root->val);
            root = root->right;

       }

        return res;
    }
};

后序遍历法

后序遍历法我们可以参照中序遍历法，在其基础上修改。

while !root or !st.empty() 
    while root is not Null  
        st.push(root)
        root = root->left
        
    root = st.top()
    res.push(root->val)
    st.pop()
    root = root->right

仔细观察代码，我们可以发现，如果想实现后序遍历 while root is not Null 这一块不需要改变，我们应该要先去遍历右子树，最后才能将当前节点加入到res。

我们发现当左节点访问完要先访问右节点有如下几种情况：

右节点存在，且未被访问
右节点存在，且已被访问
右节点不存在

其中便引出了第二点与中序不同的点，我们需要判断这个右节点是否被访问了，我们这里添加一个prev指针用来记录右节点是否被访问。

因为从上图中我们可以看出只有右节点访问完成后，返回父节点，此时才会遇到右节点存在，且已被访问的情况，所以我们只需要记录上一个节点即可。

2. 3.
if root->right == null or root->right == prev
	//右节点不存在           存在且被访问
	res.push_back(root->val)
    prev = root
    root = nullptr

这里有一点我们需要注意，那就是最后将root赋值为nullptr,此时如果不这样赋值，就会再次进入将左节点加入栈的循环。当然我们可以利用prev指针来避免，但是我们尽量少修原代码。

1.
else
	st.push(root)
	root = root->right

最后完整实现代码

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        std::stack<TreeNode*> st;
	    std::vector<int> res;
	    TreeNode* prev = nullptr;
       while(root != nullptr || !st.empty()){
	    while(root != nullptr){
            st.push(root);
            root = root->left;
        }
            root = st.top();
            st.pop(); 
            if(root->right == nullptr || root->right == prev){
				res.push_back(root->val);
    			prev = root;
    			root = nullptr;
		}
			else{
			st.push(root);
			root = root->right;
		}
      }

        return res;
    }
};

当然，后序遍历还有一种简单的办法，就是在前序遍历的基础上将结果反转，不过这样就失去了这道题的意义。

后序遍历的另一种实现

vector<int> postorderTraversal(TreeNode* root) {
      std::stack<TreeNode*> st;
	    std::vector<int> res;
	    if(root != nullptr ) st.push(root);
	    while(!st.empty()){
            auto temp = st.top();
            res.push_back(temp->val);
            st.pop();
            if (temp->left != nullptr)
            {
                st.push(temp->left);
            }
            if (temp->right != nullptr)
            {
                st.push(temp->right);
            }

        }
        reverse(res.begin(), res.end());
        return res;
    }

递归实现

因为递归实现比较简单，所以不作讲解，只列出代码。

class Solution {
public:
	void dfs(TreeNode* root, vector<int>& res){
		if(root != nullptr){
			dfs(root->left, res);
                        res.push_back(root->val);
			dfs(root->right, res);
            //只需要调整顺序就可以实现前中后序遍历
		}
		
	}
    vector<int> inorderTraversal(TreeNode* root) {
    	vector<int> res;
    	if(root == nullptr) return res;
    	dfs(root, res);
    	return res;
    }
};

BinaryTree 层序遍历 LC.102

Wed, 02 Oct 2024 00:00:00 +0000

102. 二叉树的层序遍历

题目地址：102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

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

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

这里是题目给出的二叉树定义

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

在此我们先不去管题目的输出要求，我们来讲一下如何去用队列实现二叉树的层序遍历。

什么是层序遍历？

层序遍历就是按照从顶至底的方式，按照一定的顺序将处于同一树层的元素全部访问的过程。

核心思想算法

从图中我们可以看出，每次只有遍历完当前层的所有节点后，才到下一层进行遍历，像这种从一个节点开始，像辐射一样把所有可行的路径探索后才访问下一层的访问方式叫做广度优先搜索(Breadth-first search)简称BFS。

BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。

使用队列来存储每一层的节点。
从根节点开始，将其加入队列。
当队列非空时，执行以下步骤：
- 获取当前队列的大小（即当前层的节点数）。
- 遍历当前层的所有节点：
  - 将节点从队列中取出。
    - 将该节点的值加入结果。
    - 如果该节点有左子节点，将左子节点加入队列。
    - 如果该节点有右子节点，将右子节点加入队列。

其中能保证按照有序按层输出的主要是因为我们将节点访问顺序依次加入了队列，在每次弹出时又仅仅将下一层的节点加入，我们可以写出如下代码。

vector<int> levelOrderTraversal(BinaryTree* root){
        queue<BinaryTree*> q;
        int size = 0;
        vector<int> visited;
        
        if(root == nullptr) return visited; //若树为空，直接返回.
            q.push(root);
      
            while(!q.empty()){ //若队列为空，此时已全部访问
                    BinaryTree* temp = q.front();  
                    q.pop(); //弹出首元素
                    visited.push_back(temp->val); //装入visited
                    if(temp->left != nullptr) q.push(temp->left); //若节点不为空，将节点加入待访问队列
                    if(temp->right != nullptr) q.push(temp->right);
                	
                }
        
        return visited;
    }

题解

BFS队列实现

掌握了基本了的思想，我们现在回到题目。题目要求我们返回的是一个二维数组，也就是对在同一层的节点值进行分层，我们需要对每层的节点数做单独的记录，当计数器为零时，将数组中的元素加到res数组中。

while(!q.empty()){
            int size = q.size(); //每次记录当前层内节点数
            vector<int> visited;
            while(size > 0){ //只有当前层全部访问完之后 才将结果加入res
                auto tmp = q.front();
                visited.push_back(tmp->val);
                q.pop();
                if(tmp != nullptr && tmp->left != nullptr) q.push(tmp->left);
                if(tmp != nullptr && tmp->right != nullptr) q.push(tmp->right);
                size--;
            }
            res.push_back(visited);
        }

DFS递归实现

这是使用队列的解法，我们也可以使用递归进行求解，这里只简单介绍思路。

调用DFS函数将本节点元素加入res数组对应层数depth，然后递归调用传入左右节点，增加层数depth+1，如此即使访问顺序虽然是深度优先，但依然能正确传入对应层数。

void dfs(TreeNode* node, int depth, vector<vector<int>>& res) {
        if (!node) return;
        
        if (depth >= res.size()) {
            res.push_back(vector<int>());
        }
        
        res[depth].push_back(node->val);
        
        dfs(node->left, depth + 1, res);
        dfs(node->right, depth + 1, res);
    }

Queue

Sun, 29 Sep 2024 00:00:00 +0000

队列

队列(Queue)是遵循先进先出(FIFO)规则的线性数据结构,正如同它的名字一样，先进入队列排队的元素会首先离开队列，像在羽毛球桶里的羽毛球一样，先放进去的球会从下面先取出来。

如图所示，删除队首元素的过程叫做出队，将新元素加入队尾的过程叫做入队。

栈的实现

STL中队列的使用

使用标准库中队列前首先应引入头文件**<queue>**,下面将简单介绍队列简单的使用。

#include <queue>
//队列的声明
std::queue<data_type> q1;
std::queue<data_type> q2;

//向队列中添加元素
q1.push(val);

//删除队首元素
q1.pop();

//复制队列
q1 = q2;

//访问队首和队尾元素
q1.front();
q1.back();

//检查队列是否为空与获取元素
q1.empty();
q1.size();

应注意的一点是，pop()没有返回值，需要先使用front()再次使用pop().

基于链表的实现

class Queue{
	private:
		Node* front;
		Node* back;
		int quesize;
	public:
		Queue(){
			front = nullptr;
			back = nullptr;
			quesize = 0;
		}
		~Queue(){
			freeMemoryNode(front);
		}
    
    	int getSize(){
            return quesize;
        }
    	
    	bool isEmpty(){
			return quesize == 0;
        }
    
    
		void push(int val){
			Node* node = new Node(val);
			if(front == nullptr){
				front = node;
				back = node;
			}
            
            else{
            	back->next = node;
				back = node;
            }
			quesize++;
		}
    	
    	void pop(){
            if(isEmpty()) throw std::runtime_error("队列为空");
            Node* tmp = front->next;
            delete front;
            front = tmp;
            quesize--;
        }
    
    	int peek(){
			if(isEmpty()) throw std::runtime_error("队列为空");
            return back->val;
        }
    	
    	
};

基于数组的实现

为能专注于对队列的实现和理解，我们这里使用标准库中的**<vector>**实现。

在数组中删除元素的操作时间复杂度为$O(n)$,如果我们直接删除的话就不等于队列删除元素的操作时间复杂度$O(1)$了，所以我们这里使用front和back作为队列的首尾，每次删除只将front后移一位，而不删除元素。

#include <vector>
class Queue{
	private:
		std::vector<int> queue;
		int front;
		int back;
		int quesize;
	public:
		Queue(){
			front = -1;
			back = -1;
			quesize = 0;
		}
		~Queue(){
			//vector自动管理内存
		}
		
		int getSize(){
            return quesize;
        }
    	
    	bool isEmpty(){
			return quesize == 0;
        }
    
    
		void push(int val){
			queue.push_back(val);
			if(front == -1){
				front = 0;
				back = 0;
			}
            
            else{
            	back = queue.size()-1;
            }
			quesize++;
		}
    	
    	void pop(){
            if(isEmpty()) throw std::runtime_error("队列为空");
            front++;
            quesize--;
        }
    
    	int peek(){
			if(isEmpty()) throw std::runtime_error("队列为空");
            return queue[front];
        }
		
};

*为什么不使用C风格数组

如果不使用vector，则需要预制数组大小，并且在即将超出数组大小限制时进行扩容操作，或者将back再次指向那些被`删除`元素的下标，但这样依旧会面临扩容操作，这两种操作方式较为复杂此处不再赘述。

队列各操作效率

操作名	时间复杂度
pop()	$O(1)$
push()	$O(1)$
peek()	$O(1)$

队列相关题目

二叉树迭代法实现层序遍历：102. 二叉树的层序遍历 - 力扣（LeetCode）

Stack 基础总结

Sun, 29 Sep 2024 00:00:00 +0000

栈

栈(Stack)属于线性数据结构，它遵循着先进后出(FILO)原则,就像是在杠铃上的杠铃片，要想拿到最开始放进去的片必须把在它之后的所有杠铃片全部弹出(pop),而每次加新片只能在末尾压入(push),通常我们把最后一个入栈元素的位置叫做`栈顶`,最先入栈的元素叫做`栈底`.

栈的实现

在CPP中有内置的栈包含在stack头文件中，但这里我们分别用数组和链表来模拟栈的基本功能。

基于数组的实现方式

class Stack{
    private:
        std::vector<int> st;
        
    public: 
        //获取栈的大小
        int getSize(){
            return st.size();
        }

        //检查是否为空
        bool isEmpty(){
            return st.empty();
        }

        //返回栈顶元素
        int peek(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            return st.back();        
        }

        //添加元素
         void push(int val){
            st.push_back(val);
         }

         //弹出元素
         void pop(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            st.pop_back();
         }


};

基于链表的实现方式

class Stack{
    private:
        Node* st;
    
    public:

        Stack() : st(nullptr) {} 

    // 析构函数，防止内存泄漏
    ~Stack() {
        while (!isEmpty()) {
            pop(); 
        }
    }
        //获取栈的大小
        int getSize(){
            Node* tmp = st;
            int size;
            for(size = 0; tmp != nullptr; size++){
                tmp = tmp->next;
            }
            return size;
        }

        //检查是否为空
        bool isEmpty(){
            if(st == nullptr) return true;

            else return false;
        }

        //返回栈顶元素
        int peek(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            return st->val;        
        }

        //添加元素
        void push(int val){
            Node* nd = new Node(val);
            nd->next = st;
            st = nd;
            
         }
        

         //弹出元素
         void pop(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            auto tmp = st->next;
            delete st;
            st = tmp;
         }


};

Node的详细实现详见链表,此处只简单实现。

class Node{
	public:
		int val;
		Node* next;
		Node(int value): val(value), next(nullptr) {}
}

值得注意的是此处新元素的插入与链表直接在尾部插入不同，而是在头部插入，并将新的节点作为头节点。

*两种实现的对比

支持操作

两种实现都支持栈定义中的各项操作。数组实现额外支持随机访问，但这已超出了栈的定义范畴，因此一般不会用到。

时间效率

在基于数组的实现中，入栈和出栈操作都在预先分配好的连续内存中进行，具有很好的缓存本地性，因此效率较高。然而，如果入栈时超出数组容量，会触发扩容机制，导致该次入栈操作的时间复杂度变为 O(n) 。

在基于链表的实现中，链表的扩容非常灵活，不存在上述数组扩容时效率降低的问题。但是，入栈操作需要初始化节点对象并修改指针，因此效率相对较低。不过，如果入栈元素本身就是节点对象，那么可以省去初始化步骤，从而提高效率。

综上所述，当入栈与出栈操作的元素是基本数据类型时，例如 int 或 double ，我们可以得出以下结论。

基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高。

基于链表实现的栈可以提供更加稳定的效率表现。

空间效率

在初始化列表时，系统会为列表分配“初始容量”，该容量可能超出实际需求；并且，扩容机制通常是按照特定倍率（例如 2 倍）进行扩容的，扩容后的容量也可能超出实际需求。因此，基于数组实现的栈可能造成一定的空间浪费。

然而，由于链表节点需要额外存储指针，因此链表节点占用的空间相对较大。

综上，我们不能简单地确定哪种实现更加节省内存，需要针对具体情况进行分析。

栈相关练习题

二叉树的迭代法进行前中后序遍历

链表基础总结

Sat, 28 Sep 2024 00:00:00 +0000

链表

链表基本组成

链表(linked list)属于线性数据结构，其主要由数据本身和指向下一节点的指针构成。

在一般的链表中，头节点为第一个节点，在某些实现中，头节点本身不包含元素，尾节点的next指针指向'空’，其本身为null，nullptr或者None。

graph LR subgraph head A`[next] end head-->1 subgraph 1 B[1] B`[next] end 1-->2 subgraph 2 C[2] C`[next] end 2-->3 subgraph 3 D[3] D`[next] end 3-->4 subgraph 4 E[4] E`[next] end 4 -->None subgraph None F`[null] end

其基本组成单位是节点(node),与数组不同，每个节点在计算机的内存中都是随机存放的，所有要找到下一个节点所在的位置就需要存储下一节点位置的指针，因此通常情况下链表所占用的内存空间要大于数组。

class Node{
	public:
		int val;
		Node* next;
		Node(int value): val(value), next(nullptr) {} //构造函数 赋值
};

链表的基础操作

1. 链表初始化

链表初始化分为两步，先将节点赋值，再构建节点之间的关系，当链表正确初始化之后便可以从头节点开始遍历所有元素了。

Node* node1 = new Node(1);
Node* node2 = new Node(2);
Node* node3 = new Node(3);
Node* node4 = new Node(4);
//创建节点并赋值
node1->next = node2;
node2->next = node3;
node3->next = node4;
//连接节点

2. 插入

链表的插入本质上是在内存中开辟一个单位的Node空间，赋值后将插入位置的前一个节点Node(n)的next指针指向这块内存，将该节点next指针指向原链表之后的节点Node(n+1),相比数组更快，因此时间复杂度仅为$O(1)$.

Node* insert(Node* node, Node* head){
     //直接在尾节点处插入
	if(head == nullptr) return node;
	Node* curr = head;
	while(curr->next && curr){   //在尾节点插入复杂度为O(n)
		curr = curr->next;
		}
	curr->next = node;
	return head;
}

Node* insert2(Node* node, Node* p){
	//在p节点之后插入
    Node* tmp = p->next;
	p->next = node;
	node->next = tmp;
	return node;
}

3. 删除

删除与插入的逻辑基本相同，找到待删除节点，与其前驱，将前驱的next节点指向待删除结点的next节点，然后删去该节点。

void deletenode(Node* n){
	//删去n之后的首个节点
	Node* tmp;
	if(n == nullptr || n ->next == nullptr) return;
	tmp = n->next->next;
	delete(n->next);
	n->next = tmp;
}

4. 访问与查找节点

在链表中访问节点的速度较慢，每次必须从头节点开始遍历直到找到，其时间复杂度为$O(n)$, 而数组的访问为$O(1)$.

Node* access(Node* head, int index){
	Node* curr = head;
	for(int i = 0; i < index; i++){
		if(curr == nullptr) return curr;
		curr = curr->next;
	}
	return curr;
}
Node* find(Node* head, int val){
    //查找第一个值为val的节点
	Node* curr = head;
    while(curr != nullptr){
		if(curr->val == val) return curr;
        curr = curr->next;
    }
    return nullptr;
}

常见的链表

单向链表 ：即上述介绍的链表，只能单方向地从头节点遍历到尾节点，在进行插入删除等操作时，需要随时保存前驱节点。
双向链表 : 相比单向链表增加了prev指针用于保存上一个节点，在使用时更加灵活，但是也加大了内存开销。

graph LR subgraph head A`[next] end head-->1 subgraph 1 B[1] B`[next] end 1-->2 1-->head 2-->1 subgraph 2 C[2] C`[next] end 2-->3 3-->2 subgraph 3 D[3] D`[next] end 3-->4 4-->3 subgraph 4 E[4] E`[next] end 4 -->None None-->4 subgraph None F`[null] end
```
class ListNode{
public:
//双向链表
  int val;
  Node* next;
  Node* prev;
  Node(int value): val(value), next(nullptr), prev(nullptr) {} //构造函数 赋值
};
```
环形链表 : 即将单向链表的尾节点next指针指向头节点而不再指向`空`，在环型链表中任意节点都可以视作头节点。

graph LR subgraph 1 B[1] B`[next] end 1-->2 subgraph 2 C[2] C`[next] end 2-->3 subgraph 3 D[3] D`[next] end 3-->4 subgraph 4 E[4] E`[next] end 4 -->1

哈希表基础总结

Sat, 10 Aug 2024 00:00:00 +0000

哈希表

哈希表(hash table)又称作散列表,它是基于键值对(key-value pair)存储和访问数据的一种非线性数据结构。

哈希表通过哈希函数将键(key)映射到特定位置来实现对数据的快速存取与访问。

哈希表虽然只要知道键通过哈希函数就可以找到值，但是在哈希表内通常同时存储着键和值。其主要原因是当出现哈希冲突(hash collision)时需要通过键来确定多个值具体属于哪个键。

可以用函数对应关系理解 $f(key) = address$, $array[address] = value$。

访问查询	$O(1)$
添加元素	$O(1)$
删除元素	$O(1)$

哈希表的实现

STL中哈希表的使用

在cpp中哈希表通常是用unordered_map实现

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;
int main(){
	//初始化
	unordered_map<string, int> hashmap;
	unordered_map<string, int> hashtable =
	{
		{"num1", 1},
		{"num2", 2},
		{"num3", 3}

	};
		
	//访问
	hashtable["num3"];
	hashtable["num3"] = 1;
	hashtable.at("num3");


	//插入
	hashmap.insert({"key", 123});
	hashmap.emplace("key2", 1234);//无条件更新
	hashmap.try_emplace("key2", 1234);//如果键存在则不会更新

	//删除
	hashmap.erase("key2");
	hashmap.erase(hashmap.begin());
	hashmap.clear(); //清空容器

	//查找
	auto it = hashtable.find("num1");
	if (it != hashtable.end()){ //存在则返回所在位置迭代器，否则返回尾后迭代器
		cout<<it->first<<" "<<it->second;
	}

	if(hashtable.count("num2") == 0){
		return false;
	}

	bool exists = hashmap.contains("num3");

	//其他操作
	auto isempty = hashmap.empty();
	hashmap.size();

	return 0;
}

基于数组的简单实现

此处只是简单实现，为方便计算hash值key规定为int型。

对于哈希表来说哈希函数可以是其核心所在，因此哈希函数的设计尤为重要，常见的哈希函数有以下几种：

直接寻址法：取关键字或关键字的某个线性函数值为散列地址。即$hash(k)=k$或$hash(k)=a⋅k+b$，其中$a,b$为常数（这种散列函数叫做自身函数）

数字分析法：假设关键字是以r为基的数，并且哈希表中可能出现的关键字都是事先知道的，则可取关键字的若干数位组成哈希地址。

平方取中法：取关键字平方后的中间几位为哈希地址。通常在选定哈希函数时不一定能知道关键字的全部情况，取其中的哪几位也不一定合适，而一个数平方后的中间几位数和数的每一位都相关，由此使随机分布的关键字得到的哈希地址也是随机的。取的位数由表长决定。

折叠法：将关键字分割成位数相同的几部分（最后一部分的位数可以不同），然后取这几部分的叠加和（舍去进位）作为哈希地址。

随机数法

除留余数法：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即$hash(k)=k\ mod\ p$, $ p≤m$。不仅可以对关键字直接取模，也可在折叠法、平方取中法等运算之后取模。对p的选择很重要，一般取素数或m，若p选择不好，容易产生冲突。

struct Pair{	
	public:
		string value;
		int key;
		Pair(int key, string val) {
			this->key = key;
			this->value = val;
		}
};

class hashtable{
	private:
		vector<Pair*> buckets;
	public:
		hashtable(){
			buckets = vector<Pair*>(100);//申请大小为100的空间
		}
		~hashtable(){
			for(const auto& bucket:buckets){
				delete bucket;
			}
			buckets.clear();
		}
    
    
		int hashFunction(int key){
            //哈希函数
			int index = key % buckets.size(); //对key取模后作为下标索引便于访问键值对
			return index;
		}
		void insert(int key, string val){
			int index = hashFunction(key);
			Pair* pair = new Pair(key, val);
			buckets[index] = pair;
		}
		
		string search(int key){
			int index = hashFunction(key);
            //如果不为空，且key值相等返回value
			if (buckets[index] != nullptr && buckets[index]->key == key) {
				return buckets[index]->value;
			}
			return "";
		}
    	
		void remove(int key){
			int index = hashFunction(key);
			delete buckets[index];
			buckets[index] = nullptr;
		}
    
		void print(){
			for(const auto& bucket:buckets){
				if(bucket != nullptr){
					cout<<bucket->key<<" "<<bucket->value<<endl;
				}
			}
		}
};

可能你会有疑问，如果我输入的是相同的key值，那哈希函数计算出的index岂不是相同了吗？

又或者我存入的数据很多超过了预先申请的桶大小该怎么办，如果它能够自动扩容，那么因为容器大小发生了变化哈希函数的计算方式又会变化，这可能又会引发冲突。

哈希冲突

哈希冲突(hash collision)发生的原因是因为我们输入的内容要远远大于输出的内容，我们有无限的输入通过哈希函数转换成一个固定长度的索引，因此发生哈希冲突是不可避免的。

从图中我们可以猜想，如果桶的数量越大那么发生冲突的概率越低，于是我们可以通过扩容来降低哈希冲突的概率。

于是我们引入了负荷因子(load factor)用它来衡量哈希表的冲突程度。 $$ (负荷因子)α = 哈希表元素数 / 桶容量 $$ 一般选择$α$为0.7~0.8作为触发扩容的条件。

哈希冲突的常见几种解决方法为开放地址法、链式探测法和多次哈希法。