二叉树

最新推荐文章于 2023-03-12 16:18:00 发布
原创 最新推荐文章于 2023-03-12 16:18:00 发布 · 438 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

资料

C语言实现常用数据结构——二叉树
【数据结构 严蔚敏版】 二叉树 基本操作

二叉树的基本操作

// CPPTest.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include "testaa.h"
#include <string>
#include <limits>
#include <ctime>
#include <cstdlib>
#include <string>
#include <ctime>
#include <cstring>
#include "Box.h"
#include "A.h"
#include "FJUtils.h"

using namespace std;

#define MAX_TREE_SIZE 100 //二叉树的最大节点数

#define STATUS_OK 1
#define STATUS_FAIL 2


typedef int Status;

typedef struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
}BiTNode, *BiTree;

//定义队列节点
typedef struct QNode {
	BiTNode* data;
	struct QNode* next;
}QNode, *QueuePtr;

typedef struct {
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

// 队列的操作
// 建立队列
Status InitQueue(LinkQueue& Q);
// 入队
Status EnQueue(LinkQueue& Q, BiTree& T);
// 判空
Status QueueEmpty(LinkQueue Q);
// 元素出队列
Status DeQueue(LinkQueue& Q, BiTree& T);
// 遍历队列元素
Status QueueTraverse(LinkQueue Q);


BiTNode* initNode(BiTNode* t, char x) {
	if (t == NULL) {
		t = (BiTNode*)malloc(sizeof(BiTNode));
		t->data = x;
		t->lchild = NULL;
		t->rchild = NULL;
	}
	else if (t->lchild == NULL) {
		t->lchild = initNode(t->lchild, x);
		return t;
	}
	else {
		t->rchild = initNode(t->rchild, x);
		return t;
	}
}

//------基本操作的函数原型说明--------
Status CreateBiTree(BiTree& T);
	//按先序次序输入二叉树中节点的值（一个字符），空格字符表示空树
    //构造二叉树表示的二叉树T
Status PreOrderTraverse(BiTree T, int level);
	//采用二叉树链表存储结构，Visit是对节点操作的应用函数
	//先序遍历二叉树T，对每个节点调用函数Visit一次且近义词 
	//一旦Visit（）失败，则 操作失败
Status InOrderTraverse(BiTree T, int level);
	//采用二叉链表存储结构，Visit是对节点操作的应用函数
	//中序遍历二叉树T，对每个节点调用函数Visit一次且仅以此
	//一旦visit失败，则操作失败
Status PostOrderTraverse(BiTree T, int level);
	//采用二叉链表存储结构，Visit是对节点操作的应用函数
	//后序遍历二叉树T，对每个节点调用函数Visit一次且仅以此
	//一旦visit（）失败，则操作失败
Status LevelOrderTraverse(BiTree T, Status(*Visit)(int e));
	//采用二叉链表存储结构，Visit是对节点操作的应用函数
	//层序遍历二叉树T，对每个节点调用函数Visit一次且仅一次
	//一旦visit（）失败，则操作失败

void testBiTree();
void Menu();

// 变量声明
int main()
{
	testBiTree();
	return 0;
}


void Menu()
{
	cout << "                   二叉树基本操作                  " << endl;
	cout << "***************************************************" << endl;
	cout << "*********        1.建立二叉树         *************" << endl;
	cout << "*********        2.先序遍历二叉树     *************" << endl;
	cout << "*********        3.中序遍历二叉树     *************" << endl;
	cout << "*********        4.后序遍历二叉树     *************" << endl;
	cout << "*********        5.层序遍历二叉树     *************" << endl;
	cout << "*********        6.二叉树的高度       *************" << endl;
	cout << "*********        7.二叉树叶子数       *************" << endl;
	cout << "*********        8.完全二叉树         *************" << endl;
	cout << "*********        9.清空二叉树         *************" << endl;
	cout << "*********        10.退出              *************" << endl;
	cout << "***************************************************" << endl;
}

static char chTmp;
static int index=0;


char getCharsFromCosntChar() {
	char mycharts[] = "ABC@@DE@G@@F@@@";
	int len = my_strlen(mycharts);
	if (index < my_strlen(mycharts)) {
		char c = mycharts[index];
		index++;
		return c;
	}
	return '@';
}

void testCreateBiTree() {
	char mychars[] = "ABC@@DE@G@@F@@@";
	int len = my_strlen(mychars);

	BiTree T;
	CreateBiTree(T);
	printf("\n");
	printf("先序遍历\n");
	PreOrderTraverse(T, 1);
	printf("中序遍历\n");
	InOrderTraverse(T, 1);
	printf("后序遍历\n");
	PostOrderTraverse(T, 1);
}

void testBiTree() {
	/*
	BiTree T;
	Menu();
	printf_s("1.创建一棵二叉树：");
	if (CreateBiTree(T))
	{
		printf("创建成功");
	}
	else {
		printf("创建失败");
	}
	*/
	testCreateBiTree();

}


// 队列操作
// 建立队列
Status InitQueue(LinkQueue& Q) {
	Q.front = (QueuePtr)malloc(sizeof(QNode));
	if (!Q.front) {
		printf("内存分配失败，程序退出！！");
		exit(-1);
	}
	Q.rear = Q.front;
	Q.front->next = NULL;
	return STATUS_OK;
}
// 入队
Status EnQueue(LinkQueue& Q, BiTree& T) {
	QueuePtr p;
	p = (QueuePtr)malloc(sizeof(QNode));
	if (!p) {
		printf("内存分配失败，程序退出！！");
		exit(-1);
	}
	p->data = T;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	return STATUS_OK;
}
// 判空
Status QueueEmpty(LinkQueue Q) {
	if (Q.front == Q.rear) {
		return STATUS_FAIL;
	}
	else {
		return STATUS_OK;
	}
}
// 元素出队列
Status DeQueue(LinkQueue& Q, BiTree& T) {
	QueuePtr p;
	if (Q.front == Q.rear) {
		return STATUS_FAIL;
	}
	p = Q.front->next;
	T = p->data;
	Q.front->next = p->next;
	if (Q.rear==p) {
		Q.rear = Q.front;
	}
	free(p);
	return STATUS_OK;
}
// 遍历队列元素
Status QueueTraverse( LinkQueue Q) {
	int i;
	if (Q.front==Q.rear) {
		return STATUS_FAIL;
	}

	for (i = 0; Q.front != Q.rear;i++) {
		Q.front = Q.front->next;
		printf("data=%c",Q.front->data->data);
	}

	printf("\n");
	return STATUS_OK;
}





Status CreateBiTree(BiTree &T)
{
	// 按先序次序输入二叉树中==≠≠≠节点的值（一个字符），空格字符表示空树
	//构造二叉链表表示的二叉树T
	char ch = getCharsFromCosntChar();
	//int si = scanf("%c", &ch);
	printf("CreateBiTree->输入的字符是:%c\n", ch);
	if (ch == '@') {
		T = NULL;
	}
	else {
		if(!(T = (BiTNode *)malloc(sizeof(BiTNode)))) exit(OVERFLOW);
		T->data = ch; //生成根节点
		printf("CreateBiTree->创建左节点");
		CreateBiTree(T->lchild);
		printf("CreateBiTree->创建右节点");
		CreateBiTree(T->rchild);
	}
	return STATUS_OK;
}


Status PreOrderTraverse(BiTree T,int level) {

	if (T) {
		printf("level-%d==>%c\n", level, T->data);//访问根节点
		PreOrderTraverse(T->lchild, level + 1);//先遍历左zishu
		PreOrderTraverse(T->rchild, level + 1);//最后遍历右字树
	}

	return STATUS_OK;
}

Status InOrderTraverse(BiTree T, int level) {
	if (T) {
		InOrderTraverse(T->lchild, level+1); //先遍历左子树
		printf("level-%d==>%c\n", level, T->data);//访问根节点
		InOrderTraverse(T->rchild, level+1);
	}
	return STATUS_OK;
}

Status PostOrderTraverse(BiTree T, int level) {
	if (T) {
		PostOrderTraverse(T->lchild, level + 1);//先访问左子树
		PostOrderTraverse(T->rchild, level + 1);//再访问右子树
		printf("level-%d==>%c\n", level, T->data);//访问根节点
	}
	return STATUS_OK;
}

c语言中的二叉树

#include<stdio.h>
#include<stdlib.h>
#define SIZE 10
typedef struct Tree {
    int data;
    struct Tree *left;
    struct Tree *right;
} tree;



int find(tree *t,int x) {
    int i=0;
    if(t==NULL) {
        return -1;
    }
    if(t->data==x) {
        return i;
    } else if(x<t->data) {
        i++;
        find(t->left,x);
    } else if(x>t->data) {
        i++;
        find(t->right,x);
    }
}

tree *findMin(tree *t) {
    if(t==NULL) {
        return NULL;
    } else if(t->left==NULL) {
        return t;
    } else {
        return findMin(t->left);
    }
}

int findMax(tree *t) {
    if(t!=NULL) {
        while(t->right!=NULL) {
            t=t->right;
        }
    }
    return t->data;
}

tree *init(tree *t,int x) {
    if(t==NULL) {
        t=malloc(sizeof(tree));
        t->data=x;
        t->left=NULL;
        t->right=NULL;
        return t;
    } else if(t->left ==NULL) {
        t->left=init(t->left,x);
        return t;
    } else {
        t->right=init(t->right,x);

        return t;
    }
}



tree *insertSort(tree *t,int x) {
    if(t==NULL) {
        t=malloc(sizeof(tree));
        t->data=x;
        t->left=NULL;
        t->right=NULL;
    } else if(x < t->data) {
        t->left=insertSort(t->left,x);
    } else if(x > t->data) {
        t->right=insertSort(t->right,x);
    }
    return t;
}


tree *delete(tree *t,int x) {
    tree *temp;
    if(t==NULL) {
        printf("error,element not found!");
    } else if( x < t->data ) {/*go left*/
        t->left=delete(t->left,x);
    } else if( x > t->data ) {/*go right*/
        t->right=delete( t->right,x );
    } else if( t->left && t->right) { /*t->data==x and t has two children*/
        temp=findMin( t->right );
        t->data=temp->data;
        t->right=delete( t->right,t->data );
    } else {/*one or zero children */
        temp=t;
        if( t->left==NULL) {
            t=t->right;
        } else if( t->right == NULL ) {
            t=t->left;
        }
        free(temp);
    }
    return t;
}

void preTravel(tree *t) {
    if(t==NULL) {
        return;
    }
    printf("%d ",t->data);
    preTravel(t->left);
    preTravel(t->right);
}

void midTravel(tree *t) {
    if(t==NULL) {
        return;
    }
    midTravel(t->left);
    printf("%d ",t->data);
    midTravel(t->right);
}

void postTravel(tree *t) {
    if(t==NULL) {
        return;
    }
    postTravel(t->left);
    postTravel(t->right);
    printf("%d ",t->data);
}

main() {
    tree *t;
    int i;
    for(i=0; i<SIZE; i++) {
        t=init(t,i);
    }
    preTravel(t);
    printf("\n");
    midTravel(t);
    printf("\n");
    postTravel(t);
}

C++版的二叉树

百度2020校招C++/PHP研发工程师笔试卷（第三批）
lvlongjuan的博客
03-11 728
下列关于关键路径的叙述中错误的是（D）A关键路径是指在带权有向图中从源点到汇点的所有路径中具有最大路径长度的路径；B关键路径上的所有活动都是关键活动，可通过加快关键活动来缩短整个工程的工期；CAOE网中，关键路径上活动的时间延长多少，整个工程的时间也就随之延长多少；DAOE网中的关键路径并不唯一，可通过加快某一条关键路径中关键活动速度来缩短整个工程工期；单选题对于数列4、5、6、7、9、12、18、23，如果采用折半查找元素9，请问需要查找几次？（B）A2。
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
【题解】百度2020校招Web前端工程师笔试卷（第三批）：单选题、多选题
karshey的博客
03-12 1069
【题解】百度2020校招Web前端工程师笔试卷（第三批）：单选题、多选题
找的笔试题的复盘(一)
qq_51955445的博客
07-31 1805
自己找的笔试测试 复盘
力扣 面试题37. 序列化二叉树 bfs
xiji333的博客
04-22 297
思路：自己规定格式，字符串处理很恶心的不过可以用ostringstreamostringstreamostringstream和stringstreamstringstreamstringstream简化操作。想法其实很简单，bfsbfsbfs构造就行了。 /** * Definition for a binary tree node. * struct TreeNode { * i...
完全二叉树通过先序、中序、后序序列来构造二叉树（即得到层次遍历序列）
qq_45001063的博客
06-06 1012
根据完全二叉树的先、中、后序构造完全二叉树的序列化数组（层次遍历数组）
精选资源
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
精选资源
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
易语言二叉树遍历
07-21
在易语言中，处理数据结构如二叉树是一项常见的任务，特别是在处理递归和树形结构的数据时。二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： ...
二叉树模拟器.py二叉树模拟器.py
07-24
二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py...
力扣刷题记录-二叉树的结构相关题目
qq_41857397的博客
04-29 634
对力扣中有关二叉树结构的一些题目进行汇总记录，包括每一题的多种解法。
二叉树的详解与实现
注意路标
08-18 16万+
简介 二叉树的相关概念，如，树高度，节点层数，节点度数，路径，叶节点，分支节点，根节点，父节点，左节点，右节点，兄弟节点，祖先节点，子孙节点，左子树，右子树等基本概念，不再赘述。 二叉树分类 1、完全二叉树 若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。 一维数组可以作为完全二叉树...
2020团体程序设计天梯赛L2-3完全二叉树的层序遍历（将后序遍历转换为层序遍历）
beautfullboy的博客
11-28 3664
一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是完美二叉树。对于深度为 D 的，有 N 个结点的二叉树，若其结点对应于相同深度完美二叉树的层序遍历的前 N 个结点，这样的树就是完全二叉树。 给定一棵完全二叉树的后序遍历，请你给出这棵树的层序遍历结果。 输入格式： 输入在第一行中给出正整数 N（≤30），即树中结点个数。第二行给出后序遍历序列，为 N 个不超过 100 的正整数。同一行中所有数字都以空格分隔。 输出格式： 在一行中输出该树的层序遍历序列。所有数字都以 1 个空格分隔，行首尾不得有
队列建立完全二叉树
myblog
11-05 5273
完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。比如下面这棵树就是一棵完全二叉树通过图片我们可以了解到它的创建过程是从上到下，从左至右的，也就是说，它是一层一层建立的。完全二叉树有以下基本性质： 对于一棵有n个结点的完全二叉树，其任意结点 i (1<=i<=n)，如果 i = 1, 则结点
Android版数据结构与算法(六):树与二叉树
weixin_30301183的博客
10-08 188
版权声明：本文出自汪磊的博客，未经作者允许禁止转载。 之前的篇章主要讲解了数据结构中的线性结构，所谓线性结构就是数据与数据之间是一对一的关系，接下来我们就要进入非线性结构的世界了，主要是树与图，好了接下来我们将会了解到树以及二叉树，二叉平衡树，赫夫曼树等原理以及java代码的实现，先从最基础的开始学习吧。 一、树 树的定义： 树是n(n>=0)个结点的有限集合。 当n=0时，集合...
mamba-ssm-2.2.2-cp310-cp310-win-amd64.whl+安装环境+测试脚本.7z
最新发布
12-15
编译环境： vs2022 win10 x64 anaconda3+python3.10 torch==2.3.1+cu118 cuda11.8.0+cudnn8.9.7 triton==2.1.0 causal_conv1d==1.4.0 mamba==2.2.2 RTX2070显卡 注意编译的whl是不能用于RTX50显卡的，可以用于RTX20-RTX40系列显卡，安装时候尽量和模块一致
toplus1s_calculator_32040_1765656584703.zip
12-15
toplus1s_calculator_32040_1765656584703.zip
【创新无忧】基于多元宇宙优化算法MVO优化相关向量机RVM实现数据多输入单输出回归预测附matlab代码.zip
12-15
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

赵健zj

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

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

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

打赏作者

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

抵扣说明：

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

余额充值