孩子兄弟法建立树（暂时未完成）

最新推荐文章于 2025-06-18 17:23:19 发布

原创最新推荐文章于 2025-06-18 17:23:19 发布 · 275 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一种通用树形结构的实现方法，并详细展示了如何使用队列、双端队列和栈等数据结构来完成树的先序、后序及层序遍历。通过示例代码，读者可以了解到树节点的创建、初始化过程，以及如何进行不同类型的遍历。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

遍历的树的结构示意：

运行截图：

#include <iostream>
#include <queue>
#include <deque>
#include <stack>
#include <sstream>
using namespace std;
template<class T>
struct TreeNode
{
	T data;
	TreeNode<T>* Brother;
	TreeNode<T>* Son;
	TreeNode(T data)
	{
		this->data = data;
		Brother = NULL;
		Son = NULL;
	}
};
template<class T>
void Clear(TreeNode<T>* root)
{
	if (root != NULL)
	{
		Clear(root->Brother);
		Clear(root->Son);
		delete root;
	}
}
template<class T>
class Tree
{
private:
	TreeNode<T>* Root;
	TreeNode<T>* fid(TreeNode<T>* root, T data)
	{
		if (root != NULL)
		{
			if (root->data == data)
			{
				return root;
			}
			TreeNode<T>* tmp = fid(root->Brother, data);
			if (tmp != NULL) return tmp;
			tmp = fid(root->Son, data);
			if (tmp != NULL) return tmp;
			return NULL;
		}
		else return NULL;
	}
public:
	Tree()
	{
		Root = NULL;
	}
	bool isEmpty()
	{
		return Root == NULL;
	}
	///插入函数
	void Insert(T parent)
	{
		if (isEmpty())
		{
			cout << "树为空，请先初始化！\n";
			return;
		}
	}
	///初始化函数
	void Init()
	{
		cout << "请输入根节点的数据:\n";
		T tmp;
		cin >> tmp;
		if (Root != NULL) Clear(Root);
		Root = new TreeNode<T>(tmp);
		TreeNode<T>* tmpNode;
		string MyString;
		queue<TreeNode<T>*> MyQueue;
		MyQueue.push(Root);
		while (!MyQueue.empty())
		{
			tmpNode = MyQueue.front();
			int ct = 0;
			MyQueue.pop();
			tmp = tmpNode->data;
			cout << "请按长幼顺序请输入节点" << tmp << "的子节点，以#结尾：\n";
			while (cin >> MyString)
			{
				if (MyString == "#")
				{
					break;
				}
				if(!ct)
				{
                    stringstream ss;
                    ss << MyString;
                    ss >> tmp;
					ct++;
					tmpNode->Son = new TreeNode<T>(tmp);
					MyQueue.push(tmpNode->Son);
					tmpNode = tmpNode->Son;
					continue;
				}
				stringstream ss;
				ss << MyString;
				ss >> tmp;
				if (tmpNode == Root)
				{
					tmpNode->Son = new TreeNode<T>(tmp);
					MyQueue.push(tmpNode->Son);
					tmpNode = tmpNode->Son;
				}
				else
				{
					tmpNode->Brother = new TreeNode<T>(tmp);
					MyQueue.push(tmpNode->Brother);
					tmpNode = tmpNode->Brother;
				}
			}

		}
	}
	///先序遍历函数
	void Pre_order()
	{
		if (Root == NULL)
		{
			cout << "根节点为空！\n";
			return;
		}
		deque<TreeNode<T>*> MyDeque;
		TreeNode<T>* tmpNode;
		TreeNode<T>* son;
		MyDeque.push_back(Root);
		while (!MyDeque.empty())
		{
			tmpNode = MyDeque.front();
			son = tmpNode->Son;
			MyDeque.pop_front();
			cout << tmpNode->data << ' ';
			stack<TreeNode<T>*> MyStack;
			while (tmpNode->Brother != NULL)
			{
				MyStack.push(tmpNode->Brother);
				tmpNode = tmpNode->Brother;
			}
			while (!MyStack.empty())
			{
				MyDeque.push_front(MyStack.top());
				MyStack.pop();
			}
			if (son != NULL)
			{
				MyDeque.push_front(son);
			}
		}
		cout << endl;
	}
	///后续遍历函数
	void Bcak_order()
	{
	    if (Root == NULL)
		{
			cout << "根节点为空！\n";
			return;
		}
		deque<TreeNode<T>*> MyDeque;
		stack<T> MyStack;
		TreeNode<T>* tmpNode;
		TreeNode<T>* son;
		MyDeque.push_back(Root);
		while(MyDeque.size()!=0)
        {
            tmpNode=MyDeque.front();
            MyDeque.pop_front();
            MyStack.push(tmpNode->data);
            tmpNode=tmpNode->Son;
            while(tmpNode!=NULL)
            {
                MyDeque.push_front(tmpNode);
                tmpNode=tmpNode->Brother;
            }
        }
        while(MyStack.size()!=0)
        {
            cout<<MyStack.top()<<" ";
            MyStack.pop();
        }
        cout<<endl;
	}
	///层序遍历函数
	void Mid_order()
	{
	    if (Root == NULL)
		{
			cout << "根节点为空！\n";
			return;
		}
	    queue<TreeNode<T>*> Parents;
	    queue<TreeNode<T>*> Children;
	    queue<T> MyQueue;
	    Parents.push(Root);
	    while(!Parents.empty())
        {
            while(!Parents.empty())
            {
                TreeNode<T>* nowNode=Parents.front();
                MyQueue.push(nowNode->data);
                nowNode=nowNode->Son;
                Parents.pop();
                while(nowNode!=NULL)
                {
                    Children.push(nowNode);
                    nowNode=nowNode->Brother;
                }
            }
            Parents=Children;
            while(!Children.empty())
            {
                Children.pop();
            }
        }
        while(!MyQueue.empty())
        {
            cout<<MyQueue.front()<<" ";
            MyQueue.pop();
        }
        cout<<endl;
	}
};
int main()
{
	Tree<char>* myTree = new Tree<char>();
	myTree->Init();
	cout<<"先序遍历如下：\n";
	myTree->Pre_order();
	cout<<"后序遍历如下：\n";
	myTree->Bcak_order();
	cout<<"层序遍历如下：\n";
	myTree->Mid_order();
	return 0;
}