2. 程式人生 > >二叉樹的相關介面實現

二叉樹的相關介面實現

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

一、4.1二叉樹鏈式結構的遍歷
所謂遍歷(Traversal)是指沿著某條搜尋路線，依次對樹中每個結點均做一次且僅做一次訪問。訪問結點所做
的操作依賴於具體的應用問 題。 遍歷是二叉樹上最重要的運算之一，是二叉樹上進行其它運算之基礎。
前序/中序/後序的遞迴結構遍歷：是根據訪問結點操作發生位置命名

  1. NLR：前序遍歷(Preorder Traversal 亦稱先序遍歷)——訪問根結點的操作發生在遍歷其左右子樹之前。
  2. LNR：中序遍歷(Inorder Traversal)——訪問根結點的操作發生在遍歷其左右子樹之中（間）。
  3. LRN：後序遍歷(Postorder Traversal)——訪問根結點的操作發生在遍歷其左右子樹之後。
    由於被訪問的結點必是某子樹的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解釋為
    根、根的左子樹和根的右子樹。NLR、LNR和LRN分別又稱為先根遍歷、中根遍歷和後根遍歷。

在這裡插入圖片描述

層序遍歷：除了先序遍歷、中序遍歷、後序遍歷外，還可以對二叉樹進行層序遍歷。設二叉樹的根節點所在
層數為1，層序遍歷就是從所在二叉樹的根節點出發，首先訪問第一層的樹根節點，然後從左到右訪問第2層
上的節點，接著是第三層的節點，以此類推，自上而下，自左至右逐層訪問樹的結點的過程就是層序遍歷。

在這裡插入圖片描述

二叉樹的介面實現
1、標頭檔案

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

typedef char BTType;

typedef struct BTNode
{
	BTType _data;
	struct BTNode* _left;
	struct BTNode* _right;
}BTNode;

typedef BTNode* QUDataType;

typedef struct QueueNode
{
	QUDataType _data;
	struct QueueNode* _next;
}QueueNode;

typedef struct Queue
{
	QueueNode* _front;
	QueueNode* _rear;
}Queue;

void QueueInit(Queue* q);
void QueueDestory(Queue* q);

void QueuePush(Queue* q, QUDataType x);
void QueuePop(Queue* q);
int QueueSize(Queue* q);
int QueueEmpty(Queue* q);
QUDataType QueueFront(Queue* q);
QUDataType QueueBack(Queue* q);

typedef BTNode* STDataType;

typedef struct Stack
{
	STDataType* _a;
	int _top;
	int _capacity;
}Stack;

void StackInit(Stack* ps, int n);
void StackDestory(Stack* ps);
void StackPush(Stack* ps, STDataType x);
void StackPop(Stack* ps);
STDataType StackTop(Stack* ps);
int StackSize(Stack* ps);
int StackEmpty(Stack* ps);
void StackPrint(Stack* ps);



BTNode* CreatBTree(BTType* str, int* n);

int BinaryTreeSize(BTNode* root);//二叉樹節點個數
int BinaryTreeLeafSize(BTNode* root);//兒叉樹的葉子節點個數
int BinaryTreeLevelKSize(BTNode* root, int k);//二叉樹第k層葉子節點個數
BTNode* BinaryTreeFind(BTNode* root, BTType val);

//遞迴遍歷二叉樹
void BinaryTreePrevOrder(BTNode* root);
void BinaryTreeInOrder(BTNode* root);
void BinaryTreePostOrder(BTNode* root);
//二叉樹的層序遍歷
void BinaryTreeLevelOrder(BTNode* root);
//非遞迴遍歷二叉樹
void BinaryTreePrevOrderNonR(BTNode* root);
void BinaryTreeInOrderNonR(BTNode* root);
void BinaryTreePostOrderNonR(BTNode* root);
void Test();

2、定義檔案

#include "Tree.h"

BTNode* BuyTreeNode(BTType x)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	newnode->_data = x;
	newnode->_left = NULL;
	newnode->_right = NULL;
	return newnode;
}
BTNode* CreatBTree(BTType* arr, int* n)
{
	if (arr[*n] != '#')
	{
		BTNode* root = BuyTreeNode(arr[*n]);
		(*n)++;
		root->_left = CreatBTree(arr, n);
		(*n)++;
		root->_right = CreatBTree(arr, n);

		return root;
	}
	else
	{
		return NULL;
	}
}

int BinaryTreeSize(BTNode* root)
{
	if(root == NULL)
		return 0;
	return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1; 
}

int BinaryTreeLeafSize(BTNode* root)
{
	if(root == NULL)
		return 0;
	if(root->_left == NULL && root->_right == NULL)
		return 1;
	return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
}

int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if(root == NULL)
		return 0;
	if(root->_left == NULL && root->_right == NULL)
		return 1;
	return BinaryTreeLevelKSize(root->_left, k-1) + BinaryTreeLevelKSize(root->_right, k-1);
}

BTNode* BinaryTreeFind(BTNode* root, BTType val)
{
	BTNode* ret = NULL;
	if(root == NULL)
		return NULL;
	if(root->_data == val)
		return root;
	ret = BinaryTreeFind(root->_left,val);
	if(ret != NULL)
		return ret;
	ret = BinaryTreeFind(root->_right, val);
	if(ret != NULL)
		return ret;
	return NULL;
}


void BinaryLevelOrder(BTNode* root)
{
	Queue s;
	QueueInit(&s);
	if(root != NULL)
	{
		QueuePush(&s, root);
	}
	while(QueueEmpty(&s) == 1)
	{
		BTNode* front = QueueFront(&s);
		QueuePop(&s);
		printf("%s ", front->_data);
		if(front->_left != NULL)
		QueuePush(&s, front->_left);
		if(front->_right != NULL)
		QueuePush(&s, front->_right);
	}
	printf("\n");
}
//非遞迴前序遍歷二叉樹的思想為：a.訪問他的左路節點b.訪問左路節點的右子樹
//將所有左路節點入棧的同時並訪問，然後拿出棧頂節點，同時出棧頂節點，此時在訪問出棧節點的右孩子，
//若右孩子為空直接棧頂節點，若不為空繼續入站，訪問出棧節點的左路節點和左路節點的右子樹，

void BinaryTreePrevOrderNonR(BTNode* root)
{
	BTNode* cur = root;
	BTNode* top = NULL;
	Stack st;
	StackInit(&st, 3);
	while(cur != NULL || StackEmpty(&st) != 0)
	{
		while(cur != NULL)
		{
			printf("%c ", cur->_data);
			StackPush(&st, cur);
			cur = cur->_left;
		}
		top = StackTop(&st);
		StackPop(&st);
		cur = top->_right;
	}
	printf("\n");
}

//中序遍歷的思路和前序遍歷非遞迴很相似，也是分為左路節點和左路節點的右子樹
//首先把左路節點入棧，不訪問，當左路節點沒有左左孩子時，那出棧頂節點並且訪問，讓後出棧頂接節點
//然後把棧節點的右孩子入棧，並且繼續上面的過程。
void BinaryTreeInOrderNonR(BTNode* root)
{
	BTNode* cur = root;
	BTNode* top = NULL;
	Stack st;
	StackInit(&st, 3);
	while(cur != NULL || StackEmpty(&st) != 0)
	{
		while(cur != NULL)
		{
			StackPush(&st, cur);
			cur = cur->_left;
		}
		top = StackTop(&st);
		StackPop(&st);
		printf("%c ", top->_data);
		cur = top->_right;
	}
	printf("\n");
}

//後序遍歷的非遞迴遍歷時，要判讀它的右路節點是否已經被訪問過，如果沒有訪問過就訪問。
//首先把根節點入棧，如果根節點的左子樹和右子樹不存在，或者根節點的左子樹和右子樹已經
//訪問過，直接拿出根節點訪問，然後出棧節點，標記為上一個輸出節點的prev，在把此時的站棧頂節點
//作為當前節點，若果不滿足條件，就把根節點的左子樹和右子樹一次入棧，當前節點重置為棧頂節點，然後重複操作
void BinaryTreePostOrderNonR(BTNode* root)
{
	BTNode* top = NULL;
	BTNode* prev = NULL;
	BTNode* cur = root;
	Stack st;
	StackInit(&st,3);
	while(cur != NULL || StackEmpty(&st) != 0)
	{
		while(cur != NULL)
		{
			StackPush(&st, cur);
			cur = cur->_left;
		}
		top = StackTop(&st);
		if(top->_right == NULL || top->_right == prev)
		{
			printf("%c ",top->_data);
			StackPop(&st);
			prev = top;
		}
		else
		{
			cur = top->_right;
		}
	}
}

void BinaryTreePrevOrder(BTNode* root)
{
	if(NULL == root)
		return;
	printf("%c ", root->_data);
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);

}
void BinaryTreeInOrder(BTNode* root);
{
	if(NULL == root)
		return;
	BinaryTreeInOrder(root->_left);
	printf("%c ",root->_data);
	BinaryTreeInOrder(root->_right);
}
void BinaryTreePostOrder(BTNode* root);
{
	if(NULL == root)
		return;
	BinaryTreePostOrder(root->_left);
	BinaryTreePostOrder(root->_right);
	printf("%c ", root->_data);
}
void Test()
{
	int i = 0;
	char* arr = "ABD##E#H##CF#G##";
	BTNode* tree = CreatBTree(arr,&i);
	printf("%d\n", BinaryTreeLeafSize(tree));
	
}

相關推薦

用Python實現二叉樹相關

程式碼如下： class Node(object): """""" def __init__(self, item): self.elem = item self.lchild = None self.rchild = No

java資料結構與之二叉樹相關實現(第一篇：遍歷)

一、基本概念 每個結點最多有兩棵子樹，左子樹和右子樹，次序不可以顛倒。 性質： 非空二叉樹的第n層上至多有2^(n-1)個元素。 深度為h的二叉樹至多有2^h-1個結點。 滿二叉樹：所有終端都在同一層次，且非終端結點的度數為2。 在滿二叉

二叉樹順序結構實現的C語言

init 存儲 狀態 sta 分配 left 需要 bre oot #include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define

LeetCode：二叉樹相關應用

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

二叉樹相關

賦值 進行 n) 後序 復雜 很好 時間 葉子 style BST: 增：（插入） 　　　　? 若當前的二叉查找樹為空，則插入的元素為根節點， 　　　　? 若插入的元素值小於根節點值，則將元素插入到左子樹中， 　　　　? 若插入的元素值不小於根節點值，則將元素插入到右子樹中

搜索二叉樹之字典實現

搜索二叉樹、源碼分析、中英文字典 利用搜索二叉樹判斷一個單詞是否拼寫正確： 假設把所有單詞都按照搜索樹的性質插入到搜索二叉樹中，我們判斷一個單詞拼寫是否正確就是在樹中查找該單詞是否存在（查找key是否存在）。/***************************************** *D

簡單二叉樹相關代碼

\n include reat oid 結構 存儲空間 root node branch 1 #include <stdio.h> 2 3 typedef struct tagBinaryTree* Node; 4 typedef s

平衡二叉樹的java實現

14. bubuko 概念 tro 細心 後繼 inf 特點 演變 轉載請註明出處！ 一、概念 平衡二叉樹是一種特殊的二叉搜索樹，關於二叉搜索樹，請查看上一篇博客二叉搜索樹的java實現，那它有什麽特別的地方呢，了解二叉搜索樹的基本都清楚，在按順序向插入二叉搜索樹

js數據結構之二叉樹的詳細實現方法

eno data node left 刪除 span pan 先序遍歷 function 數據結構中，二叉樹的使用頻率非常高，這得益於二叉樹優秀的性能。 二叉樹是非線性的數據結構，用以存儲帶有層級的數據，其用於查找的刪除的性能非常高。 二叉樹 數據結構的實現方法如下：

鏈表，二叉樹相關算法的簡單整理

kmp 誰的 指針 感覺 它的 左右子樹 排序 原理 鏡像 最近在刷牛客網的劍指offer的題，感覺自己的編程能力還是很差，有時候有思路但是總是需要調試蠻久的時間，但是練習的太少。 鏈表 A->B->C->D 簡單的說單鏈表就是一個當前的節點只指向鏈表

二叉樹相關知識總結（二）

是否 integer string 根節點 color ast creat postorder ray 二叉樹的Java實現 一、分析 一個二叉樹節點包含三個部分，分別是，指向左子樹的部分，指向右子樹的部分，數據部分，如下圖所示： 我們是否可以將每個節點都抽象為一個

二叉樹遞迴實現

二叉樹遞迴實現比較符合樹的特點，也較容易理解，程式碼也較為簡單。接下來進行圖文詳解。 C程式碼下載 C++程式碼下載 java程式碼下載 ( 備用地址下載) 導航 1.建立二叉樹 2.前序遍歷二叉樹 3.中序遍歷二叉樹 4.後序遍歷二叉樹 5.層次遍歷

二叉樹資料結構實現

#include<iostream> #include<string.h> #include<vector> #include <queue> using namespace std; struct BiNode { int val; BiN

二叉樹 ADT介面 遍歷演算法 常規運算

BTree.h   (結構定義, 基本操作, 遍歷） 1 #define MS 10 2 3 typedef struct BTreeNode{ 4 char data; 5 struct BTreeNode *

PHP演算法-映象二叉樹的PHP實現

操作給定的二叉樹，將其變換為源二叉樹的映象。 二叉樹的映象定義：源二叉樹 8 / \ 6 10 / \ / \ 5 7 9 11 映象二叉樹 8

二叉樹的簡單實現

#include<iostream>#include<stdio.h>#include<malloc.h> using namespace std;#define ElemType char#define MaxSize 100 typedef struct node{

二叉樹相關概念

一. 二叉樹基本概念 在電腦科學中，二叉樹是每個結點最多有兩個子樹的樹結構。通常子樹被稱作“左子樹”（left subtree）和“右子樹”（right subtree）。二叉樹常被用於實現二叉查詢樹和二叉堆。二叉樹是每個結點最多有兩個子樹的樹結構。它有五種基本形態：二叉樹可以是空集；根可以有空的左子樹或右

與二叉樹相關的演算法筆試題集

1. 二叉搜尋樹（BST）的後序遍歷序列 2. 序列化/反序列化二叉樹 3. 找到BST中的第k小的數 4. 二叉搜尋樹轉雙鏈表 5. 找出所有節點和滿足目標數的路徑 6.根據二叉樹的前序遍歷和中序遍歷陣列來重建二叉樹 7

二叉樹的Python實現

樹的定義與基本術語   樹型結構是一類重要的非線性資料結構，其中以樹和二叉樹最為常用，是以分支關係定義的層次結構。樹結構在客觀世界中廣泛存在，如人類社會的族譜和各種社會組織機構；在計算機領域中也有廣泛應用，如在編譯程式中，可用樹來表示源程式的語法結構；在資料庫系統中，樹型結構也是資訊的重要組織形式之一；在機

二叉樹的初步實現

二叉樹的初步實現，寫了有一段時間了，先放出來，然後，有時間的話，會寫圖解以及註釋的，如果有大神發現不足之處，希望可以幫我指出來，感激不盡！ //本程式的目的是利用連結串列實現二叉樹，並且實現先序遍歷，中序遍歷，後序遍歷 #include<iostream> using namespace