学习笔记-数据结构与算法之二叉树

最新推荐文章于 2024-08-22 10:44:26 发布
最新推荐文章于 2024-08-22 10:44:26 发布
阅读量412 收藏
点赞数
分类专栏： 编程 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TI__boyue/article/details/116333623
版权

目录

二叉树

// 孩子兄弟表示法
typedef char elemtype;
typedef struct tree_node {
	elemtype data;
	struct tree_node *first_child, *right_sib;
}tree_node, *link_tree_node;

建立

交互式

#include<iostream>
using namespace std;
#include<math.h>
#include<stdlib.h>
#include<string>

// 孩子兄弟表示法
typedef char elemtype;
typedef struct tree_node {
	elemtype data;
	struct tree_node *first_child, *right_sib;
}tree_node, *link_tree_node;

void create_bi_tree(link_tree_node& head);
void pre_order_traverse(link_tree_node head);

int main() {
	string chars = "ab#d##c##";// 先序遍历序列
	cout << chars.length() << endl;

	link_tree_node head;
	create_bi_tree(head);
	pre_order_traverse(head);
	system("pause");
	return 0;
}
// 注意点 以 引用方式传递；
void create_bi_tree(link_tree_node& head) {
	elemtype temp;
	cout << "输入当前树根节点" << endl;
	cin >> temp;
	if (temp != '#') {
		head = new tree_node;
		if (!head) exit(OVERFLOW);
		head->data = temp;
		create_bi_tree(head->first_child);// 左树
		create_bi_tree(head->right_sib); // 右树
	}
	else head = NULL;
}
void pre_order_traverse(link_tree_node head) {
	if (head == NULL) return;
	cout << head->data << ' ';
	pre_order_traverse(head->first_child);
	pre_order_traverse(head->right_sib);
}

静态

#include<iostream>
using namespace std;
#include<math.h>
#include<stdlib.h>
#include<string>

// 孩子兄弟表示法
typedef char elemtype;
typedef struct tree_node{
	elemtype data;
	struct tree_node *first_child,*right_sib;
}tree_node,*link_tree_node;

void create_bi_tree(link_tree_node& head,string chars,int serial=1);
void pre_order_traverse(link_tree_node head);
int main(){
	string chars=" abcdefg########"; // 层序遍历 以满二叉树为准
	link_tree_node head;
	cout<<"满二叉树层序序列:"<<chars<<endl;
	create_bi_tree(head,chars,1);
	cout<<"先序遍历递归算法"<<endl;
	pre_order_traverse(head);
	return 0;
}

void create_bi_tree(link_tree_node& head,string chars,int serial){
	if(chars[serial]!='#'){
		head = new tree_node;
		if(!head) exit(OVERFLOW);
		head->data = chars[serial];	
		create_bi_tree(head->first_child,chars,2*serial);// 左树
		create_bi_tree(head->right_sib,chars,2*serial+1); // 右树
	}
	else head = NULL;
}
void pre_order_traverse(link_tree_node head){
	if(head == NULL) return ;
	cout<<head->data<<' ';
	pre_order_traverse(head->first_child);
	pre_order_traverse(head->right_sib);
}

遍历

递归式

先序

// 先序遍历 DLR
void pre_order_traverse(link_tree_node head){
	if(head == NULL) return ;
	cout<<head->data<<' ';
	pre_order_traverse(head->first_child);
	pre_order_traverse(head->right_sib);
}

中序

// 中序遍历 LDR
void mid_order_traverse(link_tree_node head){
	if(head == NULL) return ;
	mid_order_traverse(head->first_child);
	cout<<head->data<<' ';
	mid_order_traverse(head->right_sib);
}

后序

// 后序遍历 LRD
void back_order_traverse(link_tree_node head){
	if(head == NULL) return ;
	back_order_traverse(head->first_child);
	back_order_traverse(head->right_sib);
	cout<<head->data<<' ';
}

整体代码

#include<iostream>
using namespace std;
#include<math.h>
#include<stdlib.h>
#include<string>

// 孩子兄弟表示法
typedef char elemtype;
typedef struct tree_node{
	elemtype data;
	struct tree_node *first_child,*right_sib;
}tree_node,*link_tree_node;

void create_bi_tree(link_tree_node& head,string chars,int serial=1);
void pre_order_traverse(link_tree_node head);
void mid_order_traverse(link_tree_node head);
void back_order_traverse(link_tree_node head);
int main(){
	string chars=" abcdefg########"; // 层序遍历 以满二叉树为准
	link_tree_node head;
	cout<<"满二叉树层序序列:"<<chars<<endl;
	create_bi_tree(head,chars,1);
	cout<<"先序遍历递归算法"<<endl;
	pre_order_traverse(head);
	cout<<endl;
	cout<<"中序遍历递归算法"<<endl;
	mid_order_traverse(head);
	cout<<endl;
	cout<<"后序遍历递归算法"<<endl;
	back_order_traverse(head);
	return 0;
}

void create_bi_tree(link_tree_node& head,string chars,int serial){
	if(chars[serial]!='#'){
		head = new tree_node;
		if(!head) exit(OVERFLOW);
		head->data = chars[serial];	
		create_bi_tree(head->first_child,chars,2*serial);// 左树
		create_bi_tree(head->right_sib,chars,2*serial+1); // 右树
	}
	else head = NULL;
}
// 先序遍历 DLR
void pre_order_traverse(link_tree_node head){
	if(head == NULL) return ;
	cout<<head->data<<' ';
	pre_order_traverse(head->first_child);
	pre_order_traverse(head->right_sib);
}
// 中序遍历 LDR
void mid_order_traverse(link_tree_node head){
	if(head == NULL) return ;
	mid_order_traverse(head->first_child);
	cout<<head->data<<' ';
	mid_order_traverse(head->right_sib);
}
// 后序遍历 LRD
void back_order_traverse(link_tree_node head){
	if(head == NULL) return ;
	back_order_traverse(head->first_child);
	back_order_traverse(head->right_sib);
	cout<<head->data<<' ';
}

非递归

先序 – 自上而下— 右子树根节点入栈

在这里插入图片描述

更好

// 先序非递归遍历
void pre_order_stack(link_tree_node head){
	
	if(head == NULL) return;
	
	stack<link_tree_node> s; 
	link_tree_node p=head;
	while(p||!s.empty()){
		
		while(p){
			cout<<p->data<<" ";
			s.push(p);
			p=p->first_child;
		}
		if(!s.empty()){
			p=s.top();
			p=p->right_sib;
			s.pop();
		}
	}	
}

// 先序非递归遍历
void pre_order_stack(link_tree_node head){
	
	if(head == NULL) return;
	
	stack<link_tree_node> s; 
	link_tree_node p=head;
	while(p||!s.empty()){
		
		if(p->right_sib) s.push(p->right_sib);  
		cout<<p->data<<" ";
		if(p->first_child){
			p=p->first_child;
		}else{
			p = NULL;
			if (!s.empty())
			{
				p = s.top(); s.pop();
			}
		}
	}	
}

整体代码

#include<iostream>
#include<string>
using namespace std;
#include<math.h>
#include<stdlib.h>
#include<stack>


// 孩子兄弟表示法
typedef char elemtype;
typedef struct tree_node{
	elemtype data;
	struct tree_node *first_child,*right_sib;
}tree_node,*link_tree_node;

void create_bi_tree(link_tree_node& head,string chars,int serial=1);
void pre_order_stack(link_tree_node head);
void pre_order_traverse(link_tree_node head);
int main(){
	string chars=" abcdefg########"; // 层序遍历 以满二叉树为准 abcdefg########
	link_tree_node head;
	cout<<"满二叉树层序序列:"<<chars<<endl;
	create_bi_tree(head,chars,1);
	cout<<"先序遍历递归算法"<<endl;
	pre_order_traverse(head);
	cout<<endl;
	cout<<"先序遍历非递归算法"<<endl;
	pre_order_stack(head);
	return 0;
}

void create_bi_tree(link_tree_node& head,string chars,int serial){
	if(chars[serial]!='#'){
		head = new tree_node;
		if(!head) exit(OVERFLOW);
		head->data = chars[serial];	
		create_bi_tree(head->first_child,chars,2*serial);// 左树
		create_bi_tree(head->right_sib,chars,2*serial+1); // 右树
	}
	else head = NULL;
}
// 先序递归遍历
void pre_order_traverse(link_tree_node head){
	if(head == NULL) return ;
	cout<<head->data<<' ';
	pre_order_traverse(head->first_child);
	pre_order_traverse(head->right_sib);
}
// 先序非递归遍历
void pre_order_stack(link_tree_node head){
	
	if(head == NULL) return;
	
	stack<link_tree_node> s; 
	link_tree_node p=head;
	while(p||!s.empty()){
		
		if(p->right_sib) s.push(p->right_sib);
		cout<<p->data<<" ";
		if(p->first_child){
			p=p->first_child;
		}else{
			p = NULL;
			if (!s.empty())
			{
				p = s.top(); s.pop();
			}
		}
	}	
}

中序 – 自下而上— 当前树根节点入栈

在这里插入图片描述

// 中序非递归遍历
void mid_order_stack(link_tree_node head) {

	if (head == NULL) return;

	stack<link_tree_node> s;
	link_tree_node p = head;
	// 判断当前树是否为空 且树为空 栈是否为空
	while (p || !s.empty()) {
		// 找当前树左叶节点 即子树根节点
		while (p) {
			s.push(p);
			p = p->first_child;
		}
		if(p) cout << p->data << " "; // 左右子树叶节点
		if (!s.empty()) { // 返回 双亲节点
			p = s.top();
			cout << p->data << " "; // 当前根节点
			s.pop();
			p = p->right_sib; 
		}
		else p = p->right_sib; // 仅余根节点时
	}
}

整体代码

#include<iostream>
#include<string>
using namespace std;
#include<math.h>
#include<stdlib.h>
#include<stack>


// 孩子兄弟表示法
typedef char elemtype;
typedef struct tree_node {
	elemtype data;
	struct tree_node *first_child, *right_sib;
}tree_node, *link_tree_node;

void create_bi_tree(link_tree_node& head, string chars, int serial = 1);
void mid_order_stack(link_tree_node head);
void mid_order_traverse(link_tree_node head);
int main() {
	string chars = " abcdefg########"; // 层序遍历 以满二叉树为准 abcdefg########
	link_tree_node head;
	cout << "满二叉树层序序列:" << chars << endl;
	create_bi_tree(head, chars);
	cout << "中序遍历递归算法" << endl;
	mid_order_traverse(head);
	cout << endl;
	cout << "中序遍历非递归算法" << endl;
	mid_order_stack(head);
	return 0;
}

void create_bi_tree(link_tree_node& head, string chars, int serial) {
	if (chars[serial] != '#') {
		head = new tree_node;
		if (!head) exit(OVERFLOW);
		head->data = chars[serial];
		create_bi_tree(head->first_child, chars, 2 * serial);// 左树
		create_bi_tree(head->right_sib, chars, 2 * serial + 1); // 右树
	}
	else head = NULL;
}
// 中序遍历 LDR
void mid_order_traverse(link_tree_node head) {
	if (head == NULL) return;
	mid_order_traverse(head->first_child);
	cout << head->data << ' ';
	mid_order_traverse(head->right_sib);
}
// 中序非递归遍历
void mid_order_stack(link_tree_node head) {

	if (head == NULL) return;

	stack<link_tree_node> s;
	link_tree_node p = head;
	// 判断当前树是否为空 且树为空 栈是否为空
	while (p || !s.empty()) {
		// 找当前树左叶节点 即子树根节点
		while (p) {
			s.push(p);
			p = p->first_child;
		}
		if (!s.empty()) { // 返回 双亲节点
			p = s.top();
			cout << p->data << " "; // 当前根节点
			s.pop();
			p = p->right_sib; 
		}
		else p = p->right_sib; // 仅余根节点时
	}
}

后序

#include<iostream>
#include<string>
using namespace std;
#include<math.h>
#include<stdlib.h>
#include<stack>
#include<utility>


// 孩子兄弟表示法
typedef char elemtype;
typedef struct tree_node {
	elemtype data;
	struct tree_node *first_child, *right_sib;
}tree_node, *link_tree_node;

void create_bi_tree(link_tree_node& head, string chars, int serial = 1);
void back_order_stack(link_tree_node head);
void back_order_traverse(link_tree_node head);
int main() {
	string chars = " abcdefg########"; // a层序遍历 以满二叉树为准 abcdefg########
	link_tree_node head;
	cout << "满二叉树层序序列:" << chars << endl;
	create_bi_tree(head, chars);
	cout << "后序遍历递归算法" << endl;
	back_order_traverse(head);
	cout << endl;
	cout << "后序遍历非递归算法" << endl;
	back_order_stack(head);
	system("pause");
	return 0;
}

void create_bi_tree(link_tree_node& head, string chars, int serial) {
	if (chars[serial] != '#') {
		head = new tree_node;
		if (!head) exit(OVERFLOW);
		head->data = chars[serial];
		create_bi_tree(head->first_child, chars, 2 * serial);// 左树
		create_bi_tree(head->right_sib, chars, 2 * serial + 1); // 右树
	}
	else head = NULL;
}
// 后序遍历 LRD
void back_order_traverse(link_tree_node head) {
	if (head == NULL) return;
	back_order_traverse(head->first_child);
	back_order_traverse(head->right_sib);
	cout << head->data << ' ';
}
// 后序非递归遍历
void back_order_stack(link_tree_node head) {

	if (head == NULL) return;

	stack<pair<link_tree_node, bool> > s;
	s.emplace(make_pair(head, false));
	bool visited;

	while (!s.empty()) {
		head = s.top().first;
		visited = s.top().second;
		s.pop();
		if (head == NULL) continue;
		if (visited) cout << head->data<<" ";
		else {
			s.emplace(make_pair(head, true));
			s.emplace(make_pair(head->right_sib,false));
			s.emplace(make_pair(head->first_child,false));
		}
	}
}

传送门

C++实现二叉树 前、中、后序遍历（递归与非递归）非递归实现过程最简洁版本
C++二叉树前中后序遍历（递归&非递归）统一代码格式
C++ 中序遍历非递归实现
C++ STACK与pair的基本用法
关于C++ pair 和make_pair的用法
C++11容器中新增加的emplace相关函数的使用
c++11 之emplace_back 与 push_back的区别
C++优化：使用emplace
Template within template: why “`>>‘should be > >’ within a nested template argument list” 解决方法

小韭菜~
关注
专栏目录
DataStruct:张铭-数据结构与算法习题
04-11
:keycap_2: 习题 1 ：是北大张铭《数据结构与算法》教材习题以及对应的《数据结构与算法-学习指导与习题解析》 :keycap_3: 习题 2 ：来自王道教材习题 第一章 概述 第二章 线性表 第三章 栈和队列 :green_book: 第...
算法数据结构学习笔记-C语言.zip
06-16
"算法数据结构学习笔记-C语言.zip"这个压缩包很可能是为大学生提供的一份详细的学习资源，涵盖了数据结构的基础知识、常见算法以及相关的实践练习。 首先，我们要理解数据结构的基本概念，如数组、链表、栈、队列、...
数据结构与算法学习笔记
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法学习笔记-树和二叉树
qq_53548177的博客
12-10 772
声明：本博客仅为本人学习途中做的笔记 采自青岛大学王卓老师的视频教学 主要内容为算法思路，具体代码实现还需修改后才能运行，望各位看官多多包涵，您的点赞与评论是对我最大的肯定！ 1.树和二叉树的定义 数据的逻辑结构{线性结构{线性表栈(特殊线性表)队列(特殊线性表)字符串、数组、广义表非线性结构{树形结构图形结构 数据的逻辑结构 \begin{cases} 线性结构\begin{cases} 线性表 \\ 栈(特殊线性表) \\ .
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 43万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
算法的学习笔记---按之字形顺序打印二叉树
最新发布
业精于勤，荒于嬉
08-22 1000
之字形顺序打印二叉树是一种层序遍历的变种，它要求我们在遍历每层节点时，按指定的方向打印。这种问题不仅考察我们对二叉树遍历的掌握，还需要我们灵活运用数据结构来管理遍历的顺序。通过上述代码，我们可以高效地实现这一功能，并在复杂的树结构中应用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
嵌入式全栈开发学习笔记---数据结构（二叉树）
xiaobaivera的博客
08-10 871
二叉树的特点 1、每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点（即一个结点最多只能有两个分支）。 2、左子树和右子树是有顺序的，次序不能任意颠倒（如上图中B是A的左子树，C是A的右子树，B和C的顺序不能调换）。 3、即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。
数据结构与算法学习笔记六---树和二叉树
我叫柱子哥
04-23 770
数据结构中的树和二叉树
数据结构学习笔记-二叉树
2301_81135589的博客
06-08 844
按层序从1开始编号，结点i的左孩子为20i，右孩子为2i+1；结点i的父节点为[i/2]（向下取整）。如果能找到p的父节点，且p是右孩子，其左兄弟非空，p的前驱为左兄弟子树中最后一个被先序遍历的结点；如果能找到p的父节点，且p是左孩子，其右兄弟非空，p的后继为右兄弟子树中第一个被后序遍历的结点；如果能找到p的父节点，且p是右孩子，其左兄弟为空，p的父结点即为其前驱；如果能找到p的父节点，且p是左孩子，其右兄弟为空，p的父节点即为其后继；若p有左孩子，则先序后继为左孩子，若p没有左孩子，则先序后继为右孩子。
软件设计师学习笔记-数据结构与算法基础
IT1995的博客
09-16 4652
目录 数据结构与算法基础 稀疏矩阵 线性表-顺序表存储与链式存储对比 广义表 树与二叉树 略......   数据结构与算法基础   稀疏矩阵 注意：做题目的时，涉及稀疏矩阵的都用代入法   线性表-顺序表存储与链式存储对比   广义表 例1答案长度3，深度2 例2答案，head(head(tail(LS1)))   树与二叉树   略.....
【数据结构】算法基础学习笔记--数据结构
分享自己学习过程获得的一些知识
09-01 1849
算法基础学习笔记--数据结构。
算法学习笔记 - ＜＜数据结构与算法之美＞＞ 王争
galoiszhou的博客
08-06 505
数据结构与算法之美 数组 数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。 线性表（Linear List） 数组 链表 队列 栈 … 非线性: 二叉树 堆 图 … 连续的内存空间和相同类型的数据 优点:　随机访问 缺点：删除/插入　数据比较低效. 大量数据迁移 插入数据 优化: 数组的顺序不重要的场景, 如果需要在中间插入, 可以把插入位置的元素移动到数组末尾, 再把要插入的元素直接放入插入位置. 删除数据 优化: 在某些特殊场景下，并不一定非得追求数
《B站-青岛大学-王卓老师-数据结构与算法基础》自学心得、笔记（C++语言实现）.zip
06-17
在学习《B站-青岛大学-王卓老师-数据结构与算法基础》这门课程时，数据结构作为计算机科学中的核心部分，对于提升编程能力、理解复杂问题的解决策略至关重要。王卓老师的课程深入浅出地讲解了各种数据结构及其算法，...
海贼胡船长-B站-数据结构与算法系列课程中的演示代码.zip
06-17
“大学生 C/C++/JAVA/Python数据结构学习笔记和资料大全”这个描述表明，课程不仅提供理论讲解，还可能包含针对不同编程语言的实现示例。C/C++适合系统级编程，对底层控制有很强的能力；JAVA则是企业级应用的首选，...
黑马程序员C++学习笔记（第一阶段：基础）
TI__boyue的博客
09-20 1566
目录起步：hello c++定义常量：# define ,const 起步：hello c++ #include <iostream> using namespace std; int main(){ cout <<"hello c++"<< endl; // system("pause"); return 0; } 定义常量：# define ,const #define 宏变 ...
黑马程序员C++学习笔记（第二阶段核心：面向对象）（一）
TI__boyue的博客
09-29 1148
内存分区：代码区，全局区，栈区，堆区 程序运行前：代码区，全局区 程序运行后：栈区，堆区 数据保留一次 //栈区：局部变量 int a=10; // 堆区:程序员开辟new，释放delete, int *p=new int(10); // 返回的是整型数据10存放的地址编号 int *p = new int(10); //开辟 delete p; //释放 int *arr = new int[10]; //10个元素 返回首地址\ for(int i=0;i<10;i++){ a
黑马程序员C++学习笔记（第二阶段核心：面向对象）（二）
TI__boyue的博客
10-14 672
目录C++对象模型和this指针成员变量和成员函数分开存储this 指针 C++对象模型和this指针 成员变量和成员函数分开存储 在C++中，类内的成员变量和成员函数分开存储 只有非静态成员变量才属于类的对象上面(类对应的对象的内存大小不会发生改变) 空对象占用内存空间为: C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置 每个空对象也应该有一个独一无二的内存地址 this 指针 每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码。那
C++面试高频考点整理--基础
TI__boyue的博客
05-29 603
目录1、const、define的联系与区别2、指针和引用的区别传送门 1、const、define的联系与区别 const ：在堆栈分配了空间，在程序中可以被调用、传递，存在于程序的数据段 define：仅将具体数值传递到目标变量，生命周期止步于编译期，在程序中仅是一个常数，没有实际存在，存在于数据的代码段 2、指针和引用的区别 指针： 是一个变量，指向内存中的一个存储单元，存储的是一个地址 可以有const指针 可以有多级，即指针的指针 可以为空 nullptr 初始化后指针指向可以改变 size
学习笔记-数据结构与算法之栈与队列
TI__boyue的博客
05-01 515
目录栈 栈
数据结构复习笔记：二叉树与排序算法详解
数据结构复习笔记是一份全面而深入的数据结构学习资料，主要针对数据结构的基础概念、重要数据结构类型以及算法设计与分析展开讲解。该笔记首先阐述了数据结构的发展背景和学习目的，强调了理解和处理现实世界中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值