2. 程式人生 > >演算法之二叉樹各種遍歷

演算法之二叉樹各種遍歷

阿新 • • 發佈：2019-02-09

樹形結構是一類重要的非線性資料結構，其中以樹和二叉樹最為常用。

二叉樹是每個結點最多有兩個子樹的有序樹。通常子樹的根被稱作“左子樹”（left subtree）和“右子樹”（right subtree）。二叉樹常被用作二叉查詢樹和二叉堆或是二叉排序樹。二叉樹的每個結點至多隻有二棵子樹(不存在度大於2的結點)，二叉樹的子樹有左右之分，次序不能顛倒。二叉樹的第i層至多有2的 i -1次方個結點；深度為k的二叉樹至多有2^(k) -1個結點；對任何一棵二叉樹T，如果其終端結點數(即葉子結點數)為n0，度為2的結點數為n2，則n0 = n2 + 1。

二叉樹的鏈式儲存結構是一類重要的資料結構，其形式定義如下：

//二叉樹結點
typedef struct BiTNode{
	//資料
	char data;
	//左右孩子指標
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
二叉樹的建立：

通過讀入一個字串，建立二叉樹的演算法如下：

//按先序序列建立二叉樹
int CreateBiTree(BiTree &T){
	char data;
	//按先序次序輸入二叉樹中結點的值（一個字元），‘#’表示空樹
	scanf("%c",&data);
	if(data == '#'){
		T = NULL;
	}
	else{
		T = (BiTree)malloc(sizeof(BiTNode));
		//生成根結點
		T->data = data;
		//構造左子樹
		CreateBiTree(T->lchild);
		//構造右子樹
		CreateBiTree(T->rchild);
	}
	return 0;
}

二叉樹的遍歷：

遍歷是對樹的一種最基本的運算，所謂遍歷二叉樹，就是按一定的規則和順序走遍二叉樹的所有結點，使每一個結點都被訪問一次，而且只被訪問一次。由於二叉樹是非線性結構，因此，樹的遍歷實質上是將二叉樹的各個結點轉換成為一個線性序列來表示。

遞迴演算法：

//輸出
void Visit(BiTree T){
	if(T->data != '#'){
		printf("%c ",T->data);
	}
}
//先序遍歷
void PreOrder(BiTree T){
	if(T != NULL){
		//訪問根節點
		Visit(T);
		//訪問左子結點
		PreOrder(T->lchild);
		//訪問右子結點
		PreOrder(T->rchild);
	}
}
//中序遍歷
void InOrder(BiTree T){
	if(T != NULL){
		//訪問左子結點
		InOrder(T->lchild);
		//訪問根節點
		Visit(T);
		//訪問右子結點
		InOrder(T->rchild);
	}
}
//後序遍歷
void PostOrder(BiTree T){
	if(T != NULL){
		//訪問左子結點
		PostOrder(T->lchild);
		//訪問右子結點
		PostOrder(T->rchild);
		//訪問根節點
		Visit(T);
	}
}

非遞迴演算法：

<1>先序遍歷：

【思路】：訪問T->data後，將T入棧，遍歷左子樹；遍歷完左子樹返回時，棧頂元素應為T，出棧，再先序遍歷T的右子樹。

/* 先序遍歷(非遞迴)
   思路：訪問T->data後，將T入棧，遍歷左子樹；遍歷完左子樹返回時，棧頂元素應為T，出棧，再先序遍歷T的右子樹。
*/
void PreOrder2(BiTree T){
	stack<BiTree> stack;
	//p是遍歷指標
	BiTree p = T;
	//棧不空或者p不空時迴圈
	while(p || !stack.empty()){
		if(p != NULL){
			//存入棧中
			stack.push(p);
			//訪問根節點
			printf("%c ",p->data);
			//遍歷左子樹
			p = p->lchild;
		}
		else{
			//退棧
			p = stack.top();
			stack.pop();
			//訪問右子樹
			p = p->rchild;
		}
	}//while
}
<2>中序遍歷

【思路】：T是要遍歷樹的根指標，中序遍歷要求在遍歷完左子樹後，訪問根，再遍歷右子樹。
         先將T入棧，遍歷左子樹；遍歷完左子樹返回時，棧頂元素應為T，出棧，訪問T->data，再中序遍歷T的右子樹。

void InOrder2(BiTree T){
	stack<BiTree> stack;
	//p是遍歷指標
	BiTree p = T;
	//棧不空或者p不空時迴圈
	while(p || !stack.empty()){
		if(p != NULL){
			//存入棧中
			stack.push(p);
			//遍歷左子樹
			p = p->lchild;
		}
		else{
			//退棧，訪問根節點
			p = stack.top();
			printf("%c ",p->data);
			stack.pop();
			//訪問右子樹
			p = p->rchild;
		}
	}//while
}

<3>後序遍歷

【思路】：T是要遍歷樹的根指標，後序遍歷要求在遍歷完左右子樹後，再訪問根。需要判斷根結點的左右子樹是否均遍歷過。

//後序遍歷(非遞迴)
typedef struct BiTNodePost{
	BiTree biTree;
	char tag;
}BiTNodePost,*BiTreePost;

void PostOrder2(BiTree T){
	stack<BiTreePost> stack;
	//p是遍歷指標
	BiTree p = T;
	BiTreePost BT;
	//棧不空或者p不空時迴圈
	while(p != NULL || !stack.empty()){
		//遍歷左子樹
		while(p != NULL){
			BT = (BiTreePost)malloc(sizeof(BiTNodePost));
			BT->biTree = p;
			//訪問過左子樹
			BT->tag = 'L';
			stack.push(BT);
			p = p->lchild;
		}
		//左右子樹訪問完畢訪問根節點
		while(!stack.empty() && (stack.top())->tag == 'R'){
			BT = stack.top();
			//退棧
			stack.pop();
			BT->biTree;
			printf("%c ",BT->biTree->data);
		}
		//遍歷右子樹
		if(!stack.empty()){
			BT = stack.top();
			//訪問過右子樹
			BT->tag = 'R';
			p = BT->biTree;
			p = p->rchild;
		}
	}//while
}

<4>層次遍歷

【思路】：按從頂向下，從左至右的順序來逐層訪問每個節點，層次遍歷的過程中需要用佇列。

//層次遍歷
void LevelOrder(BiTree T){
	BiTree p = T;
	//佇列
	queue<BiTree> queue;
	//根節點入隊
	queue.push(p);
	//佇列不空迴圈
	while(!queue.empty()){
		//對頭元素出隊
		p = queue.front();
		//訪問p指向的結點
		printf("%c ",p->data);
		//退出佇列
		queue.pop();
		//左子樹不空，將左子樹入隊
		if(p->lchild != NULL){
			queue.push(p->lchild);
		}
		//右子樹不空，將右子樹入隊
		if(p->rchild != NULL){
			queue.push(p->rchild);
		}
	}
}


測試用例：


輸入：

ABC##DE#G##F###

輸出：


程式碼：

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

//二叉樹結點
typedef struct BiTNode{
	//資料
	char data;
	//左右孩子指標
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

//按先序序列建立二叉樹
int CreateBiTree(BiTree &T){
	char data;
	//按先序次序輸入二叉樹中結點的值（一個字元），‘#’表示空樹
	scanf("%c",&data);
	if(data == '#'){
		T = NULL;
	}
	else{
		T = (BiTree)malloc(sizeof(BiTNode));
		//生成根結點
		T->data = data;
		//構造左子樹
		CreateBiTree(T->lchild);
		//構造右子樹
		CreateBiTree(T->rchild);
	}
	return 0;
}
//輸出
void Visit(BiTree T){
	if(T->data != '#'){
		printf("%c ",T->data);
	}
}
//先序遍歷
void PreOrder(BiTree T){
	if(T != NULL){
		//訪問根節點
		Visit(T);
		//訪問左子結點
		PreOrder(T->lchild);
		//訪問右子結點
		PreOrder(T->rchild);
	}
}
//中序遍歷  
void InOrder(BiTree T){  
    if(T != NULL){  
        //訪問左子結點  
        InOrder(T->lchild);  
        //訪問根節點  
        Visit(T);  
        //訪問右子結點  
        InOrder(T->rchild);  
    }  
}  
//後序遍歷
void PostOrder(BiTree T){
	if(T != NULL){
		//訪問左子結點
		PostOrder(T->lchild);
		//訪問右子結點
		PostOrder(T->rchild);
		//訪問根節點
		Visit(T);
	}
}
/* 先序遍歷(非遞迴)
   思路：訪問T->data後，將T入棧，遍歷左子樹；遍歷完左子樹返回時，棧頂元素應為T，出棧，再先序遍歷T的右子樹。
*/
void PreOrder2(BiTree T){
	stack<BiTree> stack;
	//p是遍歷指標
	BiTree p = T;
	//棧不空或者p不空時迴圈
	while(p || !stack.empty()){
		if(p != NULL){
			//存入棧中
			stack.push(p);
			//訪問根節點
			printf("%c ",p->data);
			//遍歷左子樹
			p = p->lchild;
		}
		else{
			//退棧
			p = stack.top();
			stack.pop();
			//訪問右子樹
			p = p->rchild;
		}
	}//while
}
/* 中序遍歷(非遞迴)
   思路：T是要遍歷樹的根指標，中序遍歷要求在遍歷完左子樹後，訪問根，再遍歷右子樹。
         先將T入棧，遍歷左子樹；遍歷完左子樹返回時，棧頂元素應為T，出棧，訪問T->data，再中序遍歷T的右子樹。
*/
void InOrder2(BiTree T){
	stack<BiTree> stack;
	//p是遍歷指標
	BiTree p = T;
	//棧不空或者p不空時迴圈
	while(p || !stack.empty()){
		if(p != NULL){
			//存入棧中
			stack.push(p);
			//遍歷左子樹
			p = p->lchild;
		}
		else{
			//退棧，訪問根節點
			p = stack.top();
			printf("%c ",p->data);
			stack.pop();
			//訪問右子樹
			p = p->rchild;
		}
	}//while
}

//後序遍歷(非遞迴)
typedef struct BiTNodePost{
	BiTree biTree;
	char tag;
}BiTNodePost,*BiTreePost;

void PostOrder2(BiTree T){
	stack<BiTreePost> stack;
	//p是遍歷指標
	BiTree p = T;
	BiTreePost BT;
	//棧不空或者p不空時迴圈
	while(p != NULL || !stack.empty()){
		//遍歷左子樹
		while(p != NULL){
			BT = (BiTreePost)malloc(sizeof(BiTNodePost));
			BT->biTree = p;
			//訪問過左子樹
			BT->tag = 'L';
			stack.push(BT);
			p = p->lchild;
		}
		//左右子樹訪問完畢訪問根節點
		while(!stack.empty() && (stack.top())->tag == 'R'){
			BT = stack.top();
			//退棧
			stack.pop();
			printf("%c ",BT->biTree->data);
		}
		//遍歷右子樹
		if(!stack.empty()){
			BT = stack.top();
			//訪問過右子樹
			BT->tag = 'R';
			p = BT->biTree;
			p = p->rchild;
		}
	}//while
}
//層次遍歷
void LevelOrder(BiTree T){
	BiTree p = T;
	//佇列
	queue<BiTree> queue;
	//根節點入隊
	queue.push(p);
	//佇列不空迴圈
	while(!queue.empty()){
		//對頭元素出隊
		p = queue.front();
		//訪問p指向的結點
		printf("%c ",p->data);
		//退出佇列
		queue.pop();
		//左子樹不空，將左子樹入隊
		if(p->lchild != NULL){
			queue.push(p->lchild);
		}
		//右子樹不空，將右子樹入隊
		if(p->rchild != NULL){
			queue.push(p->rchild);
		}
	}
}
int main()
{
	BiTree T;
	CreateBiTree(T);
	printf("先序遍歷：\n");
	PreOrder(T);
	printf("\n");
	printf("先序遍歷(非遞迴)：\n");
	PreOrder2(T);
	printf("\n");
	printf("中序遍歷：\n");
	InOrder(T);
	printf("\n");
	printf("中序遍歷(非遞迴)：\n");
	InOrder2(T);
	printf("\n");
	printf("後序遍歷：\n");
	PostOrder(T);
	printf("\n");
	printf("後序遍歷(非遞迴)：\n");
	PostOrder2(T);
	printf("\n");
	printf("層次遍歷：\n");
	LevelOrder(T);
	printf("\n");
    return 0;
}


相關推薦

演算法之二叉樹各種遍歷

樹形結構是一類重要的非線性資料結構，其中以樹和二叉樹最為常用。 二叉樹是每個結點最多有兩個子樹的有序樹。通常子樹的根被稱作“左子樹”（left subtree）和“右子樹”（right subtree）。二叉樹常被用作二叉查詢樹和二叉堆或是二叉排序樹。二叉樹的每個結點至多隻

演算法之二叉樹分層遍歷

通過佇列實現二叉樹的分層遍歷，換行可以使用last和nLast兩個變數，每次新增新的最右節點記錄nLast,每次從佇列彈棧記錄一個節點node,node==last換行，把nLast賦值給last，用二維陣列遍歷。  ArrayList<ArrayList<Integer&

資料結構與演算法隨筆之------二叉樹的遍歷（一文搞懂二叉樹的四種遍歷）

二叉樹的遍歷 二叉樹的遍歷（traversing binary tree）是指從根結點出發，按照某種次序依次訪問二叉樹中所有的結點，使得每個結點被訪問依次且僅被訪問一次。 遍歷分為四種，前序遍歷，中序遍歷，後序遍歷及層序遍歷 前序 中

LeetCode之二叉樹層次遍歷逆序輸出（簡單 二叉樹）

問題描述： 給定一個二叉樹，返回其節點值自底向上的層次遍歷。 （即按從葉子節點所在層到根節點所在的層，逐層從左向右遍歷） 例如： 給定二叉樹 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7

二叉樹面試題之二叉樹的遍歷方式

一、基本概念 1、二叉樹的概念 一棵二叉樹是結點的一個有限集合，該集合或者為空，或者是由一個根節點加上兩棵分別稱為左子樹和右子樹的二叉樹組成（即一個根節點最多隻有兩個孩子結點）。 2、二叉樹的特點 （1）每個結點最多有兩棵子樹，即二叉樹不存在度大於2的結

百度面試題之二叉樹層次遍歷(從上到下，從下到上)

1.二叉樹的層次遍歷 遞迴解法 class Node(object): def __init__(self, v, left=None, right=None): self.value = v self.left = l

資料結構之二叉樹的遍歷：

一.二叉樹—特殊樹（基礎知識） （一）概念： 一個二叉樹要麼為空，要麼包含一個根節點，外加一個左子樹和右子樹，每一個字數都是二叉樹 (二)二叉樹的形狀： 不平衡二叉樹、完美平衡二叉樹、完全二叉樹、滿二叉樹； 一般來說二叉樹越平衡，訪問、插入、刪除的效能也越高； （三）二叉樹的遍歷; 1,前序

二叉樹各種遍歷操作

目錄 本文總結關於二叉樹的各種遍歷演算法 首先定義二叉樹節點結構體 struct TreeNode { int val; struct TreeNode *lef

資料結構實驗之二叉樹的遍歷

【實驗內容】 建立一個二叉樹，對這棵動態二叉樹進行分析，將其用靜態二叉連結串列表示。二叉樹的動態二叉連結串列結構中的每個結點有三個欄位：data，lchild，rchild。靜態二叉連結串列是用陣列作為儲存空間，每個陣列元素儲存二叉樹的一個結點，也有三個欄位：

資料結構之二叉樹的遍歷

二叉樹的遍歷：先序遍歷： 先訪問根節點再遍歷左子樹                      再遍歷右子樹中序遍歷：中序遍歷左子樹                      再訪問根節點        

【面試題之演算法部分】二叉樹的遍歷

本篇文章主要目的是詳細討論二叉樹的前序、中序和後序遍歷演算法，包括遞迴版和迭代版。首先給出遞迴版的一般思想： 前序遍歷：先訪問根節點，前序遍歷左子樹，前序遍歷右子樹。 中序遍歷：中序遍歷左子樹，訪問根節點，中序遍歷右子樹。 後序遍歷：後序遍歷左子樹，後序遍歷

二叉樹的遍歷演算法（js實現）

之前我的部落格中講到了如何通過js去實現一顆二叉樹，有興趣的可以去我的部落格中看下。今天我們來一起實現下二叉樹的遍歷演算法。歡迎大家幫忙指出不當之處，或者進行深入的挖掘。大家一起進步。二叉樹吶，有三種遍歷演算法，1：中序遍歷，2：先序遍歷，3：後序遍歷。在我們看具體實現之前，我們想下為什麼要這樣做？二叉樹廣泛

PTA 資料結構與演算法題目集（中文） 6-9 二叉樹的遍歷

6-9 二叉樹的遍歷（25 分）本題要求給定二叉樹的4種遍歷。函式介面定義：void InorderTraversal( BinTree BT ); void PreorderTraversal( Bi

PTA資料結構與演算法題目集（中文）4-9 二叉樹的遍歷 (25分)

本題要求給定二叉樹的4種遍歷。 函式介面定義： void InorderTraversal( BinTree BT ); void PreorderTraversal( BinTree BT ); void PostorderTraversal( BinTree BT

二叉樹的遍歷演算法Java實現

學習並總結了二叉樹的遞迴和非遞迴的遍歷方式~ 下面是自己邊敲邊學的程式碼。 package tree; import java.util.LinkedList; public class Binaryorder { private Tree

面試題23：二叉樹的遍歷演算法

一. 構造二叉樹 構造二叉樹，先得要構建一個樹的節點，定義一個TreeNode： public class TreeNode { int val; TreeNode left; TreeNode right;

二叉樹的遍歷之先序遍歷、中序遍歷和後序遍歷

例圖：                   1.先序遍歷   先序遍歷也叫做先跟遍歷、前序遍歷。先序遍歷步驟為：訪問根結點然後遍歷左子樹，最後遍歷右子樹。在遍歷左、右子樹時，仍然先訪問根結點，然後遍歷左子樹，最後遍歷右子樹。即根左右。   如上圖1，先序遍歷的序列為：

【LeetCode & 劍指offer刷題】樹題1：二叉樹的遍歷總結（前序、中序、後序、層序、 之字形層序、垂直遍歷）

【LeetCode & 劍指offer 刷題筆記】目錄（持續更新中...）   二叉樹的遍歷總結 （前序、中序、後序、層序、 之字形層序、垂直遍歷）   三種遞迴遍歷 // 前序遍歷（根-左-右）

C語言 二叉樹的遍歷 遞迴和（多種）非遞迴演算法

//二叉樹遍歷 //作者：nuaazdh //時間：2011年12月1日 #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #defi

資料結構之二叉排序樹及二叉樹的遍歷

本文解決的問題是： 構建一個二叉排序樹，隨機產生20個樹，並實現該二叉樹的三種深度遍歷（遞迴和非遞迴）和一種廣度遍歷。 實現程式碼如下： #include<stdio.h> #include<stdlib.h> #define MaxSize 10