数据结构（树和二叉树）

最新推荐文章于 2023-07-15 17:39:18 发布
最新推荐文章于 2023-07-15 17:39:18 发布
阅读量1.4k 收藏 16
点赞数 9
分类专栏： 数据结构与算法 文章标签： 二叉树 数据结构 链表 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45724216/article/details/112137071
版权

1. 前序打印叶子结点

【问题描述】设计算法，要求按照前序遍历方式打印二叉树的叶子结点。

【输入形式】一行字符串，该行是扩展二叉树的前序遍历序列，用于构造二叉树。

【输出形式】二叉树的前序叶子遍历序列（中间用空格隔开）。

【样例输入】AB#D##C##

【样例输出】

D C

#include <iostream>
#include <string>
using namespace std;
struct BiNode {
	char data;
	BiNode *L_child;
	BiNode *R_child;
};

class BiTree {
	public:
		BiTree() {
			root=Creat();
		}
		~BiTree() {
			Release(root);
		}
		void PreOrder() {
			PreOrder(root);
		}

	private:
		BiNode *Creat();
		void Release(BiNode *bt);
		void PreOrder(BiNode *bt);
		BiNode *root;
};

BiNode *BiTree::Creat() {
	BiNode *bt;
	char a=getchar();
	if(a=='#')bt= NULL;
	else {
		bt=new BiNode;
		bt->data=a;
		bt->L_child=Creat();
		bt->R_child=Creat();
	}
	return bt;
}

void BiTree::Release(BiNode *bt) {
	if(bt==NULL)return;
	else {
		Release(bt->L_child);
		Release(bt->R_child);
		delete bt;
	}
}

void BiTree::PreOrder(BiNode *bt) {
	if(bt==NULL)return;
	else {
		if(bt->L_child==NULL&&bt->R_child==NULL)
			cout<<bt->data<<" ";
		PreOrder(bt->L_child);
		PreOrder(bt->R_child);
	}
}

int main() {
	BiTree T;
	T.PreOrder();
	return 0;
}

2. 求二叉树的结点个数

【问题描述】设计算法求二叉树的结点个数。

【输入形式】一行字符串，该行是扩展二叉树的前序遍历序列，用于构造二叉树。

【输出形式】二叉树中的结点个数。

【样例输入】AB#D##C##

【样例输出】

4

#include <iostream>
using namespace std;
struct BiNode {
	char data;
	BiNode *L_child;
	BiNode *R_child;
};
class BiTree {
	public:
		BiTree() {
			root=Creat();
		}
		~BiTree() {
			Release(root);
		}
		int CountNode() {
			return CountNode(root);
		}

	private:
		BiNode *Creat();
		void Release(BiNode *bt);
		int CountNode(BiNode *bt);
		BiNode *root;
};
int BiTree::CountNode(BiNode *bt) {
	int count=0;
	if(bt==NULL)return count;
	else {
		if(bt->data!='#') {
			count++;
			count+=CountNode(bt->L_child);
			count+=CountNode(bt->R_child);
		}
	}
	return count;
}
BiNode* BiTree::Creat() {
	BiNode *bt;
	char a=getchar();
	if(a=='#')bt=NULL;
	else {
		bt=new BiNode;
		bt->data=a;
		bt->L_child=Creat();
		bt->R_child=Creat();
	}
	return bt;
}
void BiTree::Release(BiNode *bt) {
	if(bt==NULL)return;
	else {
		Release(bt->L_child);
		Release(bt->R_child);
		delete bt;
	}
}
int main() {
	BiTree T;
	cout<<T.CountNode();
	return 0;
}

3. 求二叉树的深度

【问题描述】设计算法求二叉树的深度。

【输入形式】一行字符串，该行是扩展二叉树的前序遍历序列，用于构造二叉树。

【输出形式】二叉树的深度。

【样例输入】AB#D##C##

【样例输出】

3

#include <iostream>

using namespace std;
struct BiNode {
	char data;
	BiNode *L_child;
	BiNode *R_child;
};

class BiTree {
	public:
		BiTree() {
			root = Creat();
		}

		~BiTree() {
			Release(root);
		}

		int CountDepth() {
			return CountDepth(root);
		}

	private:
		BiNode *Creat();

		void Release(BiNode *bt);

		int CountDepth(BiNode *bt);

		BiNode *root;
};
BiNode* BiTree::Creat() {
	BiNode *bt;
	char a=getchar();
	if(a=='#')bt=NULL;
	else {
		bt=new BiNode;
		bt->data=a;
		bt->L_child=Creat();
		bt->R_child=Creat();
	}
	return bt;
}
void BiTree::Release(BiNode *bt) {
	if(bt==NULL)return;
	else {
		Release(bt->L_child);
		Release(bt->R_child);
		delete bt;
	}
}
int BiTree::CountDepth(BiNode *bt) {
	int i=0,j=0;
	if(bt==NULL)return 0;
	else {
		i=CountDepth(bt->L_child);
		j=CountDepth(bt->R_child);
	}
	return i>=j?i+1:j+1;
}
int main() {
	BiTree T;
	cout<<T.CountDepth();
	return 0;
}

4. 二叉链表存储结构下，求结点x的双亲结点

【问题描述】以二叉链表为存储结构，编写算法求二叉树中结点x的双亲。

【输入形式】两行，第一行是扩展二叉树的前序遍历序列，第二行是待查询结点x

【输出形式】如果结点x存在双亲，则输出其双亲的数值；否则输出“NO”。

【样例输入】AB#D##C##

D

【样例输出】

B

#include <iostream>

using namespace std;
struct BiNode {
	char data;
	BiNode *L_child;
	BiNode *R_child;
};

class BiTree {
	public:
		BiTree() {
			root = Creat();
		}

		~BiTree() {
			Release(root);
		}

		void Parent(char x) {
			Parent(root,x);
		};

	private:
		BiNode *root;

		BiNode *Creat();

		void Release(BiNode *bt);
		void Parent(BiNode *bt,char x);
};

BiNode *BiTree::Creat() {
	BiNode *bt;
	char a = getchar();
	if (a == '#')bt = NULL;
	else {
		bt = new BiNode;
		bt->data = a;
		bt->L_child = Creat();
		bt->R_child = Creat();
	}
	return bt;
}

void BiTree::Release(BiNode *bt) {
	if (bt == NULL)return;
	else {
		Release(bt->L_child);
		Release(bt->R_child);
		delete bt;
	}
}

void BiTree::Parent(BiNode *bt, char x) {
	if (bt->L_child==NULL&&bt->R_child==NULL)return;
	if(bt->L_child!=NULL) {
		if (bt->L_child->data == x)
			cout << bt->data;
		else {
			Parent(bt->L_child, x);
		}
	}
	if(bt->R_child!=NULL) {
		if (bt->R_child->data == x)
			cout<<bt->data;
		else {
			Parent(bt->R_child,x);
		}
	}
}
int main() {
	BiTree T;
	getchar();
	char a=getchar();
	T.Parent(a);

}

5. 删除以值x为根结点的子树

【问题描述】以二叉链表为存储结构，在二叉树中删除以值x为根结点的子树。

【输入形式】两行，第一行是扩展二叉树的前序遍历序列，第二行是待查询结点x。

【输出形式】如果结点x存在，则删除以值x为根结点的子树；否则无操作。最后输出操作后二叉树的中序遍历序列（中间用空格隔开）。如果是空二叉树，则输出“Empty”。

【样例输入】AB#D##C##

D

【样例输出】

B A C

#include <iostream>

using namespace std;
struct BiNode {
	char data;
	BiNode *L_child;
	BiNode *R_child;
};

class BiTree {
	public:
		BiNode* getRoot() {
			return root;
		}
		BiTree() {
			root = Create();
		}

		~BiTree() {
			Release(root);
		}

		void Release(BiNode *bt);

		void DeleteChildTree(char x) {
			DeleteChildTree(root, x);
		}

		void InOrder() {
			InOrder(root);
		}

	private:
		BiNode *root;

		BiNode *Create();

		void DeleteChildTree(BiNode *bt, char x);

		void InOrder(BiNode *bt);
};

BiNode *BiTree::Create() {
	BiNode *bt;
	char a = getchar();
	if (a == '#')bt = NULL;
	else {
		bt = new BiNode;
		bt->data = a;
		bt->L_child = Create();
		bt->R_child = Create();
	}
	return bt;
}

void BiTree::Release(BiNode *bt) {
	if (bt == NULL)return;
	else {
		Release(bt->L_child);
		Release(bt->R_child);
		delete bt;
	}
}

void BiTree::DeleteChildTree(BiNode *bt, char x) {
	if (bt == NULL)return;
	else {
		if (bt->L_child != NULL && bt->L_child->data == x) {
			bt->L_child = NULL;
		}
		if (bt->R_child != NULL && bt->R_child->data == x) {
			bt->R_child = NULL;
		}
		DeleteChildTree(bt->L_child, x);
		DeleteChildTree(bt->R_child, x);
	}
}

void BiTree::InOrder(BiNode *bt) {
	if (bt == NULL) {
		return;
	} else {
		InOrder(bt->L_child);
		cout << bt->data << " ";
		InOrder(bt->R_child);
	}
}

int main() {
	BiTree T;
	getchar();
	char a = getchar();
	if(T.getRoot()->data==a) {
		cout<<"Empty"<<endl;
		return 0;
	}
	T.DeleteChildTree(a);
	T.InOrder();
	return 0;
}

6. 基于顺序存储结构的前序遍历

【问题描述】一个具有n个结点的二叉树采用顺序存储结构，编写算法对该二叉树进行前序遍历。

【输入形式】一行，该二叉树按照对应完全二叉树的层序遍历序列（即某个结点没有左孩子或者右孩子时，添加特殊标记#）。

【输出形式】二叉树的前序遍历序列；如果是空二叉树，则输出“Empty”。

【样例输入】ABC#D

【样例输出】

A B D C

#include<iostream>
#include<string.h>
#include<cstdlib>
using namespace std;
char array[1000];
void preOrder(int i) {
	if(array[i]=='#')
		return;
	else {
		cout<<array[i]<<" ";
		preOrder(i*2);
		preOrder(i*2+1);
	}
}
int main() {
	string s;
	memset(array,'#',sizeof(array));
	cin>>s;
	for(int i=0; i<s.length(); i++) {
		if(s[i]!='#') {
			array[i+1]=s[i];
		}
	}
	preOrder(1);
	return 0;
}

7. 扩展序列构造二叉树

【问题描述】

给出某扩展二叉树的前序遍历序列（虚结点的值用“#”表示），构造二叉树，并输出该二叉树的中序遍历序列。

【输入形式】扩展二叉树的前序遍历序列

【输出形式】二叉树的中序遍历序列

【样例输入】AB#D##C##

【样例输出】BDAC

#include<stack>
#include<cstdlib>
#include<iostream>
using  namespace  std;
template<class  DataType>
struct  BiNode {
	DataType  data;
	BiNode<DataType>  *lchild,*rchild;
};
template<class  DataType>
class  BiTree {
	public:
		BiTree() {
			root  =  PreCreate(root);
		};
		~BiTree() {
			Release(root);
		};
		void  InOrder() {
			InOrder(root);
		};
	private:
		BiNode<DataType>  *root;
		BiNode<DataType>*  PreCreate(BiNode<DataType>*  bt);
		void  Release(BiNode<DataType>  *  bt);    //后序释放
		void  InOrder(  BiNode<DataType>*  bt);
};

template<class  DataType>
BiNode<DataType>*  BiTree<DataType>::PreCreate(BiNode<DataType>*  bt) {
	char t;
	t=getchar();
	if(t=='#')
		bt=NULL ;
	else {
		bt=new BiNode<DataType>;
		bt->data=t;
		bt->lchild=PreCreate(bt->lchild);
		bt->rchild=PreCreate(bt->rchild);
	}
	return bt;

}
template<class  DataType>
void  BiTree<DataType>::Release(BiNode<DataType>  *bt) {
	if(bt  ==  NULL)  return  ;
	else {
		Release(bt->lchild);
		Release(bt->rchild);
		bt  =  NULL;
		delete  bt;
	}
}
template<class  DataType>
void  BiTree<DataType>::InOrder(BiNode<DataType>*  bt) {
	if(bt==NULL)
		return ;
	else {
		InOrder(bt->lchild);
		cout<<bt->data;
		InOrder(bt->rchild);
	}
}

int  main() {
	BiTree<char>  biTree;
	biTree.InOrder();
	biTree.~BiTree();
	return  0;
}

8. 二叉树层序遍历序列

【问题描述】给出某扩展二叉树的前序遍历序列（虚结点的值用“#”表示），构造二叉树，并输出该二叉树的层序遍历序列。

【输入形式】扩展二叉树的前序遍历序列

【输出形式】二叉树的层序遍历序列

【样例输入】AB#D##C##

#include<queue>
#include<cstdlib>
#include<iostream>
using  namespace  std;
template<class  DataType>
struct  BiNode {
	DataType  data;
	BiNode<DataType>  *lchild,*rchild;
};
template<class  DataType>
class  BiTree {
	public:
		BiTree() {
			root  =  PreCreate(root);
		};
		~BiTree() {
			Release(root);
		};
		void  LeverOrder(  );
	private:
		BiNode<DataType>  *root;
		BiNode<DataType>*  PreCreate(BiNode<DataType>*  bt);
		void  Release(BiNode<DataType>  *  bt);    //后序释放
};


template<class  DataType>
BiNode<DataType>*  BiTree<DataType>::PreCreate(BiNode<DataType>*  bt) {
	char t;
	t=getchar();
	if(t=='#')
		bt=NULL;
	else {
		bt=new BiNode<DataType>;
		bt->data=t;
		bt->lchild=PreCreate(bt->lchild);
		bt->rchild=PreCreate(bt->rchild);
	}
	return bt;
}
template<class  DataType>
void  BiTree<DataType>::Release(BiNode<DataType>  *bt) {
	if(bt  ==  NULL)  return  ;
	else {
		Release(bt->lchild);
		Release(bt->rchild);
		bt  =  NULL;
		delete  bt;
	}
}
template<class  DataType>
void  BiTree<DataType>::LeverOrder() {
	queue<BiNode<DataType> > Q;
	if(root==NULL)return;
	Q.push(*root);
	while(!Q.empty()) {
		BiNode<DataType> q;
		q=Q.front();
		Q.pop();
		cout<<q.data;
		if(q.lchild) {
			Q.push(*q.lchild);
		}
		if(q.rchild) {
			Q.push(*q.rchild);
		}
	}
}

int  main() {
	BiTree<char>  biTree;
	biTree.LeverOrder();
	biTree.~BiTree();
	return  0;
}

9. 孩子链表表示法——找孩子

【问题描述】如果某树采用这种孩子链表表示法存储，现如今需要查询某个结点的某个孩子，如果该孩子存在，则输出孩子信息；否则输出NO。比如下面这棵树，查询结点B的第3个孩子，该孩子存在且是结点F；若要查询结点B的第4个孩子，该孩子不存在，则输出NO。

【输入形式】第一行树种结点的个数n；第二行各结点的信息；第三行双亲孩子关系的个数row；接下row行分别输入双亲孩子关系，第一个表示双亲结点，第二个表示孩子结点；最后一行表示待查询结点elem的第i个孩子。

【输出形式】如果待查询结点elem的第i个孩子存在，则输出孩子信息；否则输出NO。

【样例输入】
9

A B C D E F G H I

8

A B

A C

B D

B E

B F

C G

C H

E I

B 3

【样例输出】F

#include<cstdlib>
#include<iostream>
using  namespace  std;
struct  CTNode {
	int  child;//元素在数组中的下标
	CTNode  *next;
};
template<class  DataType>
struct  CBNode {
	DataType  data;
	CTNode  *firstChild;
};
template<class  DataType>
class  ChildLink {
	public:
		ChildLink(int  num);
		~ChildLink();
		bool  findChild(DataType  elem,int  i,DataType  &value);
		int  findPos(DataType  elem);
	private:
		CBNode<DataType>*  arrayPtr;
		int  nodeNUm;
};


template<class  DataType>
ChildLink<DataType>::ChildLink(int  num) {
	arrayPtr  =  new  CBNode<DataType>[num+1];
	CTNode**arrayRear  =  new  CTNode*[num+1];//尾插
	nodeNUm  =  num;
	for(int  i  =  1; i<=  num; i++) {
		DataType  temp;
		cin>>temp;
		arrayPtr[i].data  =  temp;
		arrayPtr[i].firstChild  =  NULL;
	}
	int  row;
	cin>>row;
	for(int  i  =  0; i  <  row; i++) {
		DataType  parent,child;
		cin>>parent>>child;
		int  parLoc  =  findPos(parent);
		int  chiLoc  =  findPos(child);
		if(arrayPtr[parLoc].firstChild  ==  NULL) { //第一个孩子
			arrayPtr[parLoc].firstChild  =  new  CTNode;
			arrayPtr[parLoc].firstChild  ->child  =  chiLoc;
			arrayPtr[parLoc].firstChild  ->next  =  NULL;
			arrayRear[parLoc]  =  arrayPtr[parLoc].firstChild  ;
		} else {
			CTNode*  s=  new  CTNode;//尾插
			s->child  =  chiLoc;
			s->next  =  NULL;
			arrayRear[parLoc]->next  =  s;
			arrayRear[parLoc]  =  s;
		}
	}
}

template<class  DataType>
ChildLink<DataType>::~ChildLink() {
	CTNode*  first  =  NULL;
	for(int  i=1; i<=nodeNUm; i++) {
		first  =  arrayPtr[i].firstChild;
		while(first  !=  NULL) {
			arrayPtr[i].firstChild  =  first->next;
			delete  first;
			first  =  arrayPtr[i].firstChild;
		}
	}
}
//查找元素elem的第i个孩子
template<class  DataType>
bool  ChildLink<DataType>::findChild(DataType  elem,int  i,DataType  &value) {
	int preLoc=findPos(elem); //找到elem在数组中的位置
	CTNode* first = arrayPtr[preLoc].firstChild; //获得第一个孩子地址
	int count=1;
	while(first&&count<i) {
		first=first->next;
		count++;
	}
	if(first) { //表示存在第i个孩子
		value=arrayPtr[first->child].data; //引用变量赋值
		return true;
	} else
		return false;

}
template<class  DataType>
int  ChildLink<DataType>::findPos(DataType  elem) {
	for(int  i  =  1; i  <=  nodeNUm; i++)
		if(arrayPtr[i].data  ==  elem)  return  i;
	return  0;//查找失败
}


int  main() {
	int  n;
	cin>>n;
	ChildLink<char>  childLink(n);
	char  value,elem;
	int  i;
	cin>>elem;
	cin>>i;
	if(childLink.findChild(elem,i,value))
		cout<<value<<endl;
	else
		cout<<"NO"<<endl;
	childLink.~ChildLink();
	return  0;
}

10. 哈夫曼树以及哈夫曼编码

【问题描述】给出n个字符，以及这些字符使用的频率，设计最经济的编码方案，并输出任意一个字符的哈弗曼编码。如果该字符不存在，则输出“NO”，否则输出对应的哈夫曼编码

【输入形式】第一行字符个数n；第二行n个字符的使用频率（中间用逗号分隔开）；第三行需要输出哈夫曼编码的字符序号。

【输出形式】某字符的哈夫曼编码

【样例输入】

4

2 3 4 5

2

【样例输出】01

#include<iostream>
#include<string.h>
using  namespace  std;
struct  HTNode {
	int  weight;
	int  parent,lchild,rchild;
};
class  HuffmanTree {
	public:
		HuffmanTree(int  W[],int  n);
		~HuffmanTree();
		void  Select(HTNode*  HT,int  len,int  &i1,int  &i2);
		void  CreatHuffmanCode(  );
		void  showHuffmanCode(int  i);
	private:
		int  nodeNum;
		HTNode*  HT;//存储哈夫曼树
		char**  HTC;//存储哈夫曼编码
};

HuffmanTree::HuffmanTree(int  W[],int  n) {
	nodeNum  =  n; //节点数目
	HT  =  new  HTNode[2*n  -1]; //存储节点的哈夫曼树
	//初始化
	for(int  i=0; i  <  2*nodeNum  -1; i++) {
		HT[i].lchild  =  -1;
		HT[i].rchild  =  -1;
		HT[i].parent  =-1;
	}
	for(int  i=0; i  <  nodeNum; i++)
		HT[i].weight  =  W[i];
	//哈弗曼树构造
	for(int  k  =  nodeNum; k  <  2*nodeNum-1; k++) {
		int  i1,i2;
		Select(HT,k,i1,i2);
		HT[k].weight  =  HT[i1].weight  +  HT[i2].weight;
		HT[i1].parent  =  k;
		HT[i2].parent  =  k;
		HT[k].lchild  =  i1;
		HT[k].rchild  =  i2;
	}
}
HuffmanTree::~HuffmanTree() {
	HT  =  NULL;
	delete  HT;
	HTC  =  NULL;
	delete  []HTC;
}
void  HuffmanTree::Select(HTNode*  HT,int  len,int  &i1,int  &i2) {
	int first_min,second_min;
	first_min=100000;
	second_min=10000;
	i1=-1;//节点中最小权值的下标
	i2=-1;//节点中倒数第二权值小的下标
	for(int i=0; i<len; i++) {
		if(HT[i].parent!=-1)continue;//该节点已经使用过
		if(HT[i].weight<first_min) {
			second_min=first_min;
			i2=i1;
			first_min=HT[i].weight;
			i1=i;
		} else if(HT[i].weight<second_min) {
			second_min=HT[i].weight;
			i2=i;
		}
	}
}
//进行赫夫曼编码                                                                                                //  CreatHuffmanTree
void  HuffmanTree::CreatHuffmanCode(  ) {
	//从叶子到根逆向求每个字符的赫夫曼编码，存储在编码表HC中
	int  i,start,c,f;
	HTC=new  char*[nodeNum];                                                                  //分配n个字符编码的头指针矢量
	char  *cd=new  char[nodeNum];                                                        //分配临时存放编码的动态数组空间
	cd[nodeNum-1]='\0';                                                                        //编码结束符
	for(i=0; i<nodeNum; ++i) {
		//逐个字符求赫夫曼编码
		start=nodeNum-1;                                                                    //start开始时指向最后，即编码结束符位置
		c=i;
		f=HT[i].parent;                                                          //f指向结点c的双亲结点
		while(f!=-1) {
			//从叶子结点开始向上回溯，直到根结点
			--start;                                                                    //回溯一次start向前指一个位置
			if(HT[f].lchild==c)
				cd[start]='0';                                                //结点c是f的左孩子，则生成代码0
			else
				cd[start]='1';                                                  //结点c是f的右孩子，则生成代码1
			c=f;
			f=HT[f].parent;                                                  //继续向上回溯
		}                                                                                            //求出第i个字符的编码
		HTC[i]=new  char[nodeNum-start];                                          //  为第i  个字符编码分配空间
		strcpy(HTC[i],  &cd[start]);                                        //将求得的编码从临时空间cd复制到HC的当前行中
	}
	delete  cd;                                                                                //释放临时空间
}
void  HuffmanTree::showHuffmanCode(int  i) {
	cout<<HTC[i-1]<<endl;
}
int  main() {
	int  n;
	cin>>n;
	int  W[n];
	for(int  i=0; i<n; i++)
		cin>>W[i];
	HuffmanTree  huffmanTree(W,n);
	huffmanTree.CreatHuffmanCode();
	int  i;
	cin>>i;
	if(i<1  ||  i>  n)
		cout<<"NO"<<endl;
	else
		huffmanTree.showHuffmanCode(i);
	huffmanTree.~HuffmanTree();
	return  0;
}

结语

如果你发现文章有什么问题，欢迎留言指正。
如果你觉得这篇文章还可以，别忘记点个赞加个关注再走哦。
如果你不嫌弃，还可以关注微信公众号———梦码城（持续更新中）。
梦码在这里感激不尽！！

梦码城
关注
  • 9
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
输出二叉树中某结点的双亲结点
11-22
采用先序法建立一棵二叉树，设计输出某结点数据为x的双亲结点的数据的程序，二叉树的数据域类型为字符型， 扩展二叉树的叶子结点用‘#’表示，要求可以求一棵二叉树中多个结点的双亲。
python数据结构树和二叉树简介
01-20
一、树的定义 树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并具有层次关系的结构。...它或者是空集，或者是由一个根和称为左、右子树的两个不相交的二叉树组成。特点：（1）二叉树是有序树，
顺序存储二叉树
Syx80236的博客
04-16 123
顺序存储二叉树 从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组。 顺序二叉树通常只考虑完全二叉树 第n个元素的左子节点为 2 * n + 1 第n个元素的右子节点为 2 * n + 2 第n个元素的父节点为 (n-1) / 2 n : 表示二叉树中的第几个元素(按0开始编号 给你一个数组 {1,2,3,4,5,6,7}，要求以二叉树前序遍历的方式进行遍历。 前序遍历的结果应当为 1,2,4,5,3,6,7 package com.yuxi.lesson10
二叉树采用顺序存储结构时的前序遍历
song_10的博客
12-19 7914
题目：一颗具有n个结点的二叉树采用顺序储存结构，编写算法对该二叉树进行前序遍历 C++实现如下： #include<iostream> using namespace std; class SeqTree { public: SeqTree(int n) { Creat(n); }//构造二叉树，采用顺序表储存数据 void Creat(int n); void PreOr...
【二叉树OJ题(二)】前序遍历&&中序遍历&&后序遍历&&另一颗树的子树&&二叉树遍历&&平衡二叉树
Sherry的博客
04-03 261
今天我们完成了二叉树OJ题(二)，通过分析明白了思路和原理，愿这篇博客能帮助大家理解这些OJ题，到这里，我们的二叉树就暂告一段落啦。接下来将更新排序算法的相关知识点。希望我的文章和讲解能对大家的学习提供一些帮助。
二叉树的前序中序后序遍历（两种解法：递归法+迭代法）
最新发布
m0_58681055的博客
07-15 407
先将root节点的值加入到res数组中，然后递归的进行根节点左子树的遍历，再进行根节点右子树的遍历。先递归的进行根节点左子树的遍历， 再进行根节点右子树的遍历，最后将root节点的值加入到res数组中即可。先递归的进行根节点左子树的遍历， 然后将root节点的值加入到res数组中，再进行根节点右子树的遍历。输入：root = [1,null,2,3]输入：root = [1,null,2,3]输入：root = [1,null,2,3]输出：[1,2,3]输出：[1,3,2]输出：[3,2,1]
数据结构--二叉树--思维导图.pdf
08-29
二叉树是一种常见的数据结构，它是一种树形结构，每个节点最多有两个孩子节点，分别是左子树和右子树。二叉树可以用来存储大量数据，并且可以快速地查找、插入和删除数据。 二叉树的定义：二叉树是由节点组成的树形...
数据结构 树和二叉树ppt教程
05-01
【数据结构：树和二叉树】 树是一种非线性的数据结构，它的基本概念和术语在计算机科学中至关重要，尤其在算法设计和数据组织中扮演着核心角色。树的定义基于递归，一棵非空树包含一个根节点，以及一组互不相交的...
数据结构树和二叉树.cpp
03-19
先序创建二叉树，先序、中序、后序遍历二叉树，统计二叉树中叶子节点的个数，输出叶子结点，计算二叉树的深度。
西南科技大学SWUST OJ 数据结构 树和二叉树答案 树和二叉树.zip
01-01
在IT领域，数据结构是计算机科学的基础，而树和二叉树是其中极其重要的概念。西南科技大学（SWUST）的在线编程平台（OJ）提供了关于这些主题的编程题目，帮助学生深入理解和应用这些知识。以下是对这些题目涉及知识...
n个结点的完全二叉树顺序存储在一维数组a中，设计一个算法，由此数组得到该完全二叉树的二叉链表结构
家里蹲大学摸鱼学专业优秀毕业生的博客
12-12 3708
#include<stdio.h> #include<stdlib.h> typedef struct btnode { char element; struct btnode* Lchild, * Rchild; }BTNode; typedef struct btree { struct btnode* Root; }BTree; //创建新节点 BTNode* NewNode() { BTNode* p = (BTNode*)malloc(sizeof(BTNode))
二叉树 （操作与一些节点计算题）
weixin_45765493的博客
03-30 975
二叉树的二叉链表结点结构定义 typedef struct BiTNode/*结点结构*/ { char data;//结点数据 struct BiTNode* lchild, * rchild;//左孩子，右孩子。 }BiTNode,*BiTree; 1.前序遍历 前序遍历的规则时若二叉树为空，则空操作返回，否则 先访问根节点，然后前序遍历左子树，在前序遍历右子树，如图： 这个二叉树的前...
【二叉树】45 二叉树：结点个数
windyuan~
02-25 558
问题描述 : 内容：（1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） 注意：二叉树ADT的基本操作的算法设计很多要用到递归的程序设计方法。 （2）基本操作17：在二叉树的二叉链表存储形式建立的基础上，使用递归的程序设计方法，设计并完成统计结点个数的算法。完成后将其加入到二.
二叉树查找双亲结点
qq_43527713的博客
11-15 1万+
//递归实现查找双亲结点 void Find_Father(BiTNode *(&T),ElemType data) { if(T ==NULL) return; if(T->lchild != NULL)//当左孩子存在的时候才进行判断，否则程序出错 { if(T->lchild->data == data)...
在二叉链表中查找值为x的节点的双亲节点
qq_44186550的博客
10-26 2039
在二叉链表中查找值为x的节点的双亲节点
求二叉树双亲
你好_晴天
12-05 2817
#include&lt;iostream&gt; #include&lt;stdio.h&gt; using namespace std; struct BiNode { char data; BiNode *l,*r; BiNode() { l=r=NULL; } }; class Tree { public: BiNode* p; ...
二叉树：设计一个求结点x在二叉树中的双亲结点算法。
热门推荐
刘珂的博客
10-14 2万+
typedef struct node { int data; struct node *lchild,*rchild; } bitree; bitree *q[20]; int r=0,f=0,flag=0; void preorder(bitree *bt, char x) { if (bt!=0 && flag==0) if (bt->data==x) ...
算法5.1-5.6
m0_65185254的博客
11-19 1620
数据结构(树和二叉树)
【PTA】二叉树的层次遍历
qq_51669241的博客
05-07 2653
二叉树的层次遍历 编写程序，要求实现 （1）按先序遍历序列建立二叉树的二叉链表；（2）按层次遍历二叉树。 C++： 构成二叉链表的结点类代码如下： typedef struct BiNode { char data; //结点数据域 struct BiNode *lchild,*rchild; //左右孩子指针 }BiTNode,*BiTree; 按加入空树信息的先序遍历序列建立二叉树的二叉链表代码提供如下： //先序遍历序列建立二叉链表 void C
"数据结构树和二叉树遍历教案：树的基本概念、线索二叉树、赫夫曼树及应用
The PowerPoint presentation titled "数据结构树和二叉树遍历二叉树和线索二叉树PPT学习教案" delves into the concepts of tree and binary tree traversal. The presentation covers the basics of trees, binary...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梦码城

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值