面试题----二叉树的各种遍历

#include<iostream>
#include<stack>
#include<queue>
#include<string>
#include<deque>
using namespace std;

struct Node
{
	int data;
	Node* left;
	Node* right;
	Node(){ data = 0; left = nullptr; right = nullptr; }
	Node(int a){
		data = a;
		left = nullptr;
		right = nullptr;
	}
};

void preOrder(Node* p)
{
	if (p == nullptr)return;
	stack<Node*>st;
	while (p || !st.empty())
	{
		while (p)
		{
			cout << p->data << " ";
			st.push(p);
			p = p->left;
		}

		if (!st.empty())
		{
			Node* temp = st.top();
			st.pop();
			p = temp->right;
		}
	}
}

void inOrder(Node* p)
{
	if (p == nullptr)return;
	stack<Node*>st;
	while (p || !st.empty())
	{
		while (p)
		{
			st.push(p);
			p = p->left;
		}

		if (!st.empty())
		{
			Node* p = st.top();
			st.pop();
			cout << p->data << " ";
			p = p->right;
		}
	}
}

void postOrder1(Node* p)
{
	if (p == nullptr)return;
	stack<Node*>st;
	Node* plast = nullptr;
	while (p)
	{
		st.push(p);
		p = p -> left;
	}

	while (p || !st.empty())
	{
		p = st.top();
		st.pop();
		if (p->right == nullptr || p->right == plast)
		{
			cout << p->data << " ";
			plast = p;
		}
		else
		{
			st.push(p);
            p = p->right;
            while (p)
            {
	           st.push(p);
	           p = p->left;
            }
		}

	}
}

void postOrder2(Node* p)
{
	if (p == nullptr)return;
	stack<Node*>st1, st2;
	st1.push(p);
	while (!st1.empty())
	{
		Node* temp = st1.top();
		st2.push(temp);
		if (temp->left != nullptr)
		{
			st1.push(temp->left);
		}
		if (temp->right != nullptr)
		{
			st1.push(temp->right);
		}
	}

	while (!st2.empty())
	{
		cout << st2.top()->data << " ";
		st2.pop();
	}
}

void levelOrder(Node* p)
{
	if (p == nullptr)return;
	queue<Node*>qu;
	qu.push(p);
	while (!qu.empty())
	{
		p = qu.front();
		cout << p->data << " ";
		qu.pop();
		if (p->left != nullptr)
		{
			qu.push(p->left);
		}
		if (p->right != nullptr)
		{
			qu.push(p->right);
		}
	}
}

int widthOfTree(Node* p)
{
	int max = INT_MIN;
	deque<Node*>de1, de2;
	de1.push_back(p);
	do
	{
		///下面的if改成count++即为非递归求树的深度
		if (de1.size() > max)
		{
			max = de1.size();
		}
		do
		{
			p = de1.front();
			de1.pop_front();
			if (p->left != nullptr)
			{
				de2.push_back(p->left);
			}
			if (p->right != nullptr)
			{
				de2.push_back(p->right);
			}
		} while (!de1.empty());
		de1.swap(de2);
	} while (!de1.empty());

	return max;
}

Node* findNode(Node* root, int val)
{
	///对数进行后续遍历，当访问节点时判断节点是否值为val，如为val return node
	return nullptr;
}

打印所有叶子节点到根节点的路径也是用的后续遍历，当访问的叶子节点时，栈中存在的值即为该叶子节点的路径
///以及打印两个叶子节点的路径，即先找出两个叶子节点到根的路径，再找出最初的公共的节点即可
///二叉树的最大距离，采用递归，参考网址：

int main()
{

}

　　

转载于:https://www.cnblogs.com/jinweiseu/p/5372944.html