代码随想录算法训练营day13

最新推荐文章于 2024-10-09 22:28:58 发布
最新推荐文章于 2024-10-09 22:28:58 发布
阅读量189 收藏
点赞数 3
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56445436/article/details/141141340
版权

1.二叉树的递归遍历和迭代遍历

1.1 题目

. - 力扣（LeetCode）

. - 力扣（LeetCode）

. - 力扣（LeetCode）

1.2 题解一（递归遍历）

/**
 * 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) {}
 * };
 */
class Solution {
public:
    void preTraversal(TreeNode* root, vector<int>& vec)
    {
        if (root == nullptr)return;
        //中
        vec.push_back(root->val);
        //左
        preTraversal(root->left,vec);
        //右
        preTraversal(root->right,vec);
    }
    vector<int> preorderTraversal(TreeNode* root) 
    {
        vector<int> vec;
        preTraversal(root,vec);
        return vec;

    }
};
/**
 * 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) {}
 * };
 */
class Solution {
public:
    void preTraversal(TreeNode* root, vector<int>& vec)
    {
        if (root == nullptr)return;
        
        //左
        preTraversal(root->left,vec);
        //右
        preTraversal(root->right,vec);
        //中
        vec.push_back(root->val);
    }
    vector<int> postorderTraversal(TreeNode* root) 
    {
        vector<int> vec;
        preTraversal(root,vec);
        return vec;

    }
};
/**
 * 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) {}
 * };
 */
class Solution {
public:
    void preTraversal(TreeNode* root, vector<int>& vec)
    {
        if (root == nullptr)return;
        
        //左
        preTraversal(root->left,vec);
        //中
        vec.push_back(root->val);
        //右
        preTraversal(root->right,vec);
        
    }
    vector<int> inorderTraversal(TreeNode* root) 
    {
        vector<int> vec;
        preTraversal(root,vec);
        return vec;

    }
};

1.3 题解二（迭代遍历）

/**
 * 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) {}
 * };
 */
class Solution {
public:

	vector<int> preorderTraversal(TreeNode* root)
	{
		vector<int> vec;
		stack<TreeNode*> sta;
		if (root == nullptr)return vec;
		sta.push(root);
		while (!sta.empty())
		{
			//中
			TreeNode* tmp = sta.top();
			sta.pop();
			vec.push_back(tmp->val);

			//空节点不入栈
			//先放右节点，因为从栈弹出来是先进后出
			if (tmp->right) sta.push(tmp->right);
			//再放左节点
			if (tmp->left)sta.push(tmp->left);

		}
        return vec;
	}
};
/**
 * 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) {}
 * };
 */
class Solution 
{
public:
    vector<int> postorderTraversal(TreeNode* root)
    {
        vector<int> result;
        stack<TreeNode*> st;

        if (root == nullptr)return result;
        st.push(root);
        while (!st.empty())
        {
            //中
            TreeNode* rootValue = st.top();
            st.pop();
            result.push_back(rootValue->val);
            
            //左
            if (rootValue->left != nullptr)st.push(rootValue->left);

            //右
            if (rootValue->right != nullptr)st.push(rootValue->right);
            
        }
        reverse(result.begin(), result.end());
        return result;
    }
};
/**
 * 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) {}
 * };
 */
 class Solution 
 {
 public:
     vector<int> inorderTraversal(TreeNode* root)
     {
         vector<int> result;
         //每次遍历的节点都要入栈
         stack<TreeNode*> st;
         TreeNode* cur = root;
         while (cur!=nullptr||!st.empty())
         {
             if (cur != nullptr)
             {
                 st.push(cur);
                 cur = cur->left;
             }
             else
             {
                 cur = st.top();
                 st.pop();
                 result.push_back(cur->val);
                 cur = cur->right;
             }

         }
         return result;
     }
 };

2.二叉树的层序遍历

2.1 题目

. - 力扣（LeetCode）

. - 力扣（LeetCode）

. - 力扣（LeetCode）

. - 力扣（LeetCode）

. - 力扣（LeetCode）

. - 力扣（LeetCode）

. - 力扣（LeetCode）

. - 力扣（LeetCode）

. - 力扣（LeetCode）

. - 力扣（LeetCode）

2.1 题解

/**
 * 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) {}
 * };
 */
 class Solution {
 public:
     vector<vector<int>> levelOrder(TreeNode* root) 
     {
         vector<vector<int>> result;
         queue<TreeNode*> q;
         if (root!=nullptr)q.push(root);
         while (!q.empty())
         {
             vector<int> vec;
             int size = q.size();
             while (size--)
             {
                 TreeNode* tmp = q.front();
                 q.pop();
                 vec.push_back(tmp->val);
                 if (tmp->left)q.push(tmp->left);
                 if (tmp->right)q.push(tmp->right);
             }
             result.push_back(vec);
             
         }
         return result;
     }
 };
/**
 * 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) {}
 * };
 */
class Solution
{
public:
	vector<vector<int>> levelOrderBottom(TreeNode* root)
	{
		vector<vector<int>> result;
		queue<TreeNode*> q;
		if (root != nullptr)q.push(root);
		while (!q.empty())
		{
			vector<int> vec;
			int size = q.size();
			while (size--)
			{
				auto tmp = q.front();
				q.pop();
				vec.push_back(tmp->val);
				if (tmp->left != nullptr)q.push(tmp->left);
				if (tmp->right != nullptr)q.push(tmp->right);
			}
			result.push_back(vec);
		}
		reverse(result.begin(), result.end());
		return result;
	}
};
class Solution 
{
public:
	vector<int> rightSideView(TreeNode* root) 
	{
		vector<int> result;
		queue<TreeNode*> q;
		if (root != nullptr)q.push(root);
		while (!q.empty())
		{
			int size = q.size();
			for (int i = 0; i < size; i++)
			{
				auto tmp = q.front();
				q.pop();
				if (i == (size - 1))result.push_back(tmp->val);
				if (tmp->left != nullptr)q.push(tmp->left);
				if (tmp->right != nullptr)q.push(tmp->right);
			}
		}
		return result;
	}
};
/**
 * 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) {}
 * };
 */
class Solution 
{
public:
	vector<double> averageOfLevels(TreeNode* root) 
	{
		vector <double> result;
		queue<TreeNode*> q;
		if (root != nullptr)q.push(root);
		while (!q.empty())
		{
			long sum = 0;
			int size = q.size();
			int n = size;
			
			while (size--)
			{
				auto tmp = q.front();
				q.pop();
				sum += (tmp->val);
				if (tmp->left != nullptr)q.push(tmp->left);
				if (tmp->right != nullptr)q.push(tmp->right);
			}
			result.push_back(sum*1.0 / n);
		}
		return result;
	}
};
/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution 
{
public:
	vector<vector<int>> levelOrder(Node* root) 
	{
		vector<vector<int>> result;
		queue<Node*> q;
		if (root != nullptr)q.push(root);
		while (!q.empty())
		{
			int size = q.size();
			vector<int> vec;
			while (size--)
			{
				auto tmp = q.front();
				q.pop();
				vec.push_back(tmp->val);
				for (auto i : tmp->children)
				{
					if (i != nullptr)
					{
						q.push(i);
					}
				}
			}
			result.push_back(vec);
			
		}
		return result;
	}
};
/**
 * 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) {}
 * };
 */
class Solution 
{
public:
	vector<int> largestValues(TreeNode* root) 
	{
		vector<int> result;
		queue<TreeNode*> q;
		if (root != nullptr)q.push(root);
		while (!q.empty())
		{
			int size = q.size();
			int min_num = INT32_MIN;
			while (size--)
			{
				auto tmp = q.front();
				q.pop();
				min_num = tmp->val > min_num ? tmp->val : min_num;
				if (tmp->left != nullptr)q.push(tmp->left);
				if (tmp->right != nullptr)q.push(tmp->right);
			}
			result.push_back(min_num);
		}
		return result;
	}
};
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
	Node* connect(Node* root) 
	{
		
		queue <Node*> q;
		if (root != nullptr)q.push(root);
		Node* pre;
		while (!q.empty())
		{
			int size = q.size();
			//表示前一个节点
			Node* headNodePerlevel;
			//表示当前节点
			Node* node;
			for (int i = 0; i < size; i++)
			{
				//每一层的第一个节点
				if (i == 0)
				{
					headNodePerlevel = q.front();
					q.pop();
					node = headNodePerlevel;
				}
				//当前层的别的节点
				else
				{
					node = q.front();
					q.pop();
					headNodePerlevel->next = node;
					headNodePerlevel = node;
				}
				if (node->left != nullptr)q.push(node->left);
				if (node->right != nullptr)q.push(node->right);
			}
			//遍历完这一层，最后的节点指向Null
			node->next = nullptr;

		}
		return root;
	}
};
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
	Node* connect(Node* root) 
	{
		queue<Node*> q;
		if (root != nullptr)q.push(root);
		while (!q.empty())
		{
			int size = q.size();
			Node* preNode;
			Node* nownode;
			for (int i = 0; i < size; i++)
			{
				if (i == 0) 
				{
					preNode = q.front();
					q.pop();
					nownode = preNode;
				}
				else
				{
					nownode = q.front();
					q.pop();
					preNode->next = nownode;
					preNode = nownode;
				}
				if (nownode->left != nullptr)q.push(nownode->left);
				if (nownode->right != nullptr)q.push(nownode->right);
			}
			nownode->next = nullptr;
		}
		return root;
	}
};
class Solution {
public:
	int maxDepth(TreeNode* root) 
	{
		if (root == nullptr)return 0;
		queue<TreeNode*> q;
		q.push(root);
		int count = 0;
		while (!q.empty())
		{
			int size = q.size();
			while (size--)
			{
				auto tmp = q.front();
				q.pop();
				if (tmp->left!= nullptr)q.push(tmp->left);
				if (tmp->right!= nullptr)q.push(tmp->right);
			}
			count++;
		}
		return count;
	}
};
/**
 * 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) {}
 * };
 */
class Solution {
public:
	int minDepth(TreeNode* root) 
	{
		if (root == nullptr)return 0;
		queue<TreeNode*> q;
		q.push(root);
		int count = 0;
		while (!q.empty())
		{
			int size = q.size();
			count++;
			while (size--)
			{
				auto tmp = q.front();
				q.pop();
				if (tmp->left != nullptr)
				{
					q.push(tmp->left);
				}
				if (tmp->right != nullptr)
				{
					q.push(tmp->right);
				}
				if (!tmp->left && !tmp->right)
				{
					return count;
				}
			}

		}
		return count;
	}
};
半勺鸡腿堡
关注
代码随想录算法训练营day4
weixin_44520607的博客
11-23 573
代码随想录算法训练营day4
代码随想录算法训练营Day8
weixin_44520607的博客
12-02 600
代码随想录算法训练营Day8
代码随想录算法训练营Day13
lynyzy的博客
09-27 568
DFS、BFS遍历二叉树应用
代码随想录算法训练营 Day13
Icewolf273的博客
07-29 258
迭代遍历。
代码随想录算法训练营day13|二叉树01
gyuhyhui的博客
08-01 1644
刚刚我们说过了二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存，这个定义没啥可说的，我们来看看链式存储的二叉树节点的定义方式。C++int val;二叉树的定义和链表是差不多的，相对于链表 ，二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。int val;
代码随想录算法训练营day2
zhoujun的博客
12-29 424
leetCode刷题日记
代码随想录算法训练营Day13||二叉树
jiegongzhu3z的博客
07-15 1403
while的条件控制为队列不为空，也就是说，所有节点都访问完了，才回出现队列为空的情况，正是我想要的条件。3.二叉搜索树：特征是，所有左子树（包括左节点）小于根节点，所有右子树（包括右节点）大于根节点。维护就是说保护一个数据结构，让它本身的性质不发生变化，以单调队列为例子，维护单调队列就是让pop的时候只删去当前的队首（最大值），push之前把队内已有元素中小于即将加入的元素先去掉，然后再加入。2.完全二叉树：特征是除了最底层可以不满，其他层都是满节点，并且在底层的节点必须是连续的。
代码随想录算法训练营Day1
lynyzy的博客
09-11 593
双指针
代码随想录算法训练营day13|二叉树part1
weixin_45831563的博客
07-16 260
【代码】代码随想录算法训练营day13|二叉树part1。
代码随想录算法训练营Day13 | 递归遍历、迭代遍历、层序遍历
jiabao0520的博客
09-24 1000
训练营第13天：144.二叉树的前序遍历、94.二叉树的中序遍历、145.二叉树的后序遍历、102.二叉树的层序遍历、107.二叉树的层序遍历Ⅱ、199.二叉树的右视图、637.二叉树的层平均值、429.N叉树的层序遍历、515. 在每个树行中找最大值、116. 填充每个节点的下一个右侧节点指针、117. 填充每个节点的下一个右侧节点指针 Ⅱ、104.二叉树的最大深度、111.二叉树的最小深度。
代码随想录算法训练营day1
weixin_44520607的博客
11-16 1360
代码随想录 算法训练营第一天
代码随想录算法训练营day3
weixin_44520607的博客
11-22 372
代码随想录算法训练营day3
图论day56|广度优先搜索理论基础 、bfs与dfs的对比（思维导图）、 99.岛屿数量（卡码网）、100.岛屿的最大面积（卡码网）
2402_84438596的博客
10-09 712
图论day56|广度优先搜索理论基础 、bfs与dfs的对比（思维导图）、 99.岛屿数量（卡码网）、100.岛屿的最大面积（卡码网）
[算法] 数组
最新发布
Letmooning的博客
10-09 294
- 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 584
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 385
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 944
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值