二叉树的链式存储的基本操作

已于 2024-12-15 14:42:02 修改
阅读量109 收藏
点赞数 3
文章标签： 算法 c++ 数据结构
于 2024-12-15 11:52:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiao____________/article/details/144485093
版权

 

#include<iostream>
#include "二叉树.h"

using namespace std;

#define OK 1
#define ERROR 0

//顺序存储不常用
//#define  MAX_TREE_SIZE 100 //二叉树的最大结点数
//typedef TElemType SqBiTree[MAX_TREE_SIZE];//0号单元存储根节点
//SqBiTree bt;

//二叉链表
typedef char TElemType;
typedef struct BiNode {
	TElemType data;
	struct BiNode* lchild, * rchild;
}BiNode,*BiTree;

//队列

typedef BiNode*  QElemType;
typedef int Status;

typedef struct QNode {
	QElemType data;
	struct QNode* next;
}QNode, * QueuePtr;

typedef struct {
	QueuePtr front;//队头指针
	QueuePtr rear;//队尾指针
}LinkQueue;

//初始化
Status InitQueue(LinkQueue& Q) {
	Q.front = Q.rear = new QNode;
	Q.front->next = NULL;//有头结点
	return OK;
}

//入队
Status EnQueue(LinkQueue& Q, QElemType e) {
	QueuePtr p;
	p = new QNode;
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	return OK;
}

//出队
Status DeQueue(LinkQueue& Q, QElemType& e) {
	if (Q.front == Q.rear)
		return ERROR;
	QueuePtr p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if (Q.rear == p)
		Q.rear = Q.front;//最后一个元素被删，队尾指针指向头指针
	delete p;
	return OK;
}

//取队头元素
QElemType GetHead(LinkQueue Q) {
	if (Q.front != Q.rear)
		return Q.front->next->data;
}

//判空
bool IsEmpty(LinkQueue Q) {
	if (Q.front == Q.rear)
		return true;
	else return false;

}

//栈
typedef BiNode* SElemType;

typedef struct StackNode {
	SElemType data;
	struct StackNode* next;
}StackNode, * LinkStack;

LinkStack S;

//不带头结点
Status InitStack(LinkStack& S) {
	S = NULL;//构造一个空栈
	return OK;
}

//入栈
Status push(LinkStack& S, SElemType& e) {
	LinkStack p;
	p = new StackNode;//生成新结点
	p->data = e;
	p->next = S;//将新结点插入栈顶
	S = p;
	return OK;
}

//出栈
Status pop(LinkStack& S, SElemType& e) {
	LinkStack p;
	if (S == NULL)
		return ERROR;
	e = S->data;
	p = S;
	S = S->next;
	delete p;//释放原栈顶元素空间
	return OK;
}
//判空
bool EmptyStack(LinkStack S) {
	if (S) return false;
	else return true;
}

//栈顶元素
void GetTop(LinkStack S, SElemType& e) {
	e = S->data;
}

//凹入法显示二叉树
void TreeOut(BiTree T, int h) {
	if (T!=NULL) {
		cout << "\t";
		for (int i = 1; i <= 5 * h; i += 2)
			cout << "  ";
		cout <<" " << T->data;
		for (int i = 5 * h + 2; i <= 50; i += 2)
			cout << "--";
		cout << "\n";
		TreeOut(T->lchild, h + 1);
		TreeOut(T->rchild, h + 1);
	}
	else {
		cout << "\t";
		for (int i = 1; i <= 5 * h; i += 2)
			cout << "  ";
		cout << " 0";//空结点
		for (int i = 5 * h + 2; i <= 50; i += 2)
			cout << "--";
		cout << "\n";
	}
}

//创建二叉树
void CreateTree(BiTree& T) {
	TElemType x;
	cin >> x;
	if (x == '0')   T = NULL;
	else {
		T = new BiNode;
		T->data = x;
		cout << "\n\t\t请输入"<<T->data<<"结点的左子结点：";
		CreateTree(T->lchild);
		cout << "\n\t\t请输入" << T->data << "结点的右子结点：";
		CreateTree(T->rchild);
	}
}

//计算结点数（递归）
int num = 0;
void Number(BiTree bt) {
	if (!bt) return;
	num++;   //累加结点数
	Number(bt->lchild);
	Number(bt->rchild);
}

//深度(递归)
int hl, hr;
int Depth(BiTree bt) {
	if (!bt) return 0;
	hl = Depth(bt->lchild);  //计算bt的左子树深度
	hr = Depth(bt->rchild);  //计算bt的右子树深度
	return (hl > hr ? (hl + 1) : (hr + 1));
}

int num_0 = 0;//计算叶子结点数的变量 
//计算叶子结点（递归）
void CountLeaf(BiTree T) {
	if (T) {
		if (T->lchild == NULL && T->rchild == NULL) num_0++;
		CountLeaf(T->lchild);
		CountLeaf(T->rchild);
	}
 }

//先序遍历算法（递归）
void PreOrder(BiTree T) {
	if (T) {
		cout << T->data;
		PreOrder(T->lchild);
		PreOrder(T->rchild);
	}
}
//先序遍历算法（非递归）栈
void PreOrderTraverse(BiTree bt) {
	if (!bt) return;
	InitStack(S);
	push(S, bt);   //树根的指针进栈
	while (!EmptyStack(S)) {
		BiNode* p;
		pop(S, p);//将栈顶元素弹出，并将其赋值给p
		while (p) {  //沿着左链一路向下
			cout << p->data << " "; //访问
			if (p->rchild)  push(S, p->rchild); //右孩子进栈
			p = p->lchild;
		}
	}
}


//中序遍历算法（递归）
void InOrder(BiTree T) {
	if (T) {
		InOrder(T->lchild);
		cout << T->data;
		InOrder(T->rchild);
	}
}
//中序遍历算法（非递归）栈
void InOrderTraverse(BiTree bt) {

	if (!bt) return;
	InitStack(S);
	BiNode* p = bt;
	while (p||!EmptyStack(S)) {
		while (p) {  //沿着左链一路向下

			push(S, p);//左孩子进栈
			p = p->lchild;
		}
		pop(S, p);
		cout << p->data << " "; //访问
		p = p->rchild;
	}
}

//后序遍历算法（递归）
void PostOrder(BiTree T) {
	if (T) {
		PostOrder(T->lchild);
		PostOrder(T->rchild);
		cout << T->data;
	}
}

//后序遍历算法（非递归）栈
//1、沿着根的左孩子，依次入栈，直到左孩子为空；
//2、读栈顶元素进行判定，若右孩子不空且未被访问，将右孩子执行第一步；
//3、栈顶元素出栈。
void PostOrderTraverse(BiTree bt) {

	if (!bt) return;
	InitStack(S);
	BiNode* p = bt,* r = NULL; // r标记最近访问过的结点;
	while (p || !EmptyStack(S)) {
		if(p) {  //沿着左链一路向下
			push(S, p);//左孩子进栈
			p = p->lchild;
		}
		else {
			GetTop(S, p);
			// 获取s的栈顶元素赋值给p
			// GetTop(s,p)意思就是判断栈顶元素的情况
			if (p->rchild && p->rchild != r) {
				// 若右孩子存在且未被访问
				p = p->rchild;  // 就让右孩子
				push(S, p);  // 入栈
				p = p->lchild;  // 让右孩子向左
				//上面三句意思就是让右孩子的左孩子一直入栈，一直向左走
			}
			else {
				pop(S, p);  // 右孩子为空或未被访问过，就出栈
				cout << p->data << " ";
				r = p;  // r标记最近访问结点
				p = NULL;  // p置空
				// 置空原因：因为这个结点已经出栈了
				//继续指向就没必要了，置空后p不标记任何结点
			}
		}
	
	}
}

//层序遍历（队列的思想）
void LevelTraverse(BiNode* bt) {
	//按层次遍历二叉树算法
	if (!bt)   return;           //空树
	LinkQueue Q;
	InitQueue(Q);             //初始化空队列Q
	EnQueue(Q, bt);        //根入队
	while (!IsEmpty(Q)) {
		BiNode* p;
		DeQueue(Q, p);    //队头p出队
		cout << p->data << " ";     //访问p
		if (p->lchild) EnQueue(Q, p->lchild); //p的左孩子入队
		if (p->rchild) EnQueue(Q, p->rchild);  //p的右孩子入队
	}
}


int main() {
	BiTree T = NULL;
	char ch1, ch2, a;
	ch1 = 'y';
	while (ch1 == 'y' || ch1 == 'Y') {
		cout << "\n\n\n\n";
		cout << "\n\n\t\t\t\t二   叉    树\n";
		cout << "\n\t\t*********************************************";
		cout << "\n\t\t*           1----建 二 叉 树                *";
		cout << "\n\t\t*           2----凹 入 显 示                *";
		cout << "\n\t\t*           3----先 序 遍 历                *";
		cout << "\n\t\t*           4----中 序 遍 历                *";
		cout << "\n\t\t*           5----后 序 遍 历                *";
		cout << "\n\t\t*           6----层 序 遍 历                *";
		cout << "\n\t\t*           7----叶子结点个数               *";
		cout << "\n\t\t*           8----结 点 个 数                *";
		cout << "\n\t\t*           9----二叉树的深度               *";
		//cout << "\n\t\t*          10----删除最小值                 *";
		//cout << "\n\t\t*          11----删除最大值                 *";//这是二叉排序树里面的
		cout << "\n\t\t*           0----返       回                *";
		cout << "\n\t\t*********************************************";
		cout << "\n\t\t请选择菜单号：";
		cin >> ch2;
		cout << "\n";
		switch (ch2)
		{
		case'1':
			cout << "\n\t\t请输入按先序建立二叉树的结点序列：";
			cout << "\n\t\t说明：'0'代表结点为空，请逐个输入，按回车输入下一个结点。";
			cout << "\n\t\t请输入根结点：";
			CreateTree(T);
			cout << "\n\t\t二叉树成功建立！\n";
			break;
		case'2':
			TreeOut(T, 1);
		case'3':
			cout << "\n\t\t该二叉树的先序遍历序列(递归)为：";
			PreOrder(T);
			cout << "\n\t\t该二叉树的先序遍历序列(非递归)为：";
			PreOrderTraverse(T);
			break;
		case'4':
			cout << "\n\t\t该二叉树的中序遍历序列(递归)为：";
			InOrder(T);
			cout << "\n\t\t该二叉树的中序遍历序列（非递归）为：";
			InOrderTraverse(T);
			break;
		case'5':
			cout << "\n\t\t该二叉树的后序遍历序列(递归)为：";
			PostOrder(T);
			cout << "\n\t\t该二叉树的后序遍历序列(非递归)为：";
			PostOrderTraverse(T);
			break;
		case'6':
			cout << "\n\t\t该二叉树的层序遍历序列为：";
			LevelTraverse(T);
			break;
		case'7':
			CountLeaf(T);
			cout << "\n\t\t该二叉树的叶子结点个数为：" << num_0;
			break;
		case'8':
			Number(T);
			cout << "\n\t\t该二叉树的结点个数为：" << num;
			break;
		case'9':
			
			cout << "\n\t\t该二叉树的深度为：" << Depth(T);
			break;
		case'0':
			ch1 = 'n';
			break;
		default:
			cout << "\n\t\t***请注意：输入有误！***";
		}
		
	}
	return 0;
}

小月球～
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值