实验6 二叉树操作

已于 2023-12-03 23:45:56 修改
阅读量433 收藏 6
点赞数 7
分类专栏： # 数据结构实验 文章标签： 数据结构
于 2023-12-03 22:34:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27378595/article/details/134770977
版权

0x01 实验目的

掌握二叉树的基本概念，二叉树的存储结构使用链表。

0x02 实验内容

  1. 输入一个完全二叉树的层次遍历字符串，创建这个二叉树，输出这个二叉树的前序遍历字符串、中序遍历字符串、后序遍历字符串、结点数目、二叉树高度(上述每一个结果独立一行显示)。
  2. 输入二叉树前序序列和中序序列(各元素各不相同)，创建这个二叉树，输出该二叉树的后序序列、层次遍历。

0x03 实验过程

层次遍历

判断队列是否为空的条件必须加上，因为队列为空时，有可能会通过q.front()获取到一些非NULL的奇怪的东西，然后获取其element时会报错。

void levelOrder(binaryTreeNode<E>* node) {
			queue<binaryTreeNode<E>*> q;
			while (node != NULL) {
				if(Level == 0) {
					Level++;
					cout<<node->element;
					if(node->leftChild != NULL) q.push(node->leftChild);
					if(node->rightChild != NULL) q.push(node->rightChild);
					if(!q.empty()) {
						node = q.front();
						q.pop();
					}else node = NULL; 
				} else {
					cout<<","<<node->element;
					if(node->leftChild != NULL) q.push(node->leftChild);
					if(node->rightChild != NULL) q.push(node->rightChild);
					if(!q.empty()) {
						node = q.front();
						q.pop();
					}else node = NULL; 
				}

			}
		}

层次遍历构建二叉树

先将第一个节点放入队列，之后树上每添加一个节点就要将该节点入队列。先进先出的进行添加节点操作，直到node数组空了。

template <class E>
binaryTreeNode<E>* constructTreeByLevelOrder(binaryTreeNode<E> node[],int num) {
	queue<binaryTreeNode<E>*> q;
	q.push(&node[0]);
	int i = 1;
	while(i < num) {
		binaryTreeNode<E>* current = q.front();
		q.pop();
		if(i < num) {
			current->leftChild = &node[i];
			q.push(&node[i]);
		}
		i++;
		if(i < num) {
			current->rightChild = &node[i];
			q.push(&node[i]);
		}
		i++;
	}
	return &node[0];
}

前序遍历和中序遍历构建二叉树

采用递归地形式，依次构建左子树和右子树。利用前序遍历的的第一个节点是头节点，以及在中序遍历中头结点的两侧分别为左子树和右子树这两个性质。

template<class E>
binaryTreeNode<E>* create(binaryTreeNode<E> preorder[], int p, int q, binaryTreeNode<E> inorder[], int i, int j) {
	if (p > q) return nullptr;
	if (p == q) return &preorder[p];
	int k = i;
	// 找到根节点在中序遍历序列中的位置
	while (preorder[p].element != inorder[k].element) k++;
	preorder[p].leftChild = create(preorder, p+1, p+k, inorder, i, k-1);
	preorder[p].rightChild = create(preorder, p+k+1, q, inorder, k+1, j);
	return &preorder[p];
}

改BUG

在这里插入图片描述
在这里插入图片描述

0x04 实验源码

#include<bits/stdc++.h>
using namespace std;
int in = 0;
int post = 0;
int Level = 0;
template<class T>
class binaryTreeNode {
	public:
		T element;
		binaryTreeNode<T> *leftChild,*rightChild;
		binaryTreeNode() {
			leftChild  = rightChild = NULL;
		}
		binaryTreeNode(const T& theElement) : element(theElement) {
			leftChild = rightChild = NULL;
		}
		binaryTreeNode(const T& theElement, binaryTreeNode *theLeftChild, binaryTreeNode *theRightChild):element(theElement) {
			leftChild = theLeftChild;
			rightChild = theRightChild;
		}
};
template<class E>
class linkedBinaryTree {
	public:
		linkedBinaryTree() {
			root = NULL;
			treeSize = 0;
		}
		bool empty() const {
			return treeSize == 0;
		}
		int size() const {
			return treeSize;
		}
		void setSize(int size) {
			treeSize = size;
		}
		void preOrder(binaryTreeNode<E>* node,int level) {
			if(node != NULL) {
				if(level == 0) {
					cout<<node->element;
					preOrder(node->leftChild, ++level);
					preOrder(node->rightChild, ++level);
				} else {
					cout<<","<<node->element;
					preOrder(node->leftChild, ++level);
					preOrder(node->rightChild, ++level);
				}
			}
		}
		void inOrder(binaryTreeNode<E>* node) {
			if(node != NULL) {
				if(node->leftChild == NULL && in == 0) {
					cout<<node->element;
					in++;
				} else {
					inOrder(node->leftChild);
					cout<<","<<node->element;
					inOrder(node->rightChild);
				}

			}
		}
		void postOrder(binaryTreeNode<E>* node) {
			if(node != NULL) {
				if(node->leftChild == NULL && post == 0) {
					cout<<node->element;
					post++;
				} else {
					postOrder(node->leftChild);
					postOrder(node->rightChild);
					cout<<","<<node->element;
				}
			}
		}
		void levelOrder(binaryTreeNode<E>* node) {
			queue<binaryTreeNode<E>*> q;
			while (node != NULL) {
				if(Level == 0) {
					Level++;
					cout<<node->element;
					if(node->leftChild != NULL) q.push(node->leftChild);
					if(node->rightChild != NULL) q.push(node->rightChild);
					if(!q.empty()) {
						node = q.front();
						q.pop();
					}else node = NULL; 
				} else {
					cout<<","<<node->element;
					if(node->leftChild != NULL) q.push(node->leftChild);
					if(node->rightChild != NULL) q.push(node->rightChild);
					if(!q.empty()) {
						node = q.front();
						q.pop();
					}else node = NULL; 
				}

			}
		}
		int getHeight(binaryTreeNode<E>* node) {
			if(node == NULL) return 0;
			int h1 = getHeight(node->leftChild);
			int h2 = getHeight(node->rightChild);
			if(h1 > h2) {
				return ++h1;
			} else {
				return ++h2;
			}
		}
	private:
		binaryTreeNode<E> *root;
		int treeSize;
};
template <class E>
binaryTreeNode<E>* constructTreeByLevelOrder(binaryTreeNode<E> node[],int num) {
	queue<binaryTreeNode<E>*> q;
	q.push(&node[0]);
	int i = 1;
	while(i < num) {
//		cout<<"q.front()"<<q.front()<<endl;
//		cout<<"&q.front()"<<&q.front()<<endl;
//		cout<<"node[0]"<<&node[0]<<endl;
//		cout<<"node[0]"<<&node<<endl;
		binaryTreeNode<E>* current = q.front();
		q.pop();
		if(i < num) {
			current->leftChild = &node[i];
//			cout<<current->leftChild->element<<endl;
//			cout<<node[0].leftChild->element<<endl;
			q.push(&node[i]);
		}
		i++;
		if(i < num) {
			current->rightChild = &node[i];
			q.push(&node[i]);
		}
		i++;
	}
	return &node[0];
}
template<class E>
binaryTreeNode<E>* create(binaryTreeNode<E> preorder[], int p, int q, binaryTreeNode<E> inorder[], int i, int j) {
	if (p > q) return nullptr;
	if (p == q) return &preorder[p];
	int k = i;
	// 找到根节点在中序遍历序列中的位置
	while (preorder[p].element != inorder[k].element) k++;
	preorder[p].leftChild = create(preorder, p+1, p+k, inorder, i, k-1);
	preorder[p].rightChild = create(preorder, p+k+1, q, inorder, k+1, j);
	return &preorder[p];
}
int main() {
  //两种写法都可以。
	//binaryTreeNode<char> *node = new binaryTreeNode<char>[100];
	binaryTreeNode<char> node[100];
	string s;
	cout<<"Input1"<<endl;
	cin>>s;
	for(int i = 0; i < s.length(); i++) {
		binaryTreeNode<char> n(s.at(i));
		node[i] = n;
	}
	linkedBinaryTree<char> tree;
	constructTreeByLevelOrder(node,s.length());
	tree.setSize(s.length());
//	node[0].leftChild = &node[1];
//	node[0].rightChild = &node[2];
//  cout<<"preOrder"<<endl;
//  记录层数，方便输出逗号
	int level = 0;
	cout<<"Output1"<<endl;
//	cout<<node[0].element<<endl;
//	cout<<node[0].leftChild<<endl;
	tree.preOrder(&node[0],level);
	cout<<endl;
	tree.inOrder(&node[0]);
	in = 0;
	cout<<endl;
	tree.postOrder(&node[0]);
	post = 0;
	cout<<endl;
	cout<<tree.size()<<endl;
	cout<<tree.getHeight(&node[0])<<endl;

//	tree.constructTreeByLevelOrder(node,length);
//	tree.inOrder();
//	cout<<2<<node[0].element<<node[0].leftChild->element;
	cout<<"Input2"<<endl;
	string s1,s2;
	cin>>s1>>s2;
	binaryTreeNode<char> node1[100];
	binaryTreeNode<char> node2[100];
	for(int i = 0; i < s1.length(); i++) {
		binaryTreeNode<char> n(s1.at(i));
		node1[i] = n;
	}
	int noting;
	for(int i = 0; i < s2.length(); i++) {
		binaryTreeNode<char> n(s2.at(i));
		node2[i] = n;
		if(s2.at(i) == s1.at(0)) noting = i;
	}
	//constructTreeByPreOrderAndInOrder(node1, node2, s1.length(), s2.length(), noting);
	cout<<"Output2"<<endl;
	create(node1, 0, s1.length()-1, node2, 0, s2.length()-1);
//	tree.preOrder(&node1[0],level);
//	cout<<endl;
//	tree.inOrder(&node1[0]);
//	cout<<endl;
	tree.postOrder(&node1[0]);
	cout<<endl;
	tree.levelOrder(&node1[0]);
	cout<<endl;
	cout<<"End"<<endl;
	return 0;
}

0x05 错误代码

#include<bits/stdc++.h>
using namespace std;
int in = 0;
int post = 0;
int Level = 0;
template<class T>
class binaryTreeNode {
	public:
		T element;
		binaryTreeNode<T> *leftChild,*rightChild;
		binaryTreeNode() {
			leftChild  = rightChild = NULL;
		}
		binaryTreeNode(const T& theElement) : element(theElement) {
			leftChild = rightChild = NULL;
		}
		binaryTreeNode(const T& theElement, binaryTreeNode *theLeftChild, binaryTreeNode *theRightChild):element(theElement) {
			leftChild = theLeftChild;
			rightChild = theRightChild;
		}
};
template<class E>
class linkedBinaryTree {
	public:
		linkedBinaryTree() {
			root = NULL;
			treeSize = 0;
		}
		bool empty() const {
			return treeSize == 0;
		}
		int size() const {
			return treeSize;
		}
		void setSize(int size) {
			treeSize = size;
		}
		void preOrder(binaryTreeNode<E>* node,int level) {
			if(node != NULL) {
				if(level == 0) {
					cout<<node->element;
					preOrder(node->leftChild, ++level);
					preOrder(node->rightChild, ++level);
				} else {
					cout<<","<<node->element;
					preOrder(node->leftChild, ++level);
					preOrder(node->rightChild, ++level);
				}
			}
		}
		void inOrder(binaryTreeNode<E>* node) {
			if(node != NULL) {
				if(node->leftChild == NULL && in == 0) {
					cout<<node->element;
					in++;
				} else {
					inOrder(node->leftChild);
					cout<<","<<node->element;
					inOrder(node->rightChild);
				}

			}
		}
		void postOrder(binaryTreeNode<E>* node) {
			if(node != NULL) {
				if(node->leftChild == NULL && post == 0) {
					cout<<node->element;
					post++;
				} else {
					postOrder(node->leftChild);
					postOrder(node->rightChild);
					cout<<","<<node->element;
				}
			}
		}
		void levelOrder(binaryTreeNode<E>* node) {
			queue<binaryTreeNode<E>*> q;
			while (node != NULL) {
				if(Level == 0) {
					Level++;
					cout<<node->element;
					if(node->leftChild != NULL) q.push(node->leftChild);
					if(node->rightChild != NULL) q.push(node->rightChild);
					node = q.front();
					q.pop();
				} else {
					cout<<","<<node->element;
					if(node->leftChild != NULL) q.push(node->leftChild);
					if(node->rightChild != NULL) q.push(node->rightChild);
					node = q.front();
					q.pop();
				}

			}
		}
		int getHeight(binaryTreeNode<E>* node) {
			if(node == NULL) return 0;
			int h1 = getHeight(node->leftChild);
			int h2 = getHeight(node->rightChild);
			if(h1 > h2) {
				return ++h1;
			} else {
				return ++h2;
			}
		}
	private:
		binaryTreeNode<E> *root;
		int treeSize;
};
template <class E>
binaryTreeNode<E>* constructTreeByLevelOrder(binaryTreeNode<E> node[],int num) {
	queue<binaryTreeNode<E>*> q;
	q.push(&node[0]);
	int i = 1;
	while(i < num) {
//		cout<<"q.front()"<<q.front()<<endl;
//		cout<<"&q.front()"<<&q.front()<<endl;
//		cout<<"node[0]"<<&node[0]<<endl;
//		cout<<"node[0]"<<&node<<endl;
		binaryTreeNode<E>* current = q.front();
		q.pop();
		if(i < num) {
			current->leftChild = &node[i];
//			cout<<current->leftChild->element<<endl;
//			cout<<node[0].leftChild->element<<endl;
			q.push(&node[i]);
		}
		i++;
		if(i < num) {
			current->rightChild = &node[i];
			q.push(&node[i]);
		}
		i++;
	}
	return &node[0];
}
template <class E>
//左子树的实现 
binaryTreeNode<E>* soul(int noting, binaryTreeNode<E> node1[], binaryTreeNode<E> node2[]) {
	int index1 = 100;
	int index2 = 100;
	for(int i = 1; i <= noting; i++) {
		for(int j = noting; j >= 0; j--) {
			if(node1[i].element == node2[j].element) {
				index1 = index2;
				index2 = j;
				cout<<"index1"<<index1<<endl;
				cout<<"index2"<<index2<<endl;
			}
		}
		if(index1 > index2) {
			node1[i-1].leftChild = &node1[i];
		} else {
//			cout<<"Yes"<<endl;
			for(int j = noting; j >= 0; j--) {
				if(node1[i].element == node2[j].element) {
					for(int k = noting; k >= 0; k--) {
						if(node2[j-1].element == node1[k].element) {
							node1[k].rightChild = &node1[i];
						}
					}
				}
			}
		}
	}
	return &node1[0];
}
template <class E>
binaryTreeNode<E>* constructTreeByPreOrderAndInOrder(binaryTreeNode<E> node1[], binaryTreeNode<E> node2[], int num1, int num2, int noting) {
	soul(noting, node1, node2);
	int temp;
	//获取下一个左子树区间 
	for(int i = noting + 1; i < num1; i++) {
		if(node2[i].element == node1[noting+1].element) {
			temp = noting;
			noting = i;
		}
	}
	do {
		//重复操作，直到剩下最后一个元素，或者不剩下元素，退出循环 
		int num = 0;
		binaryTreeNode<char> node3[100];
		binaryTreeNode<char> node4[100];
		for(int i = temp + 1; i <= noting; i++) {
			node3[num] = node1[i];
			node4[num] = node2[i];
			num++;
		}
		soul(noting, node3, node4);
		for(int i = noting + 1; i < num1; i++) {
			if(node2[i].element == node1[noting+1].element) {
				temp = noting;
				noting = i;
			}
		}
	} while(noting + 1 != num1 - 1 && noting + 1 != num1);
	//如果剩一个元素 
	if(noting + 1 == num1 - 1) node2[num1 - 1].rightChild = &node2[num1];
	return &node1[0];
}
int main() {
	//binaryTreeNode<char> *node = new binaryTreeNode<char>[100];
	binaryTreeNode<char> node[100];
	string s;
	cout<<"Input"<<endl;
	cin>>s;
	for(int i = 0; i < s.length(); i++) {
		binaryTreeNode<char> n(s.at(i));
		node[i] = n;
	}
	linkedBinaryTree<char> tree;
	constructTreeByLevelOrder(node,s.length());
	tree.setSize(s.length());
//	node[0].leftChild = &node[1];
//	node[0].rightChild = &node[2];
//  cout<<"preOrder"<<endl;
//  记录层数，方便输出逗号
	int level = 0;
	cout<<"Output"<<endl;
//	cout<<node[0].element<<endl;
//	cout<<node[0].leftChild<<endl;
	tree.preOrder(&node[0],level);
	cout<<endl;
	tree.inOrder(&node[0]);
	in = 0;
	cout<<endl;
	tree.postOrder(&node[0]);
	post = 0;
	cout<<endl;
	cout<<tree.size()<<endl;
	cout<<tree.getHeight(&node[0])<<endl;

//	tree.constructTreeByLevelOrder(node,length);
//	tree.inOrder();
//	cout<<2<<node[0].element<<node[0].leftChild->element;
	cout<<"Input2"<<endl;
	string s1,s2;
	cin>>s1>>s2;
	binaryTreeNode<char> node1[100];
	binaryTreeNode<char> node2[100];
	for(int i = 0; i < s1.length(); i++) {
		binaryTreeNode<char> n(s1.at(i));
		node1[i] = n;
	}
	int noting;
	for(int i = 0; i < s2.length(); i++) {
		binaryTreeNode<char> n(s2.at(i));
		node2[i] = n;
		if(s2.at(i) == s1.at(0)) noting = i;
	}
	constructTreeByPreOrderAndInOrder(node1, node2, s1.length(), s2.length(), noting);
	cout<<"Output2"<<endl;
	tree.preOrder(&node1[0],level);
	cout<<endl;
	tree.inOrder(&node1[0]);
	cout<<endl;
	tree.postOrder(&node1[0]);
	cout<<endl;
	tree.levelOrder(&node1[0]);
	cout<<endl;
	return 0;
}
Java~~
关注
  • 7
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树链表作为存储按层遍历c语言,建立二叉树的二叉链表表示，实现二叉树的先序、中序、后序和按层次遍历，统计并输出结点个数。1）采用二叉链表存储结构建立二叉树，从键盘按先序输入二叉树的结点序列。如，建立...
weixin_39922929的博客
05-24 2033
typedef struct node{char data;struct node *lchild,*rchild;}bitree;bitree *root=NULL;//创建树bitree *CreateTree(char *sInPut){bitree *root,*s;bitree *Q[128];int front,rear;root=NULL;front=1;rear=0;char te...
（数据结构）二叉树的建立与遍历
jiang5086的博客
04-30 1026
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 在学习了二叉树之后，对二叉树的概念还处于比较懵的状态，下面就一项实验报告来具体实现二叉树，目的是为了掌握二叉树的定义，并且实现二叉树的链式存储结构以及在链式存储结构中的三种遍历（前序、中序、后序）。 提示：以下是本篇文章正文内容，下面案例可供参考 一、什么是二叉树？ 二叉树（binary tree）是一个有限的结点集合，这个集合或则为空，或则由一个根结点和两颗互不相交的称为左子树（left subt.
后序建立二叉树
Ruanes的博客
02-09 3091
试题描述 采用用户输入元素并基于后序遍历的方式创建一个包含6个节点的二叉链表树，基于遍历和交换，确保任何父节点的元素值不小于子节点。要求在遍历函数中采用函数指针。采用后序的方法输出二叉树的节点 样例输出 …CFD…BEA 样例输出 F D B E C A 应该是反了，正确是A C E B D F 这道题的难点是需要从叶子节点进行回溯比较,我还没有想到比较简单的做法，欢迎交流。 算法思路： 1.后...
二叉树的基本操作
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
二叉树基本操作实验
CS@zeny的博客
11-20 1225
数据结构(实验报告)–二叉树 二叉树的基本操作 实验目的： 理解二叉树的定义 掌握二叉树的链式存储结构 掌握二叉树基本操作的递归算法 实验内容： 先序创建二叉树； 分别实现二叉树的先序、中序、后序递归遍历； 如果将空孩子显示为‘#’,实现二叉树的先序递归遍历 统计二叉树的结点数和叶结点数（写在同一个函数里）； 计算二叉树的深度； 交换二叉树的左右子树； 销毁二叉树。 实验代码 #include <stdio.h> #include <malloc.h&g
实验五_二叉树操作
沉远的博客
11-23 529
1. 求二叉树深度，判断树是否为空时，不能直接「 if(T) 」，否则会导致函数没有返回值。要在判断树为空时，返回0，保证函数有返回值。 2. 计算叶子数和节点数时，要用全局变量 LEAFCOUNT 和 NODECOUNT ，因为该变量不仅在函数中要使用，在主函数中也要使用。 3. 注意先、中、后序遍历的英文缩写（PreOrder，InOrder，PostOrder），要规范。
数据结构实验——二叉树相关操作
05-13
本人本科期间数据结构二叉树的实验 1、建立二叉树的存储结构 2、先序、中序、后序遍历二叉树（要求任选某一种用非递归算法完成） 3、查询二叉树中某个结点 4、统计二叉树中叶子结点的个数 5、求二叉树的深度 6、要求...
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
实验6 二叉树.pdf
11-12
二叉树的遍历是二叉树操作的核心，主要包括先序遍历、中序遍历、后序遍历和层次遍历。这四种遍历方式分别有不同的应用场景，例如先序遍历常用于复制一棵树，中序遍历常用于构造排序序列，后序遍历常用于计算表达式树...
实验6 二叉树.docx
11-12
二叉树的遍历是理解和操作二叉树的关键。实验要求你实现递归和非递归的先序、中序、后序遍历，以及层次遍历。这些遍历方法如下： 1. 先序遍历（根-左-右）： - 递归：访问根节点，然后递归遍历左子树和右子树。 -...
实验六 二叉树操作.pdf
11-12
这个实验不仅锻炼了我们对二叉树基本概念的理解，还强化了我们利用数组实现二叉树操作的技能，这对于在实际的编程和算法设计中处理树形结构的问题至关重要。通过这样的实践，我们可以更好地理解和应用二叉树的性质，...
二叉树根据输入字符进行层次创建以及层次遍历
cendien的博客
09-16 2518
用户输入相应的节点数据对二叉树的节点进行定义， 以‘#’代表空节点，以‘*’代表二叉树构建完成 图片中第一行为输入数据，第二行为中序遍历的结果，第三行为层次遍历的结果。 以下为样例代码： #include<iostream> #include<queue> using namespace std; class Node { public: char d...
数据结构——二叉树
mankeywang的博客
11-07 1052
文章目录1. 树2. 二叉树2.2 二叉树的性质满二叉树完全二叉树2.3二叉树的遍历前序遍历中序遍历后序遍历二叉树的建立递归遍历算法先序遍历算法中序遍历算法后序遍历算法遍历算法的分析非递归遍历算法复制二叉树计算二叉树的深度计算二叉树的结点数计算二叉树的叶子结点数2.4 线索二叉树3. 森林3.1 树的存储结构双亲表示法孩子链表表示法孩子兄弟表示法把树树转成二叉树森林转化为二叉树二叉树转换回森林3.2 树的遍历4. 哈斯曼树4.1 哈斯曼树的构造哈斯曼树的算法实现哈斯曼编码哈斯曼编码的代码实现 1. 树
数据结构算法常见面试考题
热门推荐
Zuoerfeng
11-08 13万+
（1） 红黑树的了解（平衡树，二叉搜索树），使用场景 把数据结构上几种树集中的讨论一下： 1.AVLtree 定义：最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 节点的平衡因子是它的左子树的高度减去它的右子树的高度（有时相反）。...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 165
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 213
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构---二叉树
weixin_47808575的博客
07-22 295
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值