2. 程式人生 > >二叉樹的應用

二叉樹的應用

阿新 • • 發佈：2018-11-13

一、層序遍歷的應用：

映象：還需要引入佇列，同上一篇部落格。

.h

# pragma once
# include<assert.h>
# include<malloc.h>
# include<stdio.h>
# include<stdlib.h>
# include<string.h>
# include"Queue.h"
typedef char BTDataType;
typedef struct BinTreeBTNode
{
	struct BinTreeBTNode* _pLeft;
	struct BinTreeBTNode* _pRight;
	BTDataType _data;
}BTBTNode,*PBTNode;

PBTNode BuyBinTreeBTNode(BTDataType data);
 
void _CreateBinTree(PBTNode* pRoot, BTDataType array[], int size, int* index, BTDataType invalid);
 
void CreateBinTree(PBTNode* pRoot, BTDataType array[], int size, BTDataType invalid);
 
//拷貝一棵樹,根加左子樹加右子樹
PBTNode CopyBinTree(PBTNode pRoot);
 
//二叉樹的前需遍歷：根+左子樹+右子樹
void PreOrder(PBTNode pRoot);
 
//中序遍歷：左子樹+根節點+右子樹
void InOrder(PBTNode pRoot);
 
//後序遍歷：左子樹+右子樹+根節點
void PostOrder(PBTNode pRoot);
 
void DestroyBinTree(PBTNode* pRoot);

void MirrorBinTree(PBTNode pRoot);
void MirrorBinTreeNor(PBTNode pRoot);

.c

# include"BinaryTree.h"

 
//#define NULL 0
PBTNode BuyBinTreeNode(DataType data)
{
	PBTNode pNewNode = (PBTNode)malloc(sizeof(Node));
	if (NULL == pNewNode)
	{
		assert(0);
		return NULL;
	}
	pNewNode->_data = data;
	pNewNode->_pLeft = NULL;
	pNewNode->_pRight = NULL;
	return pNewNode;
}
void _CreateBinTree(PBTNode* pRoot, DataType array[], int size, int* index, DataType invalid)
{
	assert(pRoot);//此時pRoot代表外部實參的地址,可以改變指向
	assert(index);
	if (*index < size&&invalid != array[*index]){
		*pRoot = BuyBinTreeNode(array[*index]);
		//建立根節點的左子樹
		++(*index);
		_CreateBinTree(&(*pRoot)->_pLeft, array, size, index, invalid);
		//建立根節點的右子樹
		++(*index);
		_CreateBinTree(&(*pRoot)->_pRight, array, size, index, invalid);
	}
}
void CreateBinTree(PBTNode* pRoot, DataType array[], int size, DataType invalid)
{
	int index = 0;
	_CreateBinTree(pRoot, array, size, &index, invalid);

}
//拷貝一棵樹,根加左子樹加右子樹
PBTNode CopyBinTree(PBTNode pRoot){
	PBTNode pNewRoot = NULL;
	if (pRoot){
		//拷貝根節點
		pNewRoot = BuyBinTreeNode(pRoot->_data);
		//拷貝根節點的左子樹
		if (pRoot->_pLeft)
			pNewRoot->_pLeft = CopyBinTree(pRoot->_pLeft);
		//拷貝根節點的右子樹
		if (pRoot->_pRight)
			pNewRoot->_pRight = CopyBinTree(pRoot->_pRight);
	}
	return pNewRoot;
}
//二叉樹的前需遍歷：根+左子樹+右子樹
void PreOrder(PBTNode pRoot)
{
	if (pRoot)
	{
		printf("%c ", pRoot->_data);
		PreOrder(pRoot->_pLeft);
		PreOrder(pRoot->_pRight);
	}
}
//中序遍歷：左子樹+根節點+右子樹
void InOrder(PBTNode pRoot)
{
	if (pRoot)
	{

		InOrder(pRoot->_pLeft);
		printf("%c ", pRoot->_data);
		InOrder(pRoot->_pRight);
	}
}
//後序遍歷：左子樹+右子樹+根節點
void PostOrder(PBTNode pRoot)
{
	if (pRoot)
	{

		PostOrder(pRoot->_pLeft);
		PostOrder(pRoot->_pRight);
		printf("%c ", pRoot->_data);
	}
}
void LevelOrder(PBTNode pRoot)
{
	Queue q;
	if (NULL == pRoot)
		return;
	QueueInit(&q);//初始化根節點
	//把根節點的地址加到樹裡面
	QueuePush(&q, pRoot);
	while (!QueueEmpty(&q)){
		//遍歷
		PBTNode pCur = QueueFront(&q);
		printf("%c  ", pCur->_data);
		//QueuePop(&q);出佇列的操作也可以放在這個位置上
		//把元素放到佇列裡
		if (pCur->_pLeft)
			QueuePush(&q, pCur->_pLeft);
		if (pCur->_pRight)
			QueuePush(&q, pCur->_pRight);
		//從佇列裡面拿出去
		QueuePop(&q);
	}
}
void DestroyBinTree(PBTNode* pRoot)
{
	assert(pRoot);
	if (*pRoot){
		//銷燬左子樹
		DestroyBinTree(&(*pRoot)->_pLeft);
		//銷燬右子樹
		DestroyBinTree(&(*pRoot)->_pRight);
		//銷燬根節點
		free(*pRoot);
		*pRoot = NULL;
	}
}

void Swap(PBTNode* pLeft, PBTNode* pRight)
{
	PBTNode tmp = *pLeft;
	*pLeft = *pRight;
	*pRight = tmp;
}
//非遞迴實現
void MirrorBinTreeNor(PBTNode pRoot){
	Queue q;
	if (NULL == pRoot)
		return;
	QueueInit(&q);
	QueuePush(&q, pRoot);
	while (!QueueEmpty(&q))
	{
		//如果當前佇列不為空，取對頭元素
		PBTNode pCur = QueueFront(&q);
		//交換左右孩子
		Swap(&(pCur->_pLeft),&(pCur->_pRight));
		if (pCur->_pLeft)
			QueuePush(&q, pCur->_pLeft);//將左孩子寫入
		if (pCur->_pRight)
			QueuePush(&q, pCur->_pRight);
	}
}
//遞迴實現映象
void MirrorBinTree(PBTNode pRoot)
{
	if (pRoot)
	{
		Swap(&(pRoot->_pLeft), &(pRoot->_pRight));
		MirrorBinTree(pRoot->_pLeft);
		MirrorBinTree(pRoot->_pRight);
	}
}
void TestBinTree()
{
	char* str = "ABD###CE##F";
	PBTNode pRoot = NULL, pNewRoot;
	CreateBinTree(&pRoot, str, strlen(str), '#');
	pNewRoot = CopyBinTree(pRoot);

	printf("前序遍歷：");
	PreOrder(pRoot);
	printf("\n");

	printf("中序遍歷：");
	InOrder(pRoot);
	printf("\n");

	printf("後序遍歷：");
	PostOrder(pRoot);
	printf("\n");

	printf("層序遍歷：");
	LevelOrder(pRoot);

	MirrorBinTree(pRoot);
	MirrorBinTreeNor(pRoot);
	printf("層序遍歷：");
	LevelOrder(pRoot);
}

//A B D # # # C E #

二、

1、求二叉樹中結點總的個數；

遞迴呼叫的時間複雜度：遞迴呼叫總的次數*每次遞迴呼叫的次數，一個結點兩個指標域，n個結點則有2*n個指標域；每個指標域都是一次函式呼叫，遞迴程式總的呼叫次數為2n，每一次呼叫了兩次，則為4n。所以節點總的個數為O(n)。

int BinTreeSize(PBTNode pRoot)
{
	if (NULL == pRoot)
		return 0;
	int left = BinTreeSize(pRoot->_pLeft);
	int right = BinTreeSize(pRoot->_pRight);
	return left + right + 1;
}

測試的程式碼：

void TestBinTree()
{
	char* str = "ABD###CE##F";
	PBTNode pRoot = NULL, pNewRoot;
	CreateBinTree(&pRoot, str, strlen(str), '#');
	pNewRoot = CopyBinTree(pRoot);

	printf("前序遍歷：");
	PreOrder(pRoot);
	printf("\n");

	printf("中序遍歷：");
	InOrder(pRoot);
	printf("\n");

	printf("後序遍歷：");
	PostOrder(pRoot);
	printf("\n");

	printf("層序遍歷：");
	LevelOrder(pRoot);

	MirrorBinTree(pRoot);
	MirrorBinTreeNor(pRoot);
	printf("層序遍歷：");
	LevelOrder(pRoot);
	printf("\n");

	printf("二叉樹中結點的個數為：%d\n", BinTreeSize(pRoot));
}

2、二叉樹中葉子節點的總的個數

葉子節點：沒有孩子的節點，度為0的節點

int BinTreeLeaf(PBTNode pRoot)
{
	if (pRoot == NULL)
		return 0;
	if (NULL == pRoot->_pLeft&&NULL == pRoot->_pRight)
		//左孩子和右孩子都為空，則只有一個葉子節點
		return 1;

	return BinTreeLeaf(pRoot->_pLeft) + BinTreeLeaf(pRoot->_pRight);
}

測試程式碼：

	printf("二叉樹中葉子結點的個數為：%d\n", BinTreeLeaf(pRoot));

3、判斷一個節點是否在一棵二叉樹中

struct BinaryTree
{
    BinaryTree(char data)
    :_pLeft(NULL)
    , _pRight(NULL)
    , _data(data)
    {}
    BinaryTree *_pLeft;
    BinaryTree *_pRight;
    char _data;
};
//建立二叉樹
void CreateBinaryTree(BinaryTree *&pRoot, char *str,size_t size, size_t &index)
{
    if (index < size && str[index] != '#')
    {
        pRoot = new BinaryTree(str[index]);
        CreateBinaryTree(pRoot->_pLeft, str, size, ++index);
        CreateBinaryTree(pRoot->_pRight, str, size, ++index);
    }
}
//遞迴實現
bool IsNodeInTree(BinaryTree *pRoot,BinaryTree *pNode)
{
    if (NULL == pRoot || NULL == pNode)
        return false;
    if (pRoot->_data == pNode->_data)
        return true;
    if (IsNodeInTree(pRoot->_pLeft, pNode) || IsNodeInTree(pRoot->_pRight, pNode))
        return true;

        return false;
}

4、獲取一個節點的雙親節點

 

5、獲取一個節點的左孩子節點

 

6、獲取一個節點的右孩子節點

 

7、判斷一棵二叉樹是否為完全二叉樹（層序遍歷變形）

1>如果樹為空，則直接返回錯
2>如果樹不為空：層序遍歷二叉樹
2.1>如果一個結點左右孩子都不為空，則pop該節點，將其左右孩子入佇列；
2.1>如果遇到一個結點，左孩子為空，右孩子不為空，則該樹一定不是完全二叉樹；
2.2>如果遇到一個結點，左孩子不為空，右孩子為空；或者左右孩子都為空；則該節點之後的佇列中的結點都為葉子節點；該樹才是完全二叉樹，否則就不是完全二叉樹；

int IsCompleteBinTree(pNode pRoot)
{
	Queue q;
	int flag=0;
	if (NULL==pRoot)
		return 1;



	QueueInit(&q);
	QueuePush(&q,pRoot);


	while (!QueueEmpty(&q))
	{
		pNode pCur=QueueFront(&q);
		if (flag)
		{
			if (pCur->_pLeft||pCur->_pRight)
				return 0;

		}

		else
		{
			if (pCur ->_pLeft&&pCur->_pRight)
			{
				QueuePush(&q,pRoot->_pLeft);
				QueuePush(&q,pRoot->_pRight);
			}
			else if (pCur->_pRight)
				return 0;
			else if(pCur->_pLeft) {
				QueuePush(&q,pRoot->_pLeft);
				flag=1;
			}
			else 
				flag=1;
			QueuePop(&q);
		}
	}
	return 1;
}
bool IsCompleteTree(BinaryTreeNode *pRoot)
{
         if(pRoot == NULL)
               return false;

          queue<BinaryTreeNode*> q;
          q.push(pRoot);
          BinaryTreeNode* pCur = q.front();
          while(pCur != NULL)
          {
               q.pop();
               q.push(pCur -> left);
               q.push(pCur -> right);
               pCur = q.front();
          }

          q.pop();//把空pop出來
          //因為以經有一個空了，所以只要頭不為空就不是完全二叉樹
          while(! q.empty())
          {
               if(q.front() != NULL)
                    return false;
               q.pop();
          }
          return true;
}

 

相關推薦

搜索二叉樹應用——簡單字典實現

數據結構 搜索二叉樹 字典實現 搜索二叉樹基本概念請看上篇博客這兩個問題都是典型的K（key）V（value）問題，我們用KV算法解決。 判斷一個單詞是否拼寫正確：假設把所有單詞都按照搜索樹的性質插入到搜索二叉樹中，我們判斷一個單詞拼寫是否正確就是在樹中查找該單詞是否存在（查找key是否存在）。

二叉樹應用

#include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #define MAXSIZE 50 #define OVERFLOW -1 typedef int Status; t

[原始碼和文件分享]二叉樹應用

1 專案要求 建立一棵二叉樹 前序、中序、層次非遞迴遍歷該二叉樹 判斷該二叉樹是否為二叉排序樹 如果是二叉排序樹，進行結點的插入或刪除 輸出結果 2 解題思路 首先設計一個結構體，確定需要輸入的資料型別，再設計一個結構體，用來存放左右孩子的指標。輸入資料

資料結構之二叉樹應用（哈夫曼樹及哈夫曼編碼實現）（C++）

一、哈夫曼樹1.書上用的是靜態連結串列實現，本文中的哈夫曼樹用 排序連結串列 實現；2.實現了從 字元頻率統計、構建權值集合、建立哈夫曼樹、生成哈夫曼編碼，最後對 給定字串的編碼、解碼功能。3.使用到的 “SortedList.h”標頭檔案，在上篇博文：資料結構之排序單鏈表。

二叉樹應用_樹中兩個節點的最低公共祖先

題目：給定樹中的兩個節點，找出這兩個節點的最低公共祖先。 情況1：當給定的樹為二叉搜尋樹時。 分析：由於二叉搜尋樹是排序過的，位於左子樹的節點都小於根節點，位於右子樹的節點都大於根節點。如果要查詢的兩個節點比根節點大的話，則最低公共祖先在右子樹中；如果要查詢

LeetCode：二叉樹相關應用

div mage alt sed note col from ret 題目 LeetCode：二叉樹相關應用 基礎知識 617.歸並兩個二叉樹 題目 Given two binary trees and imagine that when you put one of th

二叉樹的應用

一、層序遍歷的應用： 映象：還需要引入佇列，同上一篇部落格。 .h # pragma once # include<assert.h> # include<malloc.h> # include<stdio.h> # include<stdlib

二叉樹的應用詳解 - 資料結構

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

6.2.2-1 【指標與引用】在二叉樹建立的應用

0 引子 　　本文旨在通過二叉樹的遞迴建立，分析指標與引用，函式形參與實參的具體實現。 　　二叉樹的遍歷，通常是利用建立好的二叉連結串列的首地址，也即根節點地址。主函式先定義一指標，再通過二叉樹建立函式返回根結點地址，或者將定義的指標作為形參來實現修改。 　　這就涉及函式形參與實參的呼叫機制。實參賦給形

【資料結構】二叉樹的應用

1、分別採用遞迴和非遞迴的方式編寫兩個函式，求一棵給定二叉樹中葉子節點的個數 2、返回一棵給定二叉樹在中序遍歷下的最後一個結點 3、假設二叉樹採用鏈式方式儲存，root為其根節點，p和q分別指向二叉樹中任意兩個結點，編寫一個函式，返回p和q最近的共同祖先。  #includ

【2018.10.10】簡單結構體二叉樹及其應用

簡單結構體二叉樹及其應用 結構體二叉樹的建立可以使用遍歷或者遞迴，各有其特點，遍歷程式碼複雜但是便於理解與閱讀，遞迴理解更復雜，但是對應程式碼量要小很多 1.首先時畫出我們一會要建立的二叉樹。說是樹可我更覺得他像一個根型結構。這個二叉樹在前序遍歷裡的結構是：ABD##E##C#F

二叉樹採用二叉連結串列儲存，複製二叉樹的演算法（樹的應用）

二叉樹採用二叉連結串列儲存，試寫出複製一棵二叉樹的演算法。 話不多說上程式碼： #include<stdio.h> #include<stdlib.h> typedef struct BiTnode   {   &

《資料結構與演算法設計》實驗報告書之二叉樹的基本操作實現及其應用

《資料結構與演算法設計》實驗報告書之二叉樹的基本操作實現及其應用 實驗專案 二叉樹的基本操作實現及其應用 實驗目的 1．熟悉二叉樹結點的結構和對二叉樹的基本操作。 2．掌握對二叉樹每一種操作的具體實現。 3．學會利用遞迴方法編寫對二叉樹這種遞迴資料結構進行處理的演算法。 4.會用二叉

二叉樹層序遍歷與獲取二叉樹深度的應用

不同於中序、前序、和後續遍歷使用棧，層序遍歷使用的是佇列！ 程式碼如下： void level_order(tree_pointer ptr){ int front = rear = 0; tree_pointer queue[MAX_QUEUE_SIZE];

SDUTOJ1291資料結構上機測試4.1:二叉樹的遍歷與應用1

以SDUTOJ1291資料結構上機測試4.1:二叉樹的遍歷與應用1為例 https://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Contest/contestproblem/cid/2711/pid/1291 思路： 遞迴實現，化解子問

演算法--分奇偶行列印二叉樹--佇列的應用

頭條的一道面試題，層序列印二叉樹，奇數行時從左到右，偶數行時從右到左。 如上所示，列印結果為 ：   1    3  2   4   5   6   7   10   9  8 1. 普通的層序列印二叉樹，一般採用一個佇列，根節點入佇列，然後一次遍歷佇列中的節

二叉樹的遍歷應用1

二叉樹的遍歷是指按某種順序訪問樹中的每個結點。由於二叉樹具有遞迴的性質，一棵非空的二叉樹可以看成是由根結點、左子樹和右子樹三部分組成，依次遍歷這3個部分的資訊，也就遍歷了二叉樹。 完全二叉樹的順序儲存轉鏈式儲存 一顆完全二叉樹存放在於一個一維陣列T【n】中，從T

二叉樹的遍歷應用2

遞迴演算法刪除二叉樹所有葉結點 若二叉樹為空，返回NULL； 若二叉樹只有一個結點，直接刪除； 否則遞迴左右子樹。 void Del(BiTNode *&t) { if(t==NULL) return; if(t->lcild==NULL&am

資料結構知識整理 - 遍歷二叉樹的應用

主要內容 建立二叉連結串列 複製二叉樹 計算二叉樹深度 統計二叉樹的結點個數   建立二叉連結串列 在先序遍歷的遞迴演算法中，將輸出語句改為輸入語句即可。(可回顧“遞迴演算法”） 需要注意的是，遞迴演算法會遍歷滿二叉樹中的每一個結點，

Leetcode 二叉樹的層次遍歷 佇列的應用

給定一個二叉樹，返回其按層次遍歷的節點值。 （即逐層地，從左到右訪問所有節點）。 例如: 給定二叉樹: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其層次遍歷結果： [ [