[数据结构]二叉树的实现及应用

已于 2023-11-18 15:00:27 修改
阅读量70 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
于 2023-11-18 14:35:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tracier/article/details/134477808
版权

要求

编写程序，实现二叉树类及若干应用算法。
要求采用二叉链表结构，实现以下功能：
（1）构造函数：根据带空指针标记的先序遍历序列构造对象；根据先序和中序遍历序列构造对象；
（2）析构函数：释放所有结点空间；
（3）先序、中序、后序、层次遍历算法；
（4）统计叶子结点、单分支结点、双分支结点的个数；
（5）计算二叉树的高度；

（6）根据关键值查找结点；

（7）查找某个结点的父结点。

以下图二叉树为例：

带空指针的形式abd**e**cf***： 

1.先序遍历：abdecf（根->左子树->右子树）

中序遍历：dbeafc（左子树->根->右子树）

后序遍历：debfca（左子树->右子树->根）

层次遍历：abcdef（逐层遍历，从左到右依次访问每个节点）

2.叶子结点、单分支结点、双分支结点的个数分别为：3、1、2

3.高度：3

.h代码拆解

构造函数

（1）带空指针的先序序列

private:
template<class T>
BiNode<T>* BiTree<T>::CreateByPreNull(vector<T>& pre, int& i)
{
	T e = pre[i];
	i++;
	if (e == '*') return NULL;
	BiNode<T>* p = new BiNode<T>(e);
	p->lchild = CreateByPreNull(pre, i);
	p->rchild = CreateByPreNull(pre, i);

	return p;
}
public:
BiTree(vector<T>& pre)			// 由先序序列构造二叉树
{
	int i = 0;
	root = CreateByPreNull(pre, i);
}

（2）先序和中序

private:
template<class T>
BiNode<T>* BiTree<T>::CreateByPreMid(vector<T>& pre, vector<T>& mid, int ipre, int imid, int n)
{
	if (n == 0)
		return NULL;
	BiNode<T>* p = new BiNode<T>;
	p->data = pre[ipre];
	int i = 0;
	for (; i < n; i++) {
		if (pre[ipre] == mid[imid + i])
			break;
	}
	p->lchild = CreateByPreMid(pre, mid, ipre + 1, imid, i);
	p->rchild = CreateByPreMid(pre, mid, ipre + i + 1, imid + i + 1, n - i - 1);

	return p;
}
public:
template<class T>
inline BiTree<T>::BiTree(vector<T>& pre, vector<T>& mid)
{
	int n = pre.size();
	root = CreateByPreMid(pre, mid, 0, 0, n);
}

析构函数

public:
    ~BiTree() { Destory(root); }
private:
    template<class T>
    void BiTree<T>::Destory(BiNode<T>* p)
    {
	    if (p == NULL)	return;
	    Destory(p->lchild);
	    Destory(p->rchild);
	    delete p;
    }

遍历：先序、中序、后续、层次

public:
	void PreOrder() { PreOrder(root); }
	void InOrder() { InOrder(root); }
	void PostOrder() { PostOrder(root); }
	void LevelOrder() {
		if (root == NULL)	return;
		LinkQueue<BiNode<T>*> Q;
		Q.EnQueue(root);
		while (!Q.Empty()){
			auto p = Q.DeQueue();
			cout << p->data << " ";
			if (p->lchild != NULL)	Q.EnQueue(p->lchild);
			if (p->rchild != NULL)	Q.EnQueue(p->rchild);
		}
	}
private:
void PreOrder(BiNode<T>* p);
void InOrder(BiNode<T>* p);
void PostOrder(BiNode<T>* p);

template<class T>
void BiTree<T>::PreOrder(BiNode<T>* p)
{
	if (p == NULL)	return;
	cout << p->data << " ";
	PreOrder(p->lchild);
	PreOrder(p->rchild);
}

template<class T>
void BiTree<T>::InOrder(BiNode<T>* p)
{
	if (p == NULL)	return;
	InOrder(p->lchild);
	cout << p->data << " ";
	InOrder(p->rchild);
}

template<class T>
void BiTree<T>::PostOrder(BiNode<T>* p)
{
	if (p == NULL)	return;
	PostOrder(p->lchild);
	PostOrder(p->rchild);
	cout << p->data << " ";
}

统计叶子结点、单分支结点、双分支结点的个数

public:
int leafNodeCount() { return leafNodeCount(root); }
int singleNodeCount() { return singleNodeCount(root); }
int doubleNodeCount() { return doubleNodeCount(root); }

private:
template<class T>
inline int BiTree<T>::leafNodeCount(BiNode<T>* p)
{
	if (!p) return 0;
	if (p->lchild == NULL && p->rchild == NULL) return 1;
	int left = leafNodeCount(p->lchild);
	int right = leafNodeCount(p->rchild);
	return left + right;
}
template<class T>
inline int BiTree<T>::singleNodeCount(BiNode<T>* p)
{
	if (!p) return 0;
	int res = 0;
	if ((p->lchild == NULL && p->rchild) || (p->lchild && p->rchild == NULL)) res++;
	int left = singleNodeCount(p->lchild);
	int right = singleNodeCount(p->rchild);
	return left + right + res;
}
template<class T>
inline int BiTree<T>::doubleNodeCount(BiNode<T>* p)
{
	if (!p) return 0;
	int res = 0;
	if (p->lchild && p->rchild) res++;
	int left = doubleNodeCount(p->lchild);
	int right = doubleNodeCount(p->rchild);
	return res + left + right;
}

高度

public:
int Height() { return Height(root); }	

private:
template<class T>
int BiTree<T>::Height(BiNode<T>* p)
{
	if (p == NULL)	return 0;
	int left = Height(p->lchild);
	int right = Height(p->rchild);
	return max(left, right) + 1;     // #include <algorithm>
}

查找结点

private:
template<class T>
BiNode<T>* BiTree<T>::Search(BiNode<T>* p, T e){
	if (p == NULL)	return NULL;
	if (p->data == e) return p;
	BiNode<T>* q = Search(p->lchild, e);
	if (q != NULL)	return q;
	return Search(p->rchild, e);
}

public:
bool Search(T e) {
		BiNode<T>* q = Search(root, e);
		if (q == NULL)
		{
			cout << "未找到该结点" << endl;
			return false;
		}
		else
		{
			cout << "该结点为：" << q->data << endl;
			return true;
		}
	}

查找父结点

根据孩子结点的值查找

public:
bool SearchParent(T e)
	{
		BiNode<T>* q = SearchParent(root, e);
		if (q == NULL){
			cout << "该结点无父结点" << endl;
			return false;
		}
		else{
			cout << "该结点的父结点为：" << q->data << endl;
			return true;
		}
	}

private:
template<class T>
BiNode<T>* BiTree<T>::SearchParent(BiNode<T>* p, T e){
	if (p == NULL)	return NULL;
	if (p->lchild && p->lchild->data == e)	return p;
	if (p->rchild && p->rchild->data == e)	return p;
	BiNode<T>* q = SearchParent(p->lchild, e);
	if (q != NULL) return q;
	return SearchParent(p->rchild, e);
}

根据孩子结点的指针查找

private:
template<class T>
BiNode<T>* BiTree<T>::SearchParent(BiNode<T>* p, BiNode<T>* child){
	if (p == NULL || child == NULL)	return NULL;
	if (p->lchild == child || p->rchild == child)	return p;
	BiNode<T>* q = SearchParent(p->lchild, child);
	if (q != NULL) return q;
	return SearchParent(p->rchild, child);
}
public:
BiNode<T>* SearchParent(BiNode<T>* child) { return SearchParent(root, child); }

.h全部代码

#pragma once
#include <vector>
#include "LinkQueue.h"
#include <algorithm>

template <class T>
struct BiNode
{
	T data;
	BiNode<T>* lchild;
	BiNode<T>* rchild;
	BiNode() :lchild(NULL), rchild(NULL) {}
	BiNode(const T& x) :data(x), lchild(NULL), rchild(NULL) {}
};

template <class T>
class BiTree
{
private:
	BiNode<T>* root;
	void PreOrder(BiNode<T>* p);
	void InOrder(BiNode<T>* p);
	void PostOrder(BiNode<T>* p);
	BiNode<T>* CreateByPreNull(vector<T>&, int&);
	BiNode<T>* CreateByPreMid(vector<T>&, vector<T>&, int, int, int);
	void Destory(BiNode<T>* p);
	int Count(BiNode<T>* p);
	int leafNodeCount(BiNode<T>* p);
	int singleNodeCount(BiNode<T>* p);
	int doubleNodeCount(BiNode<T>* p);
	int Height(BiNode<T>* p);
	BiNode<T>* Search(BiNode<T>* p, T e);
	BiNode<T>* SearchParent(BiNode<T>* p, BiNode<T>* child);
	BiNode<T>* SearchParent(BiNode<T>* p, T e);
public:
	BiTree() { root = NULL; }
	BiTree(vector<T>& pre)			// 由先序序列构造二叉树
	{
		int i = 0;
		root = CreateByPreNull(pre, i);
	}
	BiTree(vector<T>& pre, vector<T>& mid);
	BiTree(BiTree<T>& tree);
	~BiTree() { Destory(root); }
	void PreOrder() { PreOrder(root); }
	void InOrder() { InOrder(root); }
	void PostOrder() { PostOrder(root); }
	void LevelOrder() {
		if (root == NULL)	return;

		LinkQueue<BiNode<T>*> Q;
		Q.EnQueue(root);

		while (!Q.Empty())
		{
			auto p = Q.DeQueue();
			cout << p->data << " ";

			if (p->lchild != NULL)	Q.EnQueue(p->lchild);
			if (p->rchild != NULL)	Q.EnQueue(p->rchild);
		}
	}
	int Count() { return Count(root); }					// 统计节点个数
	int leafNodeCount() { return leafNodeCount(root); }
	int singleNodeCount() { return singleNodeCount(root); }
	int doubleNodeCount() { return doubleNodeCount(root); }
	int Height() { return Height(root); }					// 计算二叉树的高度
	bool Search(T e) {
		BiNode<T>* q = Search(root, e);
		if (q == NULL)
		{
			cout << "未找到该结点" << endl;
			return false;
		}
		else
		{
			cout << "该结点为：" << q->data << endl;
			return true;
		}
	}
	BiNode<T>* SearchParent(BiNode<T>* child) { return SearchParent(root, child); }
	bool SearchParent(T e)
	{
		BiNode<T>* q = SearchParent(root, e);
		if (q == NULL)
		{
			cout << "该结点无父结点" << endl;
			return false;
		}
		else
		{
			cout << "该结点的父结点为：" << q->data << endl;
			return true;
		}
	}
};



template<class T>
void BiTree<T>::PreOrder(BiNode<T>* p)
{
	if (p == NULL)	return;
	cout << p->data << " ";
	PreOrder(p->lchild);
	PreOrder(p->rchild);
}

template<class T>
void BiTree<T>::InOrder(BiNode<T>* p)
{
	if (p == NULL)	return;
	InOrder(p->lchild);
	cout << p->data << " ";
	InOrder(p->rchild);
}

template<class T>
void BiTree<T>::PostOrder(BiNode<T>* p)
{
	if (p == NULL)	return;
	PostOrder(p->lchild);
	PostOrder(p->rchild);
	cout << p->data << " ";
}

template<class T>
BiNode<T>* BiTree<T>::CreateByPreNull(vector<T>& pre, int& i)
{
	T e = pre[i];
	i++;
	if (e == '*') return NULL;
	BiNode<T>* p = new BiNode<T>(e);
	p->lchild = CreateByPreNull(pre, i);
	p->rchild = CreateByPreNull(pre, i);

	return p;
}
template<class T>
BiNode<T>* BiTree<T>::CreateByPreMid(vector<T>& pre, vector<T>& mid, int ipre, int imid, int n)
{
	if (n == 0)
		return NULL;
	BiNode<T>* p = new BiNode<T>;
	p->data = pre[ipre];
	int i = 0;
	for (; i < n; i++) {
		if (pre[ipre] == mid[imid + i])
			break;
	}
	p->lchild = CreateByPreMid(pre, mid, ipre + 1, imid, i);
	p->rchild = CreateByPreMid(pre, mid, ipre + i + 1, imid + i + 1, n - i - 1);

	return p;
}
template<class T>
inline BiTree<T>::BiTree(vector<T>& pre, vector<T>& mid)
{
	int n = pre.size();
	root = CreateByPreMid(pre, mid, 0, 0, n);
}


template<class T>
void BiTree<T>::Destory(BiNode<T>* p)
{
	if (p == NULL)	return;
	Destory(p->lchild);
	Destory(p->rchild);
	delete p;
}

template<class T>
int BiTree<T>::Count(BiNode<T>* p)
{
	if (p == NULL)	return 0;

	int left = Count(p->lchild);
	int right = Count(p->rchild);

	return left + right + 1;
}

template<class T>
inline int BiTree<T>::leafNodeCount(BiNode<T>* p)
{
	if (!p) return 0;
	if (p->lchild == NULL && p->rchild == NULL) return 1;
	int left = leafNodeCount(p->lchild);
	int right = leafNodeCount(p->rchild);
	return left + right;
}

template<class T>
inline int BiTree<T>::singleNodeCount(BiNode<T>* p)
{
	if (!p) return 0;
	int res = 0;
	if ((p->lchild == NULL && p->rchild) || (p->lchild && p->rchild == NULL)) res++;
	int left = singleNodeCount(p->lchild);
	int right = singleNodeCount(p->rchild);
	return left + right + res;
}

template<class T>
inline int BiTree<T>::doubleNodeCount(BiNode<T>* p)
{
	if (!p) return 0;
	int res = 0;
	if (p->lchild && p->rchild) res++;
	int left = doubleNodeCount(p->lchild);
	int right = doubleNodeCount(p->rchild);
	return res + left + right;
}

template<class T>
int BiTree<T>::Height(BiNode<T>* p)
{
	if (p == NULL)	return 0;

	int left = Height(p->lchild);
	int right = Height(p->rchild);

	return max(left, right) + 1;
}

template<class T>
BiNode<T>* BiTree<T>::Search(BiNode<T>* p, T e)
{
	if (p == NULL)	return NULL;
	if (p->data == e) return p;

	BiNode<T>* q = Search(p->lchild, e);
	if (q != NULL)	return q;

	return Search(p->rchild, e);
}

template<class T>
BiNode<T>* BiTree<T>::SearchParent(BiNode<T>* p, BiNode<T>* child)
{
	if (p == NULL || child == NULL)	return NULL;

	if (p->lchild == child || p->rchild == child)	return p;

	BiNode<T>* q = SearchParent(p->lchild, child);
	if (q != NULL) return q;

	return SearchParent(p->rchild, child);
}

template<class T>
BiNode<T>* BiTree<T>::SearchParent(BiNode<T>* p, T e)
{
	if (p == NULL)	return NULL;

	if (p->lchild && p->lchild->data == e)	return p;
	if (p->rchild && p->rchild->data == e)	return p;

	BiNode<T>* q = SearchParent(p->lchild, e);
	if (q != NULL) return q;

	return SearchParent(p->rchild, e);
}

.cpp测试代码

#define _CRT_SECURE_NO_WARNINGS
#include "LinkQueue.h"
#include "BiTree.h"
#include <iostream>
#include <string>
using namespace std;//abd**e**cf***

void PrintMenu()
{
	cout << "---------------------------" << endl;
	cout << "请选择需要进行的操作" << endl;
	cout << "1. 用四种方法遍历二叉树" << endl;
	cout << "2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高" << endl;
	cout << "3. 根据关键值查找结点" << endl;
	cout << "4. 求某个结点的父节点" << endl;
	cout << "5. 退出当前操作" << endl;
	cout << "---------------------------" << endl;
}

template <class T>
void operate(BiTree<T>& BT) {
	while (1)
	{
		bool flag = true;
		PrintMenu();
		int op;	cin >> op;
		switch (op) {
		case 1:
		{
			cout << "先序遍历结果：";
			BT.PreOrder();
			cout << endl;

			cout << "中序遍历结果：";
			BT.InOrder();
			cout << endl;

			cout << "后序遍历结果：";
			BT.PostOrder();
			cout << endl;

			cout << "层序遍历结果：";
			BT.LevelOrder();
			cout << endl;
			break;
		}
		case 2:
		{
			cout << "结点总数为：" << BT.Count() << endl
				<< "叶子结点总数：" << BT.leafNodeCount() << endl <<
				"单分支结点总数：" << BT.singleNodeCount() << endl <<
				"双分支结点总数：" << BT.doubleNodeCount() << endl;
			cout << "树高为：" << BT.Height() << endl;
			break;
		}
		case 3:
		{
			cout << "输入关键值：";
			char s;	cin >> s;
			flag = BT.Search(s);
			break;
		}
		case 4:
		{
			cout << "输入结点";
			char s;	cin >> s;
			flag = BT.SearchParent(s);
			break;
		}
		case 5:
		{
			op = -1;
			break;
		}
		}

		if (!flag)
		{
			cout << "操作失败" << endl;
			cout << "---------------------------\n";
		}
		if (op == -1)	break;

		cout << endl;
	}
	return;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	while (1)
	{
		cout << "1.根据带空指针标记的先序遍历序列构造对象--------" << endl;
		cout << "2.根据先序遍历和中序遍历序列构造对象--------" << endl;
		cout << "3.退出--------" << endl;
		cout << "请输入操作:" << endl;
		int t; cin >> t;

		if (t == 1) {
			cout << "输入带空指针标记(*)的先序序列：";
			string str;	cin >> str;
			vector<char> pre;
			for (int i = 0; i < str.size(); i++)
				pre.push_back(str[i]);
			BiTree<char> BT(pre);
			operate(BT);
		}
		else if (t == 2) {
			cout << "输入先序序列和中序序列：";
			string str;	cin >> str;
			vector<char> pre;
			for (int i = 0; i < str.size(); i++)
				pre.push_back(str[i]);

			string str2;	cin >> str2;
			vector<char> mid;
			for (int i = 0; i < str2.size(); i++)
				mid.push_back(str2[i]);

			BiTree<char> BT(pre, mid);
			operate(BT);
		}
		else {
			break;
		}
	}

	return 0;
}

测试结果

1.根据带空指针标记的先序遍历序列构造对象--------
2.根据先序遍历和中序遍历序列构造对象--------
3.退出--------
请输入操作:
1
输入带空指针标记(*)的先序序列：abd**e**cf***
---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
1
先序遍历结果：a b d e c f
中序遍历结果：d b e a f c
后序遍历结果：d e b f c a
层序遍历结果：a b c d e f

---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
2
结点总数为：6
叶子结点总数：3
单分支结点总数：1
双分支结点总数：2
树高为：3

---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
3
输入关键值：a
该结点为：a

---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
4
输入结点b
该结点的父结点为：a

---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
5
1.根据带空指针标记的先序遍历序列构造对象--------
2.根据先序遍历和中序遍历序列构造对象--------
3.退出--------
请输入操作:
2
输入先序序列和中序序列：abdecf dbeafc
---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
1
先序遍历结果：a b d e c f
中序遍历结果：d b e a f c
后序遍历结果：d e b f c a
层序遍历结果：a b c d e f

---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
2
结点总数为：6
叶子结点总数：3
单分支结点总数：1
双分支结点总数：2
树高为：3

---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
3
输入关键值：f
该结点为：f

---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
3
输入关键值：p
未找到该结点
操作失败
---------------------------

---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
4
输入结点p
该结点无父结点
操作失败
---------------------------

---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
4
输入结点a
该结点无父结点
操作失败
---------------------------

---------------------------
请选择需要进行的操作
1. 用四种方法遍历二叉树
2. 计算结点总数、叶子结点总数、单分支结点数、双分支结点数和树高
3. 根据关键值查找结点
4. 求某个结点的父节点
5. 退出当前操作
---------------------------
5
1.根据带空指针标记的先序遍历序列构造对象--------
2.根据先序遍历和中序遍历序列构造对象--------
3.退出--------
请输入操作:
3

程序异常终止

可能是输入序列不正确构成二叉树的原因。#输入的数据一定要保证能构成正确的二叉树#

基本知识点总结

二叉树是一种常用的树形数据结构，它由节点（Node）组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。

1. 二叉树的基本概念：

   - 根节点（Root）：二叉树的顶层节点。

   - 叶子节点（Leaf）：没有子节点的节点。

   - 父节点（Parent）：有子节点的节点。

   - 子节点（Child）：在父节点下方的节点。

   - 兄弟节点（Sibling）：具有相同父节点的节点。

   - 深度（Depth）：从根节点到当前节点的路径长度。

   - 高度（Height）：根节点到最远叶子节点的路径长度。

2. 二叉树的分类：

   - 满二叉树：除了叶子节点外，所有节点都有两个子节点，并且所有叶子节点在同一层级上。

   - 完全二叉树：除了最后一层外，其他层节点全部填满，并且最后一层的节点从左到右依次填充。

3. 二叉树的遍历：

   - 前序遍历（Pre-order）：根节点 -> 左子树 -> 右子树。

   - 中序遍历（In-order）：左子树 -> 根节点 -> 右子树。

   - 后序遍历（Post-order）：左子树 -> 右子树 -> 根节点。

   - 层序遍历（Level-order）：逐层遍历，从左到右依次访问每个节点。

4. 二叉搜索树（Binary Search Tree，BST）：

   - 二叉搜索树是一种特殊的二叉树，它满足以下条件：

     - 左子树上的所有节点的值小于根节点的值。

     - 右子树上的所有节点的值大于根节点的值。

     - 左右子树也分别是二叉搜索树。

   - 在二叉搜索树中，查找、插入和删除操作的时间复杂度为O(log n)。

5. 平衡二叉树（Balanced Binary Tree）：

   - 平衡二叉树是一种特殊的二叉搜索树，它的左子树和右子树的高度差不超过1。

   - 常见的平衡二叉树包括红黑树、AVL树等，通过平衡操作保持树的平衡性。

6. 二叉树的应用：

   - 二叉树广泛应用于数据结构和算法中，例如排序算法、查找算法、哈夫曼编码等。

   - 表达式树（Expression Tree）：用于解析和计算数学表达式。

   - 文件系统的目录结构：每个目录都可以看作是一个节点，子目录和文件为其子节点。

Tracier
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构二叉树简单应用
08-30
本文主要介绍了C语言数据结构二叉树简单应用的相关知识点，涵盖了二叉树的创建、先中后序递归遍历、统计叶子结点的总数、求树的高度、反转二叉树、输出每个叶子结点到根节点的路径、输出根结点到每个叶子结点的路径...
数据结构学习--二叉树及其应用
06-25
二叉树是数据结构中的重要概念，它是一种特殊的树形数据结构，每个节点最多只有两个子节点，分别称为左子节点和右子节点。在本题中，我们关注的是如何在计算机中构建二叉树以及对其进行遍历。 首先，我们要理解...
二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现...
weixin_30588907的博客
09-28 317
一、基本概念 每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。 性质： 1、非空二叉树的第n层上至多有2^(n-1)个元素。 2、深度为h的二叉树至多有2^h-1个结点。 满二叉树：所有终端都在同一层次，且非终端结点的度数为2。 在满二叉树中若其深度为h，则其所包含的结点数必为2^h-1。 完全二叉树：除了最大的层次即成为一颗满二叉树且层次最大那层所有的结...
二叉树的各种遍历算法以及实例
热门推荐
大道至简，知易行难
05-25 5万+
一、二叉树 在计算机科学中，树是一种重要的非线性数据结构，直观地看，它是数据元素（在树中称为结点）按分支关系组织起来的结构。二叉树是每个节点最多有两个子树的有序树。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。值得注意的是，二叉树不是树的特殊情形。在图论中，二叉树是一个连通的无环图，并且每一个顶点的度不大于3
超好理解的哈夫曼树（最优二叉树）与例题
_C9的博客
10-27 1万+
对于比较官方的说法就是给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。 凡是涉及带权路径最短长度的问题，也就是解决一个问题需要分成几步并且这几步需要的代价很明确，我们要求最小的代价的时候，看起来像贪心的题目，我们都可以用哈夫曼树来解决，如小明决定把所有的水果合成一堆。每一次合并，小明可以把两堆水果合并到一起，消耗的体力等于两堆水果的重量之和如一块木板分割成N
数据结构——二叉树的应用
TTTSEP9TH2244的博客
01-16 2999
实验预备知识： 1. 熟练掌握二叉树的概念及5大性质。 2. 掌握二叉树的非递归遍历及递归遍历的方法。 3. 能利用二叉树的遍历解决实际问题。 4. 理解树和二叉树的含义、目的和处理方法。 一、实验目的 理解和掌握树及二叉树的类型定义方法。 定义二叉树的基本存储结构，实现基本运算 学习利用树及二叉树解决实际问题 二、实验要求 【项目1】使用队列完成层次遍历，请将代码及验证结果填入以下表格中 程序代码： main.cpp: #include <iostream> #include "btree
【数据结构】——二叉树详解
atwdy的博客
07-28 4万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
数据结构:二叉树存储结构及实现
m0_57781912的博客
09-12 1553
二叉树顺序结构存储以及堆的创建
二叉树链式结构的实现及应用
yue152152的博客
04-26 1558
文章目录前言1. 前置说明2. 二叉树的遍历2.1前序、中序及后序遍历2.1.1前序遍历代码呈现：访问顺序： 前言 建议阅读本文之前阅读一下有关二叉树的基本知识。 1. 前置说明 在学习链式二叉树的基本操作前，需先要创建一棵链式二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。 typedef int BTDataType; type
数据结构-二叉树及其应用
m0_62464074的博客
12-15 1678
实验项目名称 二叉树及其应用 实验要求 树是数据结构中应用极为广泛的非线性结构，本单元的实验达到熟悉二叉树的存储结构的特性，以及如何应用树结构解决具体问题。 实验内容 利用二叉树求解表达式的值。 算法分析 void EXTInitStack(ETLinkStack& LS)// 树栈初始化 { LS = NULL; } void EXTPush(ETLinkStack& LS, ExpTree ET)// 树栈添加元素 { ETStackNode...
头歌数据结构——二叉树及其应用
weixin_62440328的博客
11-07 6747
二叉树及其应用 第1关：实现二叉树的创建；第2关：计算二叉树的深度和节点个数；第3关：递归实现二叉树左右子树交换；第4关：非递归实现二叉树左右子树交换；第5关：层次遍历二叉树
数据结构实验报告-二叉树的存储结构的实现与应用
qq_51122012的博客
04-10 2886
按照上机实验报告模板，写出二叉树的抽象数据类型定义ADT，其他模块(如果有)和函数的功能说明，本程序包含的函数列表，函数之间的调用关系。按照教材中关于二叉树的抽象数据类型定义，采用二叉链表存储结构，编程实现二叉树的各种基本操作，并通过主函数调用，简单测试各基本函数的正确性。初始条件：二叉树 T 存在，p 指向 T 中某个结点，LR 为 0 或 1，非空二叉树 c 与 T 不相交且右子树为空。（不要用上传附件形式）(1)采用二叉链表存储结构，完成二叉树的层次遍历，先序遍历的非递归算法和中序遍历的非递归算法。
java 数据结构二叉树的实现代码
09-01
在Java中，数据结构中的二叉树是一种重要的抽象数据类型，它由节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在本文中，我们将深入探讨如何使用Java实现二叉树，并通过接口、节点类和具体实现来...
头歌数据结构二叉树的顺序存储及基本操作
05-18
头歌数据结构二叉树的顺序存储及基本操作 第1关树和二叉树基本概念 第2关二叉树的顺序存储及基本操作 在计算机科学中，二叉树是每个节点最多只有两个分支的树结构，即每个节点的分支度不大于2。通常分支被称作左...
数据结构——基于C语言实现二叉树的应用.cpp
08-11
/创建二叉树 //初始化二叉树 //创建队列 //出队 //队列判空 //入队 //先序递归遍历 //后序递归遍历 //中序递归遍历 //层次遍历
【数据结构】堆的实现和堆排序--TOP-K问题
最新发布
2301_78724721的博客
06-21 1040
在头文件中进行堆的定义和接口的声明int size;}HP;//堆的初始化//堆的销毁//堆的插入//堆的删除//取堆顶的数据// 堆的数据个数//堆的判空堆的实现堆是一种特殊的树形数据结构，通常实现为完全二叉树。堆分为最大堆和最小堆，最大堆的父节点值大于或等于其子节点值，而最小堆的父节点值小于或等于其子节点值。堆通常使用数组来实现，通过索引关系模拟树形结构，支持高效的插入、删除和查找最大/最小元素操作。堆排序堆排序是一种基于堆的排序算法。
【数据结构】顺序表
奋斗的小羊的博客
06-18 1913
顺序表超超超详解
伸展树(数据结构篇)
hellmorning的博客
06-20 735
讲解数据机构中的伸展树
数据结构二叉树的收获
12-04
二叉树是一种非常重要的数据结构，它在计算机科学中有着广泛的应用。掌握二叉树的基本概念和操作，对于提高编程能力和解决实际问题都有很大的帮助。以下是二叉树的一些收获： 1. 二叉树的定义和性质：二叉树是一种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值