C++二叉树基本问题

最新推荐文章于 2024-07-14 11:23:58 发布
最新推荐文章于 2024-07-14 11:23:58 发布
阅读量1.5k 收藏 3
点赞数 9
文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53351797/article/details/125248917
版权

1.非梯归遍历

先序遍历

class Node {
public:
	int value;
	Node* left;
	Node* right;

	Node(int data) {
		this->value = data;
		left = right = NULL;
	}
};
	void preOrderUnRecur(Node* head)
	{
		if (head == NULL)
		{
			return;
		}
		cout << "saa" << endl;
		stack<Node* >* s = new stack<Node* >;
		s->push(head);
		while (!s->empty())
		{
			head = (s->top());
			cout << head->value << "  " << endl;
			s->pop();
			if (head->right != NULL)
			{
				s->push(head->right);
			}
			if (head->left != NULL)
			{
				s->push(head->left);
			}

	
		}
		delete s;
	}

中序遍历

	void inOrderUnRecur(Node* head)
	{
		if (head == NULL)
		{
			return;
		}
		stack<Node* >* s = new stack<Node* >;

		while (!s->empty()|| head!=NULL)
		{
			
			if (head != NULL)
			{
				s->push(head);
				head = head->left;
			}
			else
			{
				head = (s->top());
				cout << head->value << "  " << endl;
				s->pop();
				head = head->right;
						
			}
		}
		delete s;
	}

后序遍历

	void posOrderUnRecur(Node* head)
	{
		if (head == NULL)
		{
			return;
		}
		stack<Node*>s1;
		stack<Node*>s2;
		s1.push(head);
		Node* cur = NULL;
		while (!s1.empty())
		{
			cur = s1.top();
			s1.pop();
			s2.push(cur);
			if (cur->left != NULL)
			{
				s1.push(cur->left);
			}
			if (cur->right != NULL)
			{
				s1.push(cur->right);
			}
		}
		while (!s2.empty())
		{
			cout << s2.top()->value << endl;
			s2.pop();
		}

	}

二叉树的最大宽度

	int TreeMaxWidth(Node* head)
	{
		if (head == NULL)
		{
			return -1;
		}
		Node* left = NULL;
		Node* right = NULL;
		queue<Node* >q_tree;
		map<Node*, int>m_tree;
		m_tree.insert(make_pair(head,1));
		int level = 0;
		int count = 1;
		//vector<int>v;
		//v[0] = 1;
		int max_isn = INT_MIN;
		q_tree.push(head);
		while (!q_tree.empty())
		{
			head = q_tree.front();
			q_tree.pop();
			left = head->left;
			right = head->right;
			if (left != NULL)
			{
				m_tree.insert(make_pair(left,m_tree[head]+1));
				q_tree.push(left);
			}
			if(right!=NULL)
			{
				m_tree.insert(make_pair(right, m_tree[head] + 1));
				q_tree.push(right);

			}
			if (m_tree[head] > level)
			{

				level = m_tree[head];
			
				count = 1;
			}
			else
			{
				count++;
			//	v[level - 1] = count;
				
			}
			cout << "    count" << count;
			max_isn = max(count, max_isn);
		}
		cout << endl;
		return max_isn;
	}

二叉树是否搜索二叉树（左边的值大于右边值）

bool isBST(Node* head) 
	{
		if (head == NULL)
		{
			return true;
		}
		list<Node*>s;
		int m_value = INT_MIN;
		inprocess(head,&s);
		list<Node*>::iterator p1;
		for (p1 = s.begin();p1 != s.end();p1++)
		{
			if ((*p1)->value > m_value)
			{
				m_value = (*p1)->value;
			}
			else 
			{
				return false;
			}
		}
		return true;
	}
	void inprocess(Node* head, list<Node*> *s) 
	{
		if (head == NULL)
		{
			return;
		}
		inprocess(head->left,s);
		s->push_back(head);
		inprocess(head->right,s);
	}

二叉树是否为完全二叉树

	bool isCBT(Node* head)
	{
		if (head == NULL)
		{
			return true;
		}
		queue<Node*>q;
		q.push(head);

		Node* cur = NULL;
		Node* l = NULL;
		Node* r = NULL;
		bool leaf = false;
		while (!q.empty())
		{
			cur = q.front();
			l = cur->left;
			r=cur->right;
			q.pop();
			if ((l == NULL && r != NULL) || (leaf&&(r!=NULL||l!=NULL)) )
			{
				return false;
			}
			if (l != NULL)
			{
				q.push(l);
			}
			if (r != NULL)
			{
				q.push(r);
			}
			else
			{
				leaf = true;
			}
		}
		return true;
	}

二叉树是否为平衡二叉树

class ReturnType
{
public:
	int  height;
	bool isBalaned;
	ReturnType(int h,bool isB)
	{
		this->height = h;
		this->isBalaned = isB;
	}
};
class IsBalancedTree
{
public:
	
	bool IsBalan(Node* head)
	{
		if (head == NULL)
		{
			return true;
		}
		return process1(head).isBalaned;
	}
	ReturnType process1(Node *x)
	{
		if (x == NULL)
		{
			return ReturnType(0,true);
		}
		ReturnType l = process1(x->left);
		ReturnType r = process1(x->right);
		int height = max(l.height, r.height)+1;

		bool flag = (r.isBalaned) && (l.isBalaned) && abs(l.height - r.height)<2;
		return ReturnType(height,flag);
	}
};

最低共同祖先

class LowestCommonAncestor
{
public:

	Node* lca(Node* head, Node* node1, Node* node2) {
		if (head == NULL || head == node1 || head == node2) {
			return head;
		}

		Node* left = lca(head->left, node1, node2);
		Node* right = lca(head->right, node1, node2);
		if (left != NULL && right != NULL) {
			return head;
		}
		return left != NULL ? left : right;

	}
	Node* lowestAncestor(Node* head, Node* node1, Node* node2)
	{
		if (head == NULL || head == node1 || head == node2)
		{
			return NULL;
		}
		map<Node*, Node*>h_m;
		h_m.insert(make_pair(head,head));
		process(head,&h_m);
		set<Node*>set_n;
		Node* cur = node1;

		while (cur!= h_m[cur])
		{
			cout << "caing"<<endl;
			

			set_n.insert(cur);
			cur = h_m[cur];
		}
		set_n.insert(head);
		cur = node2;

		while (cur != h_m[cur])
		{
			
			if (set_n.count(cur)==1)
			{
				
				
					
					return cur;			
				
			}


			cur = h_m[cur];

		}




		return cur;
	

	}

	void process(Node *head, map<Node*, Node*>*m)
	{
		if (head==NULL)
		{
			return;
		}
		m->insert(make_pair(head->left, head));
		m->insert(make_pair(head->right, head));
		process(head->left,m);
		process(head->right, m);

		
		
	}
	
};

后继节点

class Node {
public:
	int value;
	Node* left;
	Node* right;
	Node* parent;

	Node(int data) {
		this->value = data;
		left = NULL;
		right = NULL;
	}
};
class Code08_SuccessorNode
{
public:
	Node* getSuccessorNode(Node* node)
	{
		if (node->right != NULL)
		{
			return rightChild(node->right);
		}
		else
		{
			Node* parent = node->parent;
			while (parent->left != node && parent != NULL)
			{
				node = parent;
				parent = node->parent;
			}
			return parent;
		}
	}
	Node* rightChild(Node* node)
	{
		if (node == NULL)
		{
			return NULL;
		}
		while (node->left != NULL)
		{
			node = node->left;

		}
		return node;
	}

};

序列化和反序列二叉树

class SerializeAndReconstructTree
{
public:
	void string_split(const string& str, const char split, queue<string>& res_string)
	{
		string strs = str;
		int pos = strs.find(split);
		while (pos != strs.npos)
		{
			string temp = strs.substr(0, pos);
			res_string.push(temp);
			strs = strs.substr(pos + 1, strs.size());
			pos = strs.find(split);
		}
	}
	void serialByPre(Node *head,string &origin)
	{
		if (head == NULL)
		{
			origin += "#!";
			return ;
		}
		origin += to_string(head->value);
		origin += "!";
		serialByPre(head->left,origin);

		serialByPre(head->right, origin);
		
	}
	Node* reconByPreString(queue<string>& res_string)
	{
		string str=res_string.front();
		res_string.pop();
		if (str._Equal( "#"))
		{
			return NULL;
		}

		int num = stoi(str.c_str());
		Node* head = new Node(num);
		head->left = reconByPreString(res_string);
		head->right = reconByPreString(res_string);
		return head;

	}
	string width_string(Node *head)
	{
		queue<Node*>q;
		q.push(head);
		Node* cur = head;
		string str;
		str = to_string(cur->value);
		
		str += "!";
		cout << "str:" << str << endl;
		while (!q.empty())
		{
			cur=q.front();

			q.pop();
			if (cur->left != NULL)
			{
				str += to_string(cur->left->value);
				str += "!";
				q.push(cur->left);
			}
			else
			{
				str += "#!";
			}
			if (cur->right != NULL)
			{
				str += to_string(cur->right->value);
				str += "!";
				q.push(cur->right);
			}
			else
			{
				str += "#!";
			}
					
		}
		return str;
	}
	Node* width_Node_dud(string str)
	{
		if (str == "#!")
		{
			return NULL;
		}
		queue<string>q;
		this->string_split(str,'!',q);
		string temp_str = q.front();
		q.pop();
		int num = stoi(temp_str.c_str());
		Node* head = new Node(num);
		queue<Node*>q_N;
		q_N.push(head);
		Node* cur = NULL;
		while (!q_N.empty()&&!q.empty())
		{
			cur = q_N.front();
			
			q_N.pop();



			temp_str= q.front();
			q.pop();
			if (temp_str._Equal("#"))
			{
				cur->left = NULL;
			}
			else
			{
				num = stoi(temp_str.c_str());
				cur->left = new Node(num);
				q_N.push(cur->left);
			}



			temp_str = q.front();
			q.pop();
			if (temp_str._Equal("#"))
			{
				cur->right = NULL;
			}
			else
			{
				num = stoi(temp_str.c_str());
				cur->right = new Node(num);
				q_N.push(cur->right);
			}
		}
		return head;
	}


};

折纸问题

class PaperFolding {
public:
	void printAllFolds(int n)
	{
		printProcess(1,n,true);

	}
	void printProcess(int i,int n,bool down)
	{
		if (i > n)
		{
			return;
		}
		printProcess(i+1,n,true);
		if (down)
		{
			cout << "down" << endl;
		}
		else cout << "up" << endl;
		printProcess(i + 1, n, false);
	}
};

温于
关注
  • 9
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C++二叉树的基本操作
wfanyue的博客
06-16 703
#include <iostream> using namespace std; class BinaryTree ; class BinTreeNode //结点类的定义 { friend BinaryTree; private: BinTreeNode *leftChild, *rightChil...
C++实现二叉树的基本操作
weixin_42031723的博客
04-29 525
1.定义类头文件 #pragma once #include<iostream> using namespace std; //定义树的节点 typedef struct BiNode { char data; BiNode* left; BiNode* right; BiNode(char val) { data = val; left = NULL; rig...
string find()函数、string::npos的含义、erase()函数
Mongo_girl
11-04 4445
  string::npos参数 —— npos 是一个常数，用来表示不存在的位置 例如，有两个字符串a、b，判断a字符串是否包含b字符串 //如果字符串不存在包含关系，那么返回值就一定是npos if(a.find(b)!=string::npos){ cout&lt;&lt;"yes"&lt;&lt;endl; }else{ cout&lt;&lt;"no"&lt;&lt;endl...
C++中string::npos的一些用法总结
automate123的博客
10-24 1621
转载自https://blog.csdn.net/guoqingshuang/article/details/80318476 一、关于npos的定义 在MSDN中有如下说明： basic_string::npos static const size_type npos = -1;//定义 The constant is the largest representable value of type size_type. It is assuredly larger than max_size(); hen
string的find函数返回值和string::npos
ShenHang_的博客
08-11 1916
先看一种很多人日常使用错误方式 string str(“hello world”); int pos=str.find_first_of(“h”); if(pos!=string::npos) // 或者 if(pos!=-1) {… …// 查找到了 } //不存在是find返回-1 这样的使用，结果是正常的，但并没有很好的理解string find函数的返回类型和string::npos真正的值。 string::find这类型的函数，返回值类型都是string::size_type, 而string
【题目】二叉树题目总结
m0_51064412的博客
11-27 1509
文章目录一. 前序遍历类二. 中序遍历类三. 后序遍历类四. 层序遍历类1. 二叉树的层序遍历五. 其他类型题目1. 二叉树的最近公共祖先 一. 前序遍历类 二. 中序遍历类 三. 后序遍历类 四. 层序遍历类 1. 二叉树的层序遍历 题目连接 题目描述： 给你一个二叉树，请你返回其按层序遍历得到的节点值。（即逐层地，从左到右访问所有节点）。 解题思路： 借助队列拿出每一层节点的同时按照从左到右的顺序存入下一层的所有节点，其核心代码下面这条，确保拿出当前层的节点： for(size_t i = q.s
string::find()函数和string::npos静态成员常量的使用
The_Dan的博客
04-07 464
string::find()函数 string::find()函数：是一个字符或字符串查找函数，该函数有唯一的返回类型，即string::size_type，即一个无符号整形类型，可能是整数也可能是长整数。如果查找成功，返回按照查找规则找到的第一个字符或者子串的位置；如果查找失败，返回string::npos,即-1（当然打印出的结果不是-1，而是一个很大的数值，那是因为它是无符号的）。 这里值得注意的是string::find()函数的返回值不是bool类型，所以无法通过find()函数的返回值直接判
C++二叉树结构的建立与基本操作
09-04
在C++中，二叉树是一种重要的数据结构，它由一系列结点组成，每个结点最多有两个子结点，通常称为左子结点和右子结点。二叉树的构建和基本操作...通过练习和理解这些基本操作，可以为解决更复杂的问题打下坚实的基础。
c++二叉树的基本操作
11-25
递归二叉树的基本操作，递归创建，递归先序遍历、中序遍历、后序遍历，求树的高度，求叶子结点的个数，交换树的左右孩子
C++二叉树基本操作
07-03
这个压缩包文件“C++二叉树基本操作”显然是一个关于使用C++实现二叉树操作的示例代码集，对于学习C++和数据结构的人来说极具价值。 二叉树是由节点（或称为元素）构成的数据结构，每个节点最多有两个子节点，通常...
C++实现二叉树基本操作详解
08-28
C++ 实现二叉树基本操作详解 二叉树是一种重要的非线性数据结构，广泛应用于计算机科学和信息技术领域。为了帮助读者更好地理解和掌握二叉树的基本操作，本文将详细介绍 C++ 语言实现二叉树基本操作的方法和技术。 ...
C++自实现二叉树的基本操作
11-03
本文将详细讲解如何使用C++语言实现二叉树的基本操作，包括创建、销毁、插入、删除、查找和遍历，以及反转等操作。 1. **创建算法**： 创建二叉树分为创建空树和非空树。空树的创建只需分配一个空节点，非空树的...
C++ string中的find() 函数
gentleman_97的博客
01-06 2万+
1、string中find()返回值是字母在母串中的位置（下标记录），如果没有找到，那么会返回一个特别的标记npos，也就是-1。（返回值可以看成是一个int型的数） 例子：找的情况 #include<iostream> #include<string> using namespace std; int main() { string str = "aabc"; int pos = str.find("abc"); if (pos != str.n
C++中string如何实现字符串分割函数split()——4种方法
热门推荐
m0_58086930的博客
01-31 8万+
C++分割字符串 四种方法
C++中string::npos的用法总结
ONE_KICK的博客
08-07 1万+
C++中string::npos的用法总结
string::npos 含义及用途
笨死的猪Blog
07-22 1948
字符串查找包含某个字符串时一般通过find()查找,找到返回所在位置,找不到则会返回string::npos 示例代码：  string  str;  if( str.find("a") != string::npos )  { cout  }  else { cout }
力扣224.基本计算器
最新发布
Pisasama的博客
07-14 206
【代码】力扣224.基本计算器。
c++ 二叉树基本操作
08-11
在二叉树中，有一些基本的操作可以帮助我们对二叉树进行各种操作。 首先是创建二叉树的操作。我们可以通过手动输入节点的值来创建一个二叉树。根据输入的值，我们可以根据特定规则将节点连接起来，形成一个完整的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值