数据结构与算法-二叉树快速入门

最新推荐文章于 2024-08-10 20:39:42 发布

小林卡比

最新推荐文章于 2024-08-10 20:39:42 发布

阅读量302

点赞数 1

分类专栏：数据结构与算法二叉树文章标签：数据结构与算法二叉树遍历

本文链接：https://blog.csdn.net/jty123456/article/details/82635216

版权

数据结构与算法同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

二叉树

1 篇文章 0 订阅

订阅专栏

简介

二叉树是一种非常重要的非线性结构，比较适合用于计算机处理，而且任何树和森林都可以转换为二叉树。

文章目录

简介
定义
五种基本形态
性质
整体实现

定义

一棵二叉树 $T 是 n (n \geq 0)$ 个结点的有限集合。当 $n = 0$ 时，它是一棵空二叉树；当 $n > 0$ 时,它由一个根节点和两棵分别称为左子树和右子树且互不相交的二叉树组成。
二叉树的递归定义如下：
$T=\left\{\begin{array}{cc} ∅, & n=0\\ \{root,T_L,T_R\}, & n>0 \end{array}\right.$
其中root表示T的根， $T_L$ 表示T的左子树， $T_R$ 表示T的右子树， $T_L$ 、 $T_R$ 仍是二叉树。
>二叉树中即使只有一棵子树也要进行区分，说明它是左子树，还是右子树，这时二叉树与树的最主要的区别。~~二叉树就是结点度为2的树~~是错误的！

五种基本形态

(a):空树 $\emptyset$
(b):只有根节点 (b)
©:只有左子树 (c)
(d):只有右子树 (d)
(e):既有左子树，又有右子树 (e)

性质

在二叉树的第 $i (i \geq 1)$ 层上之多有 $2^{i-1}$ 个结点。
深度为 $k (k \geq 1)$ 的二叉树之多有 $2^k-1$ 个结点。
对任何一棵非空二叉树，如果其叶子结点数为 $n_0$ ，度为 $2$ 的节点数为 $n_2$ ，则 $n_0=n_2+1$ 。
具有 $n (n > 0)$ 个结点的***完全二叉树***的深度为 $log_2n+1⌋$ 。
如果将一棵有 $n$ 个结点的完全二叉树按照自顶向下，同一层自左向右**的顺序连续给结点编号 $1, 2, 3, . . ., n$ ，然后按此结点编号将树中各结点顺序地存放于一个一维数组中，并简称编号为 $i$ 的结点为结点 $i (1 \leq i \leq n)$ 。则有以下关系：

(1)若 $i = 1$ ,则结点 $i$ 为根，无双亲结点；若 $i > 1$ , 则 $i$ 的双亲结点为结点 $└ i / 2 ┘$ 。
(2)若 $2 i \leq n$ , 则结点 $i$ 的左孩子为结点 $2 i$ ；否则结点 $i$ 无左孩子。
(3)若 $2 i + 1 \leq n$ , 则结点 $i$ 的右孩子为结点 $2 i + 1$ ，否则，结点 $i$ 无右孩子。

#遍历方式

遍历二叉树：指遵从某种顺序，顺着某一条搜索路径访问二叉树中的各个结点，使得每个结点均被访问一次，而且仅被访问一次。
访问：输出结点的信息、修改结点的数据值等，但一般要求这种访问不破坏原来数据之间的逻辑结构。

先序遍历

也称为前序遍历，按照“根-左子树-右子树”的次序遍历二叉树。（递归）
如果二叉树为空，则遍历结束；否则：

访问根节点( D )；
先序遍历左子树( L )；
先序遍历右子树( R )。

void preTraverse(BiTree T) {
	if (T) {
		cout << T->data << " ";
		preTraverse(T->lchild);
		preTraverse(T->rchild);
	}
}

中序遍历

按照“左子树-根-右子树”的次序遍历二叉树。（递归）
如果二叉树为空，则遍历结束；否则：

中序遍历左子树( L )；
访问根节点( D )；
中序遍历右子树( R )。

void midTraverse(BiTree T) {
	if (T) {
		midTraverse(T->lchild);
		cout << T->data << " ";
		midTraverse(T->rchild);
	}
}

后序遍历

按照“左子树-右子树-根”的次序遍历二叉树。（递归）
如果二叉树为空，则遍历结束；否则：

后序遍历左子树( L )；
后序遍历右子树( R )。
访问根节点( D )；

void postTraverse(BiTree T) {
	if (T) {
		postTraverse(T->lchild);
		postTraverse(T->rchild);
		cout << T->data << " ";
	}
}

层次遍历

按照二叉树的层次，从上到下、从左到右的次序访问各节点。（队列）
层次遍历从二叉树的根节点开始，首先将根结点指针入队，然后从队头取出一个数据元素执行以下操作：

访问该指针所指结点；
若该指针所指结点的左、右孩子结点不空，则将其左孩子指针和右孩子指针入队；
重复上述1、2两个步骤，直至队列为空。

void levelTraverse(BiTree T) {
	BiTree bt;
	LinkQuene q;
	if (T) {
		q.EnQuene(T);
		while (q.QueneEmpty()) {
			bt = q.DeQuene();
			if (bt)
				cout << bt->data << " ";
			if (bt->lchild)
				q.EnQuene(bt->lchild);
			if (bt->rchild)
				q.EnQuene(bt->rchild);
		}
	}
}

整体实现

#include "pch.h"
#include <iostream>
#include <stdlib.h>
#define ElemType BiTree 
#define ERROR -1
#define OK 0
using namespace std;

//二叉树结点
typedef struct node {
	struct node *lchild;
	struct node *rchild;
	char data;
} BiTreeNode, *BiTree;

struct Node {
	ElemType data;
	Node* next;
};

class LinkQuene {
private:
	Node* front;
	Node* rear;
public:
	LinkQuene();
	~LinkQuene();
	int EnQuene(ElemType);
	ElemType DeQuene();
	int QueneEmpty();
};

LinkQuene::LinkQuene() {
	front = new Node;
	front->next = NULL;
	rear = front;
	//rear->next=NULL; 
}

LinkQuene::~LinkQuene() {
	Node *p;
	while (front) {
		p = front;
		front = front->next;
		delete p;
	}
}

int LinkQuene::EnQuene(ElemType c) {
	Node *p;
	p = new Node;
	p->data = c;
	p->next = NULL;
	rear->next = p;
	rear = p;
	if (front->next == NULL)
		front->next = p;
	return OK;
}

ElemType LinkQuene::DeQuene() {
	Node *p;
	ElemType c;
	if (rear == front) {
		cout << "?????";
		return NULL;
	}
	p = front->next;
	c = p->data;
	front->next = p->next;
	if (p->next = NULL)
		front = rear;
	delete p;
	return c;
}


int LinkQuene::QueneEmpty() {
	int i = 0;
	if (front->next != NULL)
		i = 1;
	return i;
}

//前序遍历
void preTraverse(BiTree T) {
	if (T) {
		cout << T->data << " ";
		preTraverse(T->lchild);
		preTraverse(T->rchild);
	}
}
//中序遍历
void midTraverse(BiTree T) {
	if (T) {
		midTraverse(T->lchild);
		cout << T->data << " ";
		midTraverse(T->rchild);
	}
}
//后序遍历
void postTraverse(BiTree T) {
	if (T) {
		postTraverse(T->lchild);
		postTraverse(T->rchild);
		cout << T->data << " ";
	}
}

//层次遍历
void levelTraverse(BiTree T) {
	BiTree bt;
	LinkQuene q;
	if (T) {
		q.EnQuene(T);
		while (q.QueneEmpty()) {
			bt = q.DeQuene();
			if (bt)
				cout << bt->data << " ";
			if (bt->lchild)
				q.EnQuene(bt->lchild);
			if (bt->rchild)
				q.EnQuene(bt->rchild);
		}
	}
}

int maxDepth(BiTree T) {
	if (T == nullptr)
		return 0;
	int leftDepth, rightDepth;
	//分别计算左子树和右子树的深度
	leftDepth = maxDepth(T->lchild) + 1;
	rightDepth = maxDepth(T->rchild) + 1;

	return leftDepth > rightDepth ? leftDepth : rightDepth;
}

void createBiTree(BiTree &T) {
	char c;
	cin >> c;
	if ('#' == c)
		T = NULL;
	else {
		T = new BiTreeNode;
		T->data = c;
		createBiTree(T->lchild);
		createBiTree(T->rchild);
	}
}

int main() {
	BiTree T;
	createBiTree(T);
	cout << "创建完成！" << endl;
	cout << "前序遍历：" << endl;
	preTraverse(T);
	cout << endl;
	cout << "中序遍历：" << endl;
	midTraverse(T);
	cout << endl;
	cout << "后序遍历：" << endl;
	postTraverse(T);
	cout << endl;
	cout << "层次遍历：" << endl;
	levelTraverse(T);
	cout << endl << "共有" << MaxDepth(T) << "层";
	return 0;
}