2. 程式人生 > >二叉樹線索化以及線索化的先序、中序、後序遍歷

二叉樹線索化以及線索化的先序、中序、後序遍歷

阿新 • • 發佈：2019-01-22

本篇部落格主要講述：二叉樹的線索化以及對線索二叉樹遍歷實現。

首先，什麼是二叉樹的線索化，為什麼要對二叉樹線索化？

二叉樹是一種非線性結構，遍歷二叉樹幾乎都是通過遞迴或者用棧輔助實現非遞迴的遍歷。用二叉樹作為儲存結構時，取到一個節點，只能獲取節點的左孩子和右孩子，不能直接得到節點的任一遍歷序列的前驅或者後繼。
為了儲存這種在遍歷中需要的資訊，我們利用二叉樹中指向左右子樹的空指標來存放節點的前驅和後繼資訊

n個節點的二叉樹中含有n+1個空指標域。利用二叉樹中的空指標域 來存放在某種遍歷次序下的前驅和後繼 ，這種指標叫“線索”。這種加上了線索的二叉樹稱為線索二叉樹。

根據線索的性質的不同，線索二叉樹分為：前序線索二叉樹 ， 中序線索二叉樹 ， 後序線索二叉樹（本篇部落格主要講述前面兩種 ， 後面會專門對後序線索二叉樹分析 ）

線索二叉樹節點：


typedef enum
{
	Link,  
	Thread
} PointTag;

typedef	struct  BinaryTreeNode
{
	BinaryTreeNode(const char data)
	:_data(data)
	, pLeft(NULL)
	, pRight(NULL)
	, Ltag(Link)
	, Rtag(Link)
	{}
	char _data;
	struct  BinaryTreeNode *pLeft , * pRight;
	PointTag  Ltag, Rtag; 
}BiTreeNode;
 Ltag  標記是否有左子樹  ，  Ltag 是Link 則表示有左子樹 ； Ltag是Thread表示沒有左子樹（有前驅）

 Rtag 標記是否有右子樹  ，  Rtag是Link 則表示有右子樹 ； Rtag是Thread 表示沒有右子樹（有後繼）

首先，線上索化二叉樹之前，你得有二叉樹吧驚訝

還是 按之前的方式：先序建立二叉樹

void  _CreatTree(BiTreeNode*& Root, const char* arr, size_t size, size_t& index)
	{
		if (arr == NULL || size == 0)
		{
			cout << "輸入有誤 " << endl;
			return;
		}
		if (index < size && arr[index] != '#')
		{
			Root = new BiTreeNode(arr[index]);
			_CreatTree(Root->pLeft, arr, size, ++index);
			_CreatTree(Root->pRight, arr, size, ++index);
		}
	}

以下面的二叉樹為例：


1、先序線索化二叉樹和遍歷
先序遍歷的順序：0 1 2 3 4

先序線索化二叉樹

分析：首先對於左子樹存在的節點，就不會有前驅；同樣，節點的右子樹存在，那麼不存在後繼。那麼我就先一直找尋節的左子樹，判斷左右子樹是否為空 ， 為空了才會考慮前驅和後繼的問題。後繼倒是很好找（反正要遍歷二叉樹），那麼前驅的位置呢？如果遇到左子樹不存在的節點，怎麼才能找到已經已經掃面過得節點呢？所以我們需要建立一個節點指標，每次記住上一次掃描的節點 。 對於右子樹就很好辦了 ， 如果當前節點的前一個節點不為空且右子樹不存在，那麼我們就放心大膽的鏈上吧 。然後迴圈得了。

假設 記錄前一個節點的指標為：

BiTreeNode* Prev =NULL;

沒聽懂描述麼？ 沒關係，如果所示：


上程式碼：

void _PreOrderThreading(BiTreeNode*& Root)
	{
		if (Root == NULL)
		{
			return;
		}
		if (Root->pLeft == NULL) //沒有左子樹
		{
			 Root->pLeft = Prev;   //前驅
			Root->Ltag = Thread;
		}
		if (Prev != NULL && Prev->pRight == NULL) // 上一個節點有沒有  右子樹
		{  //Prev第一次進來 為空  
			Prev->pRight = Root;   //後繼
			Prev->Rtag = Thread;
		}
		Prev = Root;//前驅  ， 每次記住上次的節點

		//判斷Root是否有左右孩子
		if (Root->Ltag == Link)
			_PreOrderThreading(Root->pLeft);
		if (Root->Rtag == Link)
			_PreOrderThreading(Root->pRight);
	}

對於先序線索二叉樹，我想提醒的是：每次只會把當前節點的左子樹前驅鏈上，這一次的 後繼 不會在本次鏈上，當pCur指向下一個節點的時候，才會把上一次的後繼鏈上

結果：


那麼 怎麼 寫先序遍歷線索二叉樹呢

void _PreOrder(BiTreeNode* Root)
	{
		if (Root == NULL)
		{
			return;
		}
		BiTreeNode* pCur = Root;
		while (pCur != NULL)
		{
			while (pCur->pLeft != NULL && pCur->Ltag == Link)//找到最左邊的節點,左標記一直為Link
			{
				cout << pCur->_data << ' ';
				pCur = pCur->pLeft;
			}
			//到這來，左邊的的節點還沒有訪問
			cout << pCur->_data << ' ';

			if (pCur->Ltag == Thread)//遇到線索 就看右節點
			{
				pCur = pCur->pRight;
			}
			while (pCur != NULL)//迴圈右節點
			{
				if (pCur->pLeft != NULL && pCur->Ltag == Link)//遇到左節點存在 ， 則訪問
				{
					break;
				}
				cout << pCur->_data << ' ';
				pCur = pCur->pRight;
			}
		}
	}
程式碼解釋：



2、中序線索化二叉樹和遍歷

中序遍歷的順序：213 0 4

中序遍歷線索化二叉樹

分析：還是和先序很像的 ，中序的順序是左-根-右，我們同樣可以使用上面的遞迴方式；

話不多說，上程式碼：

void _InOrderThreading(BiTreeNode*& Root)
	{
		if (Root == NULL)
		{
			return;
		}
		_InOrderThreading(Root->pLeft);    // 左
				
		if (Root->pLeft == NULL)	//根
		{
			Root->Ltag = Thread;
			Root->pLeft = Prev;
		}
		if (Prev != NULL && Prev->pRight == NULL)
		{
			Prev->pRight = Root;
			Prev->Rtag = Thread;
		}
		Prev = Root;
		_InOrderThreading(Root->pRight);   //右
	}
中序遍歷線索二叉樹
void _InOrder(BiTreeNode* Root)
	{
		if (Root == NULL)
		{
			return;
		}
		BiTreeNode* pCur = Root;
		while (pCur )
		{
			while (pCur->Ltag == Link) //找最左邊的節點
			{
				pCur = pCur->pLeft;
			}
			cout << pCur->_data << ' ';
			while ( pCur && pCur->Rtag == Thread )//找中序後繼節點
			{
				pCur = pCur->pRight;
				cout << pCur->_data << ' ';
			}
			//沒有後繼，有右子樹   
			pCur = pCur->pRight;
		}
	}
其實，中序遍歷和先序遍歷二叉樹還是很像的，首先按照中序遍歷的順序，找到二叉樹的最左邊的節點，判斷是否有前驅，有則遍歷訪問，沒有則看右子樹和後繼的情況。

此處，可以按照之前的畫圖過程繼續一步步來。

全部程式碼：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<assert.h>

//線索二叉樹 
typedef enum
{
	Link,
	Thread
} PointTag;

typedef	struct  BinaryTreeNode
{
	BinaryTreeNode(const char data)
	:_data(data)
	, pLeft(NULL)
	, pRight(NULL)
	, Ltag(Link)
	, Rtag(Link)
	{}
	char _data;
	struct  BinaryTreeNode *pLeft , * pRight;
	PointTag  Ltag, Rtag;
}BiTreeNode;

class Thread_BiTree
{
public:
	//先序 --建立樹
	Thread_BiTree(const char* arr, size_t Size)
		:_pRoot(NULL)
		, Prev(NULL)
	{
		size_t index = 0;
		_CreatTree(_pRoot, arr, Size , index);//建立二叉樹
	}
protected:
	void  _CreatTree(BiTreeNode*& Root, const char* arr, size_t size, size_t& index)
	{
		if (arr == NULL || size == 0)
		{
			cout << "輸入有誤 " << endl;
			return;
		}
		if (index < size && arr[index] != '#')
		{
			Root = new BiTreeNode(arr[index]);
			_CreatTree(Root->pLeft, arr, size, ++index);
			_CreatTree(Root->pRight, arr, size, ++index);
		}
	}
public:
	//先序--線索化二叉樹
	void PreOrderThreading()
	{
		_PreOrderThreading(this->_pRoot);
	}
	//先序--遍歷 線索二叉樹
	void PreOrder()
	{
		_PreOrder(this->_pRoot);
	}
protected:
	//先序--線索化二叉樹--C  
	//思路：先看左子樹， 找下一個節點的時候，在檢測上一個節點的右節點
	void _PreOrderThreading(BiTreeNode*& Root)
	{
		if (Root == NULL)
		{
			return;
		}
		if (Root->pLeft == NULL) //沒有左子樹
		{
			 Root->pLeft = Prev;   //前驅
			Root->Ltag = Thread;
		}
		if (Prev != NULL && Prev->pRight == NULL) // 上一個節點有沒有  右子樹
		{  //Prev第一次進來 為空  
			Prev->pRight = Root;   //後繼
			Prev->Rtag = Thread;
		}
		Prev = Root;//前驅  ， 每次記住上次的節點

		//判斷Root是否有左右孩子
		if (Root->Ltag == Link)
			_PreOrderThreading(Root->pLeft);
		if (Root->Rtag == Link)
			_PreOrderThreading(Root->pRight);
	}
	//先序--遍歷 線索二叉樹--C
	void _PreOrder(BiTreeNode* Root)
	{
		if (Root == NULL)
		{
			return;
		}
		BiTreeNode* pCur = Root;
		while (pCur != NULL)
		{
			while (pCur->pLeft != NULL && pCur->Ltag == Link)//找到最左邊的節點,左標記一直為Link
			{
				cout << pCur->_data << ' ';
				pCur = pCur->pLeft;
			}
			//到這來，左邊的的節點還沒有訪問
			cout << pCur->_data << ' ';

			if (pCur->Ltag == Thread)//遇到線索 就看右節點
			{
				pCur = pCur->pRight;
			}
			while (pCur != NULL)//迴圈右節點
			{
				if (pCur->pLeft != NULL && pCur->Ltag == Link)//遇到左節點存在 ， 則訪問
				{
					break;
				}
				cout << pCur->_data << ' ';
				pCur = pCur->pRight;
			}
		}
	}

public:
	//中序--線索化二叉樹
	void InOrderThreading()
	{
		_InOrderThreading(_pRoot);
	}
	//中序--遍歷線索二叉樹
	void InOrder()
	{
		_InOrder(this->_pRoot);
	}
protected:
	//中序--線索化二叉樹--C
	//思路:按 左-根-右的順序   先找到最左邊的節點-> 和先序線索一樣 ,先連結左子樹，執行到下一個節點在看上次節點的右子樹 -> 右子樹
	void _InOrderThreading(BiTreeNode*& Root)
	{
		if (Root == NULL)
		{
			return;
		}
		_InOrderThreading(Root->pLeft);    // 左
				
		if (Root->pLeft == NULL)	//根
		{
			Root->Ltag = Thread;
			Root->pLeft = Prev;
		}
		if (Prev != NULL && Prev->pRight == NULL)
		{
			Prev->pRight = Root;
			Prev->Rtag = Thread;
		}
		Prev = Root;
		_InOrderThreading(Root->pRight);   //右
	}
	//中序--遍歷二叉樹--C
	//思路：找到中序開始的節點（最左邊的節點）-> (後繼 )它的根節點，若沒有則找右節點
	void _InOrder(BiTreeNode* Root)
	{
		if (Root == NULL)
		{
			return;
		}
		BiTreeNode* pCur = Root;
		while (pCur )
		{
			while (pCur->Ltag == Link) //找最左邊的節點
			{
				pCur = pCur->pLeft;
			}
			cout << pCur->_data << ' ';

			while ( pCur && pCur->Rtag == Thread )//找中序後繼節點
			{
				pCur = pCur->pRight;
				cout << pCur->_data << ' ';
			}
			//沒有後繼，有右子樹   
			pCur = pCur->pRight;
		}
	}
public:
	//後序--線索二叉樹
	void PostOrderThreading()
	{
		_PostOrderThreading(_pRoot);
	}
protected:
	//後序--線索二叉數--C
	//思路：左-右-根  和前面的一樣
	void _PostOrderThreading(BiTreeNode*& Root)
	{
		if (Root == NULL)
		{
			return;
		}
		_PostOrderThreading(Root->pLeft);
		_PostOrderThreading(Root->pRight);

		if (Root->pLeft == NULL)
		{
			Root->pLeft = Prev;
			Root->Ltag = Thread;
		}
		if (Prev != NULL && Prev->pRight == NULL)
		{
			Prev->pRight = Root;
			Prev->Rtag = Thread;
		}
		Prev = Root;
	}
private:
	BiTreeNode* _pRoot;
	BiTreeNode* Prev;  //記錄
};

int main()
{
	//char * arr = "013##4##25##6##";
	char * arr = "012##3##4##";
    Thread_BiTree tree(arr, strlen(arr));

	tree.PreOrderThreading();            //先序線索化
	tree.PreOrder();                   //遍歷先序線索二叉樹
	cout << endl << "------------------------" << endl;

	char * arr1 = "013##4##25##6##";
	Thread_BiTree tree1(arr1, strlen(arr1));
	tree1.InOrderThreading();          //中序線索化
	tree1.InOrder();                //遍歷中序線索二叉樹
	cout << endl << "------------------------" << endl;

	char * arr2 = "013##4##25##6##";
	Thread_BiTree tree2(arr2, strlen(arr2));
	tree2.PostOrderThreading();
	tree2.PostOrder();
	cout << endl << "------------------------" << endl;
	return 0;
}

下一篇將詳細的講述，後序線索化二叉樹及遍歷（我也是花了很大的心思，看了好久才看明白）

PS：祝你們學習愉快，希望能學到知識的同時，分享給渴求知識的各位童鞋

相關推薦

線索二叉樹的原理以及建立和遍歷（c++）

這是一篇非常好的關於線索二叉樹的文章，內容詳細到位，敘述清晰。作者應該是很認真、細心的人，估計花了不少時間和精力，向作者致敬！ 一、線索二叉樹概念 具有 n 個結點的二叉連結串列中，其二叉連結串列的 n 個結點中共有 2n 個指標域，在這 2n 個指標域中，真正

線索二叉樹詳解以及程式碼實現

參照《大話資料結構》188到194頁。 一、二叉樹的線索儲存結構定義 /* 二叉樹線索儲存結構定義 Link = 0,代表指向左右孩子的指標 Thread= 1 代表指向前驅或後繼的線索*/ typedef enum{ Link, Thread} Pointe

java實現二叉樹的構建以及3種遍歷方法

輸出 for () 如果 順序 bintree 參考 oca gpl 轉載自http://ocaicai.iteye.com/blog/1047397 大二下學期學習數據結構的時候用C介紹過二叉樹，但是當時熱衷於java就沒有怎麽鳥二叉樹，但是對二叉樹的構建及遍歷一

Python實現二叉樹的建立以及遍歷（遞迴前序、中序、後序遍歷，隊棧前序、中序、後序、層次遍歷）

class Node: def __init__(self,data): self.data=data self.lchild=None self.rchild=None class Tree: def __init__(se

C語言二叉樹的建立以及輸出二叉樹的深度

二叉樹的深度（10分） 題目內容： 給定一棵二叉樹，求該二叉樹的深度 二叉樹深度定義：從根結點到葉結點依次經過的結點（含根、葉結點）形成樹的一條路徑，最長路徑的節點個數為樹的深度       輸入格式: 第一行是一個整數n，表示二叉樹的結

C語言-二叉樹基本操作以及二叉搜尋樹基本操作

功能 二叉樹操作: 建立二叉樹 遍歷二叉樹(前序,中序,後續) 計算高度 計算結點數目 清空二叉樹 空樹判斷 二叉搜尋樹操作: 插入 最值(最大值,最小值) 刪除 程式碼 #include &l

二叉樹的建立以及三種遍歷操作

      由二叉樹結點的性質可以確定的是，二叉樹結構相比普通的連結串列結點而複雜，需要通過其左/右指標訪問其左/右子樹結點。而在熟悉了二叉樹的結構後，需要注意的是二叉樹的建立以及遍歷操作。而建立與遍歷兩種操作，需要利用的是遞迴的思想，即保持每一個子集函式操作與其父函式相同。

【資料結構】平衡二叉樹的構建以及增加刪除操作

一、前言       最近學習中遇到了平衡二叉樹的實用，要求是對一個數據列，進行平衡二叉樹的排列，並畫出結果，小編剛開始的時候不是很會，通過總結資料學習了一下平衡二叉樹的相關知識，通過部落格總結一下。

C++二叉樹的建立以及遍歷

最近在刷 leetcode 的題目，初學演算法，菜鳥一枚，寫部落格記錄下常用程式碼，以備以後查閱，如果程式碼出現問題，請各位高手指教 void CreatBiTree(TreeNode* &T) { char ch; if ((ch = getchar())

第六章樹和二叉樹作業1—二叉樹--計算機17級 6-3 先序輸出葉結點 （15 分）

6-3 先序輸出葉結點 （15 分） 本題要求按照先序遍歷的順序輸出給定二叉樹的葉結點。 函式介面定義： void PreorderPrintLeaves( BinTree BT ); 其中BinTree結構定義如下： typedef struct TN

二叉樹 二叉樹帶虛結點表示的先序遍歷可以確定唯一一顆二叉樹

二叉樹模版變形 #include <iostream> #include<stdio.h> #include<stdlib.h> #include<string.h> #include<queue> using

二叉樹的非遞迴實現先序遍歷

//先序遍歷非遞迴演算法的實現 用到自定義的棧 void preOrderNonrecursion(BTNode *bt) { if(bt !=null) { BTNode *stack[maxSize]; //先定義一個棧用於存放遍歷的二叉樹 int

二叉樹BST叠代器（非遞歸中序遍歷）——Binary Search Tree Iterator

tor col 初始化 turn clas return sta style stack 用棧來實現二叉樹的非遞歸中序遍歷 1、棧初始化：從根節點出發一路向左，將一路上的節點push到棧中 2、取next並進行棧的調整：從stack棧頂pop出來的節點即為要取的next

二叉樹線索化以及線索化的先序、中序、後序遍歷

本篇部落格主要講述：二叉樹的線索化以及對線索二叉樹遍歷實現。 首先，什麼是二叉樹的線索化，為什麼要對二叉樹線索化？ 二叉樹是一種非線性結構，遍歷二叉樹幾乎都是通過遞迴或者用棧輔助實現非遞迴的遍歷。用二叉樹作為儲存結構時，取到一個節點，只能獲取節點的左孩子和右孩子，不能直

二叉樹的線索化

chan 構建 訪問 線索二叉樹 borde class 序列 oot png 二叉樹是一種非線性結構，遍歷二叉樹幾乎都是通過遞歸或者用棧輔助實現非遞歸的遍歷。二叉樹作為存儲結構時，一個節點只能獲取節點的左孩子和右孩子，不能直接得到節點的任一遍歷序列的前驅或者後繼。為了保存

為什麽二叉樹總能中序線索化

思想 計算 編程 中序遍歷 發揮 合成 會有 二叉線索樹 整體 為什麽二叉樹為什麽總是可以按照中序遍歷線索化空指針是夠但怎麽保證不會有一個有左右孩子的節點不被別人指到想了想可以用類似於數學歸納法這樣證明： 先討論三種最簡單的情形 1. ab c b左指針

線索二叉樹--二叉樹線索化

type 兩個 標記 typedef 指針 有一個 進行 查找 後繼節點 遍歷二叉樹是對非線性結構進行線性化操作，在得到的訪問序列中，每個節點都只有一個直接前去和一個直接後繼。 引入線索二叉樹可以加快查找前去於後繼節點的速度，實質就是將二叉鏈表中的空指針改為指向前驅或者後繼

二叉樹的線索化(摘自天勤資料結構高分筆記)

/************************************************************************/ /*      二叉樹的線索化：二叉樹的線索化可以將二叉樹非遞迴遍歷演算法中的使用者棧也給省掉，進一步提高效率     中序線

二叉樹線索化和遍歷的演算法

前言： 關於二叉線索樹有什麼作用，為什麼要建立這裡就不介紹。因為時間問題，只是總結一下線索化和遍歷的演算法。這個演算法和前面總結過的非遞迴法遍歷二叉樹都算是資料結構裡面難度係數比棧，佇列，線性表那些大的演算法。限定時間內要寫出來還是有些難度，最好是能有所總結，

二叉樹的線索化演算法思想詳解

    二叉樹的線索化，這幾天以來我很難掌握，今天終於想通了，哈哈，首先我們來看看二叉樹線索化之後會變成什麼樣子，這裡我們以圖中的二叉樹為例，圖如下：    畫的太糙，各位看官講究著看吧- -。所謂二叉樹的線索化，就是當一個節點的左右指標為空時，就讓它的左右指標指向該節點的前