2. 程式人生 > 其它 >[模板] 二叉樹 & 用先序遍歷和中序遍歷建樹 (藍橋杯練習系統 演算法訓練 繪製地圖)

[模板] 二叉樹 & 用先序遍歷和中序遍歷建樹 (藍橋杯練習系統 演算法訓練 繪製地圖)

阿新 • • 發佈：2021-03-09

[模板] 二叉樹

  該模板實現以下功能：

  前序遍歷，中序遍歷，後序遍歷，詢問節點深度

  關於樹的基礎知識參考深入學習二叉樹(一) 二叉樹基礎 - 簡書

//cpp
#include <vector>

using namespace std;

struct btree_node
{
	int depth;
	btree_node *father, *lson, *rson;
};

struct btree
{
	btree_node *btree_base;
	btree_node *root;
	btree(const int &size)
	{
		btree_base =
 
 new btree_node[size + 2]();
	}
	void setroot(const int &num)//設定樹的根節點
	{
		root = &btree_base[num];
		root->depth = 1;
	}
	bool setLeftSon(const int &this_num, const int &lson_num)
	{
		btree_node *this_node = &btree_base[this_num],
				   *lson_node = &btree_base[lson_num]
 
;
		if (this_node->lson == NULL)
		{
			this_node->lson = lson_node;
			lson_node->father = this_node;
			lson_node->depth = this_node->depth + 1;
			return true;
		}
		return false;
	}
	bool setRightSon(const int &this_num, const int &rson_num)
	{
		btree_node *this_node = &
 
btree_base[this_num],
				   *rson_node = &btree_base[rson_num];
		if (this_node->rson == NULL)
		{
			this_node->rson = rson_node;
			rson_node->father = this_node;
			rson_node->depth = this_node->depth + 1;
			return true;
		}
		return false;
	}
	bool setFather(const int &this_num, const int &father_num)
	{
		btree_node *this_node = &btree_base[this_num],
				   *father_node = &btree_base[father_num];
		if (this_node->father == NULL)
		{
			this_node->father = father_node;
			father_node->father = this_node;
			father_node->depth = this_node->depth - 1;
			return true;
		}
		return false;
	}
	int depth(const int &num){
		return btree_base[num].depth;
	}
	void __pre_order(vector<int> &v, btree_node *node)
	{
		if (node != NULL)
		{
			v.push_back(node - btree_base);
			__pre_order(v, node->lson);
			__pre_order(v, node->rson);
		}
	}
	vector<int> *preOrder()//求先序遍歷
	{
		vector<int> *v_preorder = new vector<int>();
		__pre_order(*v_preorder, root);
		return v_preorder;
	}
	void __in_order(vector<int> &v, btree_node *node)
	{
		if (node != NULL)
		{
			__in_order(v, node->lson);
			v.push_back(node - btree_base);
			__in_order(v, node->rson);
		}
	}
	vector<int> *inOrder()//求中序遍歷
	{
		vector<int> *v_inorder = new vector<int>();
		__in_order(*v_inorder, root);
		return v_inorder;
	}
	void __post_order(vector<int> &v, btree_node *node)
	{
		if (node != NULL)
		{
			__post_order(v, node->lson);
			__post_order(v, node->rson);
			v.push_back(node - btree_base);
		}
	}
	vector<int> *postOrder()//求後序遍歷
	{
		vector<int> *v_postorder = new vector<int>();
		__post_order(*v_postorder, root);
		return v_postorder;
	}
};

//java
import java.util.*;

class btree_node {
	public int depth, num;
	public btree_node father, lson, rson;
};

class btree {
	btree_node[] btree_base;
	btree_node root;

	public btree(final int size) {
		btree_base = new btree_node[size + 2];
		for (int i = 1; i <= size; i++) {
			btree_base[i] = new btree_node();
			btree_base[i].num = i;
		}
	}

	public void setroot(final int num)// 設定樹的根節點
	{
		root = btree_base[num];
		root.depth = 1;
	}

	public boolean setLeftSon(final int this_num, final int lson_num) {
		btree_node this_node = btree_base[this_num], lson_node = btree_base[lson_num];
		if (this_node.lson == null) {
			this_node.lson = lson_node;
			lson_node.father = this_node;
			lson_node.depth = this_node.depth + 1;
			return true;
		}
		return false;
	}

	public boolean setRightSon(final int this_num, final int rson_num) {
		btree_node this_node = btree_base[this_num], rson_node = btree_base[rson_num];
		if (this_node.rson == null) {
			this_node.rson = rson_node;
			rson_node.father = this_node;
			rson_node.depth = this_node.depth + 1;
			return true;
		}
		return false;
	}

	public boolean setFather(final int this_num, final int father_num) {
		btree_node this_node = btree_base[this_num], father_node = btree_base[father_num];
		if (this_node.father == null) {
			this_node.father = father_node;
			father_node.father = this_node;
			father_node.depth = this_node.depth - 1;
			return true;
		}
		return false;
	}

	public int depth(final int num) {
		return btree_base[num].depth;
	}

	void __pre_order(Vector v, btree_node node) {
		if (node != null) {
			v.add(node.num);
			__pre_order(v, node.lson);
			__pre_order(v, node.rson);
		}
	}

	public Vector preOrder()// 求先序遍歷
	{
		Vector v_preorder = new Vector();
		__pre_order(v_preorder, root);
		return v_preorder;
	}

	void __in_order(Vector v, btree_node node) {
		if (node != null) {
			__in_order(v, node.lson);
			v.add(node.num);
			__in_order(v, node.rson);
		}
	}

	public Vector inOrder()// 求中序遍歷
	{
		Vector v_inorder = new Vector();
		__in_order(v_inorder, root);
		return v_inorder;
	}

	void __post_order(Vector v, btree_node node) {
		if (node != null) {
			__post_order(v, node.lson);
			__post_order(v, node.rson);
			v.add(node.num);
		}
	}

	public Vector postOrder()// 求後序遍歷
	{
		Vector v_postorder = new Vector();
		__post_order(v_postorder, root);
		return v_postorder;
	}
};

例題：繪製地圖

藍橋杯練習系統 試題 演算法訓練 繪製地圖

資源限制

時間限制：1.0s 記憶體限制：256.0MB

問題描述

  最近，WYF正準備參觀他的點卡工廠。WYF集團的經理氰垃圾需要幫助WYF設計參“觀”路線。現在，氰垃圾知道一下幾件事情：

  • WYF的點卡工廠構成一顆二叉樹。
  • 一共有n座工廠。
  • 他需要把這顆樹上的點以後序遍歷的方法列出來，才能繪製地圖。

  還好，最近他的屬下給了他先序遍歷和中序遍歷的資料。可是，氰垃圾最近還要幫㊎澤穻解決一些問題，沒時間。請你幫幫他，替他完成這項任務。由於氰垃圾的一些特殊的要求，WYF的參觀路線將會是這棵樹的後序遍歷。

輸入格式

  第一行一個整數n，表示一共又n座工廠。
  第二行n個整數，表示先序遍歷。
  第三行n個整數，表示中序遍歷。

輸出格式

  輸出共一行，包含n個整數，為後序遍歷。

樣例輸入樣例輸出
8
1 2 4 5 7 3 6 8
4 2 7 5 1 8 6 3		4 7 5 2 8 6 3 1

資料規模和約定

  0<n<100000,。保證先序遍歷和中序遍歷合法，且均為1～n。

思路

  本題難點在於需要使用前序遍歷和中序遍歷生成一個二叉樹。

參考：中序，先序生成樹演算法 - holoblog - ITeye部落格

演算法思想很簡單，在先序中的第一個節點一定是根節點，此節點在中序中的位置可以將中序分為左右兩棵子樹。如：

根為A,中序分為：HDIBJEK A LFMCNGO,這兩棵子樹在使用同樣的方法就生成一棵樹。

  即遞迴的思想：

  取前序序列的第一個值，即為這個樹的根節點，在中序序列中找到這個節點，它兩邊的序列即是兩個子樹序列。多次對子樹進行上述過程即可。

  對於中序序列的拆分即是取該元素兩邊的序列，這即是子樹的中序序列。

對於前序序列：拆分後左子樹的中序序列共有a個元素，右子樹的中序序列有b個元素，那麼從根節點+1至根節點向後的a個即為左子樹部分的前序序列，從根節點向後的a+1個至先序序列的末尾即為右子樹部分的前序序列。

  詳見生成二叉樹的程式碼：

//cpp
#include <cstdio>
int makeTree(btree tree,//根據前序序列，中序序列生成後序序列
			 const int *pre_begin, const int *pre_end, //前序序列範圍
			 const int *in_begin, const int *in_end)   //中序序列範圍
{
	if (pre_end < pre_begin || in_end < in_begin)
		return 0; //0表示無效節點
	int thisnode = *pre_begin;
	const int *index = find(in_begin, in_end, thisnode); //thisnode在中序序列中的地址
	//中序序列切分(左子樹)
	int leftson = makeTree(tree,
						   pre_begin + 1, pre_begin + (index - in_begin), //左子樹前序序列範圍
						   in_begin, index - 1);						  //左子樹中序序列範圍
	if (leftson)														  //0表示無效節點
		tree.setLeftSon(thisnode, leftson);
	//中序序列切分(右子樹)
	int rightson = makeTree(tree,
							pre_begin + (index - in_begin) + 1, pre_end, //左子樹前序序列範圍
							index + 1, in_end);							 //右子樹中序序列範圍
	if (rightson)														 //0表示無效節點
		tree.setRightSon(thisnode, rightson);
	return thisnode;
}

int main()
{
	int n, *preOrder, *inOrder;
	scanf("%d", &n);
	btree *tr = new btree(n);
	preOrder = new int[n](), inOrder = new int[n]();
	for (int it = 0; it < n; it++)
		scanf("%d", preOrder + it);
	for (int it = 0; it < n; it++)
		scanf("%d", inOrder + it);
	tr->setroot(*preOrder);
	makeTree(*tr, preOrder, preOrder + n - 1, inOrder, inOrder + n - 1);
	vector<int> *v = tr->postOrder();
	for (auto it : *v)
		printf("%d ", it);
	return 0;
}

  注意到第8行使用了STL中的find()函式，時間複雜度為O(n)，把時間浪費在了尋找中序遍歷的節點上了。

  我們來做一個優化：輸入時記錄中序遍歷的節點地址，在尋找中先序遍歷的節點位置時直接呼叫即可。

//cpp
int makeTree(btree tree,//根據前序序列，中序序列生成後序序列
			 const int *pre_begin, const int *pre_end, //前序序列範圍
			 const int *in_begin, const int *in_end,   //中序序列範圍
			 const int **fastinorder)/*inorder定址加速*/
{
	if (pre_end < pre_begin || in_end < in_begin)
		return 0; //0表示無效節點
	int thisnode = *pre_begin;
	//const int *index = find(in_begin, in_end, thisnode); //thisnode在中序序列中的地址
	const int *index = fastinorder[thisnode];/*inorder定址加速*/
	//中序序列切分(左子樹)
	int leftson = makeTree(tree,
						   pre_begin + 1, pre_begin + (index - in_begin), //左子樹前序序列範圍
						   in_begin, index - 1,						  //左子樹中序序列範圍
						   fastinorder);/*inorder定址加速*/
	if (leftson)														  //0表示無效節點
		tree.setLeftSon(thisnode, leftson);
	//中序序列切分(右子樹)
	int rightson = makeTree(tree,
							pre_begin + (index - in_begin) + 1, pre_end, //左子樹前序序列範圍
							index + 1, in_end,							 //右子樹中序序列範圍
							fastinorder);/*inorder定址加速*/
	if (rightson)														 //0表示無效節點
		tree.setRightSon(thisnode, rightson);
	return thisnode;
}

int main()
{
	int n, *preOrder, *inOrder;
	int **fastinorder;/*inorder定址加速*/
	scanf("%d", &n);
	btree *tr = new btree(n);
	preOrder = new int[n](), inOrder = new int[n]();
	fastinorder = new int*[n+2]();/*inorder定址加速*/
	for (int it = 0; it < n; it++)
		scanf("%d", preOrder + it);
	for (int it = 0; it < n; it++){
		scanf("%d", inOrder + it);
		fastinorder[*(inOrder + it)]=inOrder + it;/*inorder定址加速*/
	}
	tr->setroot(*preOrder);
	makeTree(*tr, preOrder, preOrder + n - 1, inOrder, inOrder + n - 1, (const int **)fastinorder);/*inorder定址加速*/
	vector<int> *v = tr->postOrder();
	for (auto it : *v)
		printf("%d ", it);
	return 0;
}

//java
import java.util.*;

public class Main {

	public static int makeTree(btree tree, // 根據前序序列，中序序列生成後序序列
			int[] preorder, final int pre_begin, final int pre_end, // 前序序列範圍
			int[] inorder, final int in_begin, final int in_end, // 中序序列範圍
			final int[] fastinorder)/* inorder定址加速 */
	{
		if (pre_end < pre_begin || in_end < in_begin)
			return 0; // 0表示無效節點
		int thisnode = preorder[pre_begin];
		final int index = fastinorder[thisnode];/* inorder定址加速 */
		// 中序序列切分(左子樹)
		int leftson = makeTree(tree, 
				preorder, pre_begin + 1, pre_begin + index - in_begin, // 左子樹前序序列範圍
				inorder, in_begin, index - 1, // 左子樹中序序列範圍
				fastinorder);/* inorder定址加速 */
		if (leftson != 0) // 0表示無效節點
			tree.setLeftSon(thisnode, leftson);
		// 中序序列切分(右子樹)
		int rightson = makeTree(tree, 
				preorder, pre_begin + index - in_begin + 1, pre_end, // 左子樹前序序列範圍
				inorder, index + 1, in_end, // 右子樹中序序列範圍
				fastinorder);/* inorder定址加速 */
		if (rightson != 0) // 0表示無效節點
			tree.setRightSon(thisnode, rightson);
		return thisnode;
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n, preOrder[], inOrder[];
		int fastinorder[];/* inorder定址加速 */
		n = sc.nextInt();
		btree tr = new btree(n);
		preOrder = new int[n];
		inOrder = new int[n];
		fastinorder = new int[n + 2];/* inorder定址加速 */
		for (int it = 0; it < n; it++)
			preOrder[it] = sc.nextInt();
		for (int it = 0; it < n; it++) {
			inOrder[it] = sc.nextInt();
			fastinorder[inOrder[it]] = it;/* inorder定址加速 */
		}
		tr.setroot(preOrder[0]);
		makeTree(tr, preOrder, 0, n - 1, inOrder, 0, n - 1, fastinorder);/* inorder定址加速 */
		Vector<Integer> v = tr.postOrder();
		for (Integer it : v)
			System.out.printf("%d ", it);
	}
}

完整程式碼

//cpp
#include <iostream>
#include <vector>
#include <algorithm> //find()

using namespace std;

struct btree_node
{
	int depth;
	btree_node *father, *lson, *rson;
};

struct btree
{
	btree_node *btree_base;
	btree_node *root;
	btree(const int &size)
	{
		btree_base = new btree_node[size + 2]();
	}
	void setroot(const int &num)//設定樹的根節點
	{
		root = &btree_base[num];
		root->depth = 1;
	}
	bool setLeftSon(const int &this_num, const int &lson_num)
	{
		btree_node *this_node = &btree_base[this_num],
				   *lson_node = &btree_base[lson_num];
		if (this_node->lson == NULL)
		{
			this_node->lson = lson_node;
			lson_node->father = this_node;
			lson_node->depth = this_node->depth + 1;
			return true;
		}
		return false;
	}
	bool setRightSon(const int &this_num, const int &rson_num)
	{
		btree_node *this_node = &btree_base[this_num],
				   *rson_node = &btree_base[rson_num];
		if (this_node->rson == NULL)
		{
			this_node->rson = rson_node;
			rson_node->father = this_node;
			rson_node->depth = this_node->depth + 1;
			return true;
		}
		return false;
	}
	bool setFather(const int &this_num, const int &father_num)
	{
		btree_node *this_node = &btree_base[this_num],
				   *father_node = &btree_base[father_num];
		if (this_node->father == NULL)
		{
			this_node->father = father_node;
			father_node->father = this_node;
			father_node->depth = this_node->depth - 1;
			return true;
		}
		return false;
	}
	int depth(const int &num){
		return btree_base[num].depth;
	}
	void __pre_order(vector<int> &v, btree_node *node)
	{
		if (node != NULL)
		{
			v.push_back(node - btree_base);
			__pre_order(v, node->lson);
			__pre_order(v, node->rson);
		}
	}
	vector<int> *preOrder()//求先序遍歷
	{
		vector<int> *v_preorder = new vector<int>();
		__pre_order(*v_preorder, root);
		return v_preorder;
	}
	void __in_order(vector<int> &v, btree_node *node)
	{
		if (node != NULL)
		{
			__in_order(v, node->lson);
			v.push_back(node - btree_base);
			__in_order(v, node->rson);
		}
	}
	vector<int> *inOrder()//求中序遍歷
	{
		vector<int> *v_inorder = new vector<int>();
		__in_order(*v_inorder, root);
		return v_inorder;
	}
	void __post_order(vector<int> &v, btree_node *node)
	{
		if (node != NULL)
		{
			__post_order(v, node->lson);
			__post_order(v, node->rson);
			v.push_back(node - btree_base);
		}
	}
	vector<int> *postOrder()//求後序遍歷
	{
		vector<int> *v_postorder = new vector<int>();
		__post_order(*v_postorder, root);
		return v_postorder;
	}
};

int makeTree(btree tree,//根據前序序列，中序序列生成後序序列
			 const int *pre_begin, const int *pre_end, //前序序列範圍
			 const int *in_begin, const int *in_end,   //中序序列範圍
			 const int **fastinorder)/*inorder定址加速*/
{
	if (pre_end < pre_begin || in_end < in_begin)
		return 0; //0表示無效節點
	int thisnode = *pre_begin;
	//const int *index = find(in_begin, in_end, thisnode); //thisnode在中序序列中的地址
	const int *index = fastinorder[thisnode];/*inorder定址加速*/
	//中序序列切分(左子樹)
	int leftson = makeTree(tree,
						   pre_begin + 1, pre_begin + (index - in_begin), //左子樹前序序列範圍
						   in_begin, index - 1,						  //左子樹中序序列範圍
						   fastinorder);/*inorder定址加速*/
	if (leftson)														  //0表示無效節點
		tree.setLeftSon(thisnode, leftson);
	//中序序列切分(右子樹)
	int rightson = makeTree(tree,
							pre_begin + (index - in_begin) + 1, pre_end, //左子樹前序序列範圍
							index + 1, in_end,							 //右子樹中序序列範圍
							fastinorder);/*inorder定址加速*/
	if (rightson)														 //0表示無效節點
		tree.setRightSon(thisnode, rightson);
	return thisnode;
}

int main()
{
	int n, *preOrder, *inOrder;
	int **fastinorder;/*inorder定址加速*/
	scanf("%d", &n);
	btree *tr = new btree(n);
	preOrder = new int[n](), inOrder = new int[n]();
	fastinorder = new int*[n+2]();/*inorder定址加速*/
	for (int it = 0; it < n; it++)
		scanf("%d", preOrder + it);
	for (int it = 0; it < n; it++){
		scanf("%d", inOrder + it);
		fastinorder[*(inOrder + it)]=inOrder + it;/*inorder定址加速*/
	}
	tr->setroot(*preOrder);
	makeTree(*tr, preOrder, preOrder + n - 1, inOrder, inOrder + n - 1, (const int **)fastinorder);/*inorder定址加速*/
	vector<int> *v = tr->postOrder();
	for (auto it : *v)
		printf("%d ", it);
	return 0;
}

//java
import java.util.*;

class btree_node {
	public int depth, num;
	public btree_node father, lson, rson;
};

class btree {
	btree_node[] btree_base;
	btree_node root;

	public btree(final int size) {
		btree_base = new btree_node[size + 2];
		for (int i = 1; i <= size; i++) {
			btree_base[i] = new btree_node();
			btree_base[i].num = i;
		}
	}

	public void setroot(final int num)// 設定樹的根節點
	{
		root = btree_base[num];
		root.depth = 1;
	}

	public boolean setLeftSon(final int this_num, final int lson_num) {
		btree_node this_node = btree_base[this_num], lson_node = btree_base[lson_num];
		if (this_node.lson == null) {
			this_node.lson = lson_node;
			lson_node.father = this_node;
			lson_node.depth = this_node.depth + 1;
			return true;
		}
		return false;
	}

	public boolean setRightSon(final int this_num, final int rson_num) {
		btree_node this_node = btree_base[this_num], rson_node = btree_base[rson_num];
		if (this_node.rson == null) {
			this_node.rson = rson_node;
			rson_node.father = this_node;
			rson_node.depth = this_node.depth + 1;
			return true;
		}
		return false;
	}

	public boolean setFather(final int this_num, final int father_num) {
		btree_node this_node = btree_base[this_num], father_node = btree_base[father_num];
		if (this_node.father == null) {
			this_node.father = father_node;
			father_node.father = this_node;
			father_node.depth = this_node.depth - 1;
			return true;
		}
		return false;
	}

	public int depth(final int num) {
		return btree_base[num].depth;
	}

	void __pre_order(Vector v, btree_node node) {
		if (node != null) {
			v.add(node.num);
			__pre_order(v, node.lson);
			__pre_order(v, node.rson);
		}
	}

	public Vector preOrder()// 求先序遍歷
	{
		Vector v_preorder = new Vector();
		__pre_order(v_preorder, root);
		return v_preorder;
	}

	void __in_order(Vector v, btree_node node) {
		if (node != null) {
			__in_order(v, node.lson);
			v.add(node.num);
			__in_order(v, node.rson);
		}
	}

	public Vector inOrder()// 求中序遍歷
	{
		Vector v_inorder = new Vector();
		__in_order(v_inorder, root);
		return v_inorder;
	}

	void __post_order(Vector v, btree_node node) {
		if (node != null) {
			__post_order(v, node.lson);
			__post_order(v, node.rson);
			v.add(node.num);
		}
	}

	public Vector postOrder()// 求後序遍歷
	{
		Vector v_postorder = new Vector();
		__post_order(v_postorder, root);
		return v_postorder;
	}
};

public class Main {

	public static int makeTree(btree tree, // 根據前序序列，中序序列生成後序序列
			int[] preorder, final int pre_begin, final int pre_end, // 前序序列範圍
			int[] inorder, final int in_begin, final int in_end, // 中序序列範圍
			final int[] fastinorder)/* inorder定址加速 */
	{
		if (pre_end < pre_begin || in_end < in_begin)
			return 0; // 0表示無效節點
		int thisnode = preorder[pre_begin];
		final int index = fastinorder[thisnode];/* inorder定址加速 */
		// 中序序列切分(左子樹)
		int leftson = makeTree(tree, 
				preorder, pre_begin + 1, pre_begin + index - in_begin, // 左子樹前序序列範圍
				inorder, in_begin, index - 1, // 左子樹中序序列範圍
				fastinorder);/* inorder定址加速 */
		if (leftson != 0) // 0表示無效節點
			tree.setLeftSon(thisnode, leftson);
		// 中序序列切分(右子樹)
		int rightson = makeTree(tree, 
				preorder, pre_begin + index - in_begin + 1, pre_end, // 左子樹前序序列範圍
				inorder, index + 1, in_end, // 右子樹中序序列範圍
				fastinorder);/* inorder定址加速 */
		if (rightson != 0) // 0表示無效節點
			tree.setRightSon(thisnode, rightson);
		return thisnode;
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n, preOrder[], inOrder[];
		int fastinorder[];/* inorder定址加速 */
		n = sc.nextInt();
		btree tr = new btree(n);
		preOrder = new int[n];
		inOrder = new int[n];
		fastinorder = new int[n + 2];/* inorder定址加速 */
		for (int it = 0; it < n; it++)
			preOrder[it] = sc.nextInt();
		for (int it = 0; it < n; it++) {
			inOrder[it] = sc.nextInt();
			fastinorder[inOrder[it]] = it;/* inorder定址加速 */
		}
		tr.setroot(preOrder[0]);
		makeTree(tr, preOrder, 0, n - 1, inOrder, 0, n - 1, fastinorder);/* inorder定址加速 */
		Vector<Integer> v = tr.postOrder();
		for (Integer it : v)
			System.out.printf("%d ", it);
	}
}

優化前後：

相關推薦

[模板] 二叉樹 &amp; 用先序遍歷和中序遍歷建樹 (藍橋杯練習系統 演算法訓練 繪製地圖)

[模板] 二叉樹   該模板實現以下功能：   前序遍歷，中序遍歷，後序遍歷，詢問節點深度

（JAVA）二叉樹的補空法建立與前中後遍歷 層序遍歷

技術標籤：資料結構演算法JAVA演算法二叉樹java 二叉樹的建立（補空法） (按先序建立，先根再左再右） 這裡就不過多介紹了，附上詳細程式碼2，先中後序在前面的部落格中已經介紹過，這裡主要介紹層序遍歷。 （1）

翻轉二叉樹以匹配先序遍歷

給定一個有 N 個節點的二叉樹，每個節點都有一個不同於其他節點且處於 {1, ..., N} 中的值。

[LeetCode] 971. Flip Binary Tree To Match Preorder Traversal 翻轉二叉樹以匹配先序遍歷

Given two stringsSandT, each of which represents a non-negative rational number, returnTrueif and only if they represent the same number. The strings may use parentheses to denote the repeating part

Python 建立二叉樹 &amp; 遍歷二叉樹（前序、中序、後續）

二叉樹的從上到下的列印程式碼參考： print binary tree level by level in python 主要是為了更加清晰的看到二叉樹的結構

leetcode 971. 翻轉二叉樹以匹配先序遍歷

給你一棵二叉樹的根節點 root ，樹中有 n 個節點，每個節點都有一個不同於其他節點且處於 1 到 n 之間的值。

java實現根據先序遍歷和中序遍歷結果復原二叉樹（劍指offer）

思路 前序遍歷序列為根左右順序，中序遍歷序列為左根右。 首先根據前序遍歷序列確定根節點，然後在中序遍歷序列尋找根節點位置，考慮到當前序列在中序遍歷序列的開始位置從而在中序遍歷序列中能夠確定左子樹的長

入某二叉樹的前序遍歷和中序遍歷的結果，請重建該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。

輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。

LeetCode105 從前序遍歷和中序遍歷構造二叉樹

根據一棵樹的前序遍歷與中序遍歷構造二叉樹。 遞迴，根據前序遍歷當前有效區域第一個，即為當前根節點；找到中序遍歷中它的位置，左側為左節點，右側為右節點。

二叉樹的複製，線索二叉樹，用樹處理表達式

使用遞迴方式建立二叉樹，然後備份原來的二叉樹，最後將原來的二叉樹和備份的二叉樹都輸出來

資料結構與演算法_23 _ 二叉樹基礎（上）：什麼樣的二叉樹適合用陣列來儲存

前面我們講的都是線性表結構，棧、佇列等等。今天我們講一種非線性表結構，樹。樹這種資料結構比線性表的資料結構要複雜得多，內容也比較多，所以我會分四節來講解。

由前序遍歷和中序遍歷構建二叉樹-Python

思路： 1、由二叉樹的前（先）序序列和中序序列建立該二叉樹 分析：若二叉樹的任意兩個結點的值都不相同，則二叉樹的前序序列和中序序列能唯一確定一棵二叉樹。另外，由前序序列和中序序列的定義可知，前序序列中第

通過有序陣列生成平衡搜尋二叉樹 &amp; 有序連結串列轉換二叉搜尋樹（力扣）

通過有序陣列生成平衡搜尋二叉樹 題目：將有序陣列轉換為二叉搜尋樹 《程式設計師程式碼面試指南》第46題 P152 難度：士★☆☆☆

LintCode 378. 將二叉樹轉換成雙鏈表（非遞迴遍歷）

技術標籤：LintCode及其他OJ 文章目錄 1. 題目2. 解題 1. 題目 將一個二叉樹按照中序遍歷轉換成雙向連結串列。

排序二叉樹的實現（BST的插入和刪除）

排序二叉樹（Search Tree 簡稱BST）：又稱二叉搜尋樹，首先是滿足二叉樹，二叉樹就是每個結點最多有2個子結點，其特點是：它的左結點的值必須小於它的根結點的值，它的右結點的值必須大於它的根結點的值，比如5，3，

二叉樹的先序建立&amp;遞迴先序遍歷

#include <stdio.h> #include <stdlib.h> typedef char Elemtype; typedef struct BiTNode { Elemtype data;

【每日一題】【BFS&amp;Lambda&amp;重建二叉樹】2022年2月15日-根據先序中序重建並輸出二叉樹的右檢視

描述 請根據二叉樹的前序遍歷，中序遍歷恢復二叉樹，並打印出二叉樹的右檢視

二叉樹--用前序和中序遍歷序列構造二叉樹（leetcode 105

題解 你可以假設樹中沒有重複的元素。這句話代表什麼呢？ 這樣可以保證結點的數值可以在中序遍歷陣列中唯一確定，這樣還原出的二叉樹是唯一確定的

用遞迴的思想實現二叉樹前、中、後序迭代遍歷

先複習一下前、中、後遍歷的順序： 前序遍歷順序：中-左-右 中序遍歷順序：左-中-右

用層序遍歷求二叉樹的wpl值

wpl指的是樹的帶權路徑長度，是所有葉節點的權值乘以葉節點的深度之和，WPL=∑（葉節點的權值）*（葉節點的深度）