浙大2020年Mooc数据结构笔记--第三讲树(上)

已于 2022-03-31 18:35:11 修改
阅读量311 收藏 2
点赞数 2
CC 4.0 BY-SA版权
文章标签： 数据结构 二叉树
于 2020-04-19 10:58:58 首次发布
原文链接：https://blog.youkuaiyun.com/TeFuirnever/article/details/104977308
本文详细解析了二叉树的概念、性质及遍历算法，通过具体实例介绍了树的同构判断方法，并提供了树相关操作的C语言实现代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

浙大2020年Mooc数据结构笔记–第三讲 树

〇、前言

  • 这几天开始跟着学数据结构，鉴于当初数据结构实在学的太弱，加之这项工作算是为大家之后复习、机试铺路。确实是一个迫切需要做的大规模工作。行胜于言，虽然从第二篇开始，坚持下去。

这眉毛和我很像

  • 此文部分为自己写，部分参考网上内容。提前说一下哈。期待批评指正。

一、树的定义

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

二、树的基本术语

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

三、二叉树

在这里插入图片描述

四、二叉树的性质

在这里插入图片描述

五、二叉树的基本操作

二叉树是一个又穷的节点集合，若不为空，则由根节点和左右二叉子树所构成
二叉树的相关操作如下：

  • Boolean IsEmpty(BinTree BT):判断二叉树是否为空。
  • void Traversal(BinTree BT):按照某一顺序遍历二叉树。
  • BinTree CreatBinTree():创建一个二叉树。
  • void PreOrderTraversal(BinTree BT):先序遍历
  • void InOrderTraversal(BinTree BT):中序遍历
  • void PostOrderTraversal(BinTree BT):后序遍历
  • void LevelOrderTraversal(BInTree BT):层次遍历

六、二叉树的遍历

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

七、树的同构

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

八、课后题

在这里插入图片描述

1、树1 树的同构 (25分)

在这里插入图片描述
在这里插入图片描述
输入样例1（对应图1）：

8
A 1 2
B 3 4
C 5 -
D - -
E 6 -
G 7 -
F - -
H - -
8
G - 4
B 7 6
F - -
A 5 1
H - -
C 0 -
D - -
E 2 -

输出样例1:

Yes

输入样例2（对应图2）：

8
B 5 7
F - -
A 0 3
C 6 -
H - -
D - -
G 4 -
E 1 -
8
D 6 -
B 5 -
E - -
H - -
C 0 2
G - 3
F - -
A 1 4

输出样例2:

No

#include <stdio.h>
#define MaxTree 10
#define ElementType char
#define Tree int
#define Null -1

struct TreeNode{
	ElementType Element;
	Tree Left;
	Tree Right;
}T1[MaxTree],T2[MaxTree];

Tree BuildTree(struct TreeNode T[]){
	int N,i,check[MaxTree],Root=Null;
	ElementType cl,cr;
	scanf("%d\n",&N);
	if(N){
		for(i=0;i<N;i++)
			check[i]=0;
		for(i=0;i<N;i++){
			scanf("%c %c %c\n",&T[i].Element,&cl,&cr);
			if(cl!='-'){
				T[i].Left=cl-'0';
				check[T[i].Left]=1;
			}
			else{
				T[i].Left=Null;
			}
			if(cr!='-'){
				T[i].Right=cr-'0';
				check[T[i].Right]=1;
			}
			else{
				T[i].Right=Null;
			}
		}
		for(i=0;i<N;i++){
			if(!check[i]){
				Root=i;
				break;
			}
		}
	}
	return Root;
}

int Isomorphic(Tree R1,Tree R2){
    //两树为空树，则为同构
	if((R1==Null)&&(R2==Null))
		return 1;
    //一个树为空，另一个不为空，则不同构
	if(((R1==Null)&&(R2!=Null))||((R1!=Null)&&(R2==Null)))
		return 0;
    //两树根结点存在但数据不同，则不同构
	if(T1[R1].Element!=T2[R2].Element)
		return 0;
    //两树左子树均为空树，则判断两树右子树是否同构
	if((T1[R1].Left==Null)&&(T2[R2].Left==Null))
		return Isomorphic(T1[R1].Right,T2[R2].Right);
	//两树左子树不为空，且两树左子树数据相等，则判断两树左子树和右子树是否同时同构
	if((T1[T1[R1].Left].Element==T2[T2[R2].Left].Element)&&(T1[R1].Left!=Null)&&(T2[R2].Left!=Null))
		return (Isomorphic(T1[R1].Left,T2[R2].Left)&&Isomorphic(T1[R1].Right,T2[R2].Right));
	//否则交换判断子树是否同构
    else
		return (Isomorphic(T1[R1].Left,T2[R2].Right)&&Isomorphic(T1[R1].Right,T2[R2].Left));
	
}

int main(){
	Tree R1,R2;
	R1=BuildTree(T1);
	R2=BuildTree(T2);
	if(Isomorphic(R1,R2))
		printf("Yes\n");
	else
		printf("No\n");
}

2、03-树2 List Leaves (25分)

在这里插入图片描述
Sample Input:

8
1 -
- -
0 -
2 7
- -
- -
5 -
4 6

Sample Output:
4 1 5

#include <stdio.h>
#include <stdlib.h>

#define MaxTree 10
#define Tree int
#define Null -1

struct TreeNode {
    Tree Left;
    Tree Right;
} T1[MaxTree];

#define QueueSize 100
typedef int Position;
typedef int ElementType;
struct QNode {
    ElementType *Data;     /* 存储元素的数组 */
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;
 
Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}
 
int IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}
 
int AddQ( Queue Q, ElementType X )
{
    if ( IsFull(Q) ) {
        printf("队列满");
        return;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MaxSize;
        Q->Data[Q->Rear] = X;
        return;
    }
}
 
int IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}
 
ElementType DeleteQ( Queue Q )
{
    if ( IsEmpty(Q) ) { 
        printf("队列空");
        return Null;
    }
    else  {
        Q->Front =(Q->Front+1)%Q->MaxSize;
        return  Q->Data[Q->Front];
    }
}

Tree BuildTree(struct TreeNode T[])
{
    char cl, cr;
    int N, i, check[MaxTree];
    Tree Root = Null;
    scanf("%d\n", &N);
    if(N) {
        for(i=0;i<N;i++)
            check[i] = 0;
        for(i=0;i<N;i++) {
            scanf("%c %c\n", &cl, &cr);
            if(cl!='-') {
                T1[i].Left = cl - '0';
                check[T1[i].Left] = 1;
            } else
                T1[i].Left = Null; 

            if(cr!='-') {
                T1[i].Right = cr - '0';
                check[T1[i].Right] = 1;
            } else
                T1[i].Right = Null;
        }
        for(i=0;i<N;i++)
            if(check[i] != 1) break;
        Root = i;
    }
    return Root;
}

void PrintLeaves(Tree R)    //层序遍历
{
    Queue Q;
    Tree cur;
    int count = 0;
    if(R==Null) return;
    Q=CreateQueue(QueueSize);
    AddQ(Q, R);
    while(!IsEmpty(Q)) {
        cur = DeleteQ(Q);
        if((T1[cur].Left == Null) && (T1[cur].Right == Null)) {
            if(!count) {
                printf("%d", cur);
                count++;
            } 
			else{
            	printf(" %d", cur);
            	continue;
			}
        }
        if(T1[cur].Left!=Null) AddQ(Q, T1[cur].Left);
        if(T1[cur].Right!=Null) AddQ(Q, T1[cur].Right);
    }
}

int main()
{
    Tree R;
    R = BuildTree(T1);
    PrintLeaves(R);
    return 0;
}

3、03-树3 Tree Traversals Again (25分)

在这里插入图片描述

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

int count = 0;
//使用链式存储树结构 
typedef struct TreeNode *BinTree;
struct TreeNode {
    int Data;
    BinTree Left;
    BinTree Right;
};


typedef struct SNode *Stack;
struct SNode {
    BinTree Data;
    Stack Next;
};

BinTree CreateBinTree(int data){
	BinTree head;
	head = (BinTree)malloc(sizeof(struct TreeNode));
	head->Data = data;
	head->Left = NULL;
	head->Right = NULL;
	return head; 
} 

int IsEmptyBinTree(BinTree BST)
{
    return (BST == NULL);
}

//插入左叶子 
void InsertLeftLeafe(BinTree BST,int leftData){
	BinTree left;
	left = (BinTree)malloc(sizeof(struct TreeNode));
	left->Data = leftData;
	left->Left = NULL;
	left->Right = NULL;
	BST->Left = left;	
}

//插入右叶子 
void InsertRightLeafe(BinTree BST,int rightData){
	BinTree right;
	right = (BinTree)malloc(sizeof(struct TreeNode));
	right->Data = rightData;
	right->Left = NULL;
	right->Right = NULL;
	BST->Right = right;
}

Stack CreateStack()
{
    Stack S = (Stack)malloc(sizeof(struct SNode));
    S->Data = NULL;
    S->Next = NULL;
    return S;
}

int IsEmptyStack(Stack S)
{
    return (S->Next == NULL);
}

void StackPush(Stack S, BinTree pos)
{
    Stack TmpCell = (Stack)malloc(sizeof(struct SNode));
    TmpCell->Data = pos;
    TmpCell->Next = S->Next;
    S->Next = TmpCell;
}

BinTree StackPop(Stack S)
{
    Stack FirstCell;
    BinTree pos;
    if(S->Next == NULL) {
        printf("Stack Empty");
        return NULL;
    } 
	else {
        FirstCell = S->Next;
        S->Next = FirstCell->Next;
        pos = FirstCell->Data;
        free(FirstCell);
        return pos;
    }
}

void PrintStack(Stack S)
{
    Stack head = S;
    while(head) {
        printf("%p ", head->Next);
        head = head->Next;
    }
    printf("\n");
}

BinTree Read(){
	int N,data,count=0;
	char str[10];
	Stack S = CreateStack();
	BinTree head;
	BinTree BT = CreateBinTree(0);
	head = BT;
	scanf("%d\n",&N);
	scanf("Push %d\n",&BT->Data);
	StackPush(S,BT);
	count++;
	if(N){
		while(!IsEmptyStack(S)||count<N){
			scanf("%s",str);
			if(strcmp("Push",str) == 0){
				scanf("%d",&data);
				if(BT->Left == NULL){
					InsertLeftLeafe(BT, data);
                    BT = BT->Left;
                    StackPush(S, BT);
                    count++;
				} 
				else if(BT->Right==NULL) {
                    InsertRightLeafe(BT, data);
                    BT = BT->Right;
                    StackPush(S, BT);
                    count++;
                }
				else{
					printf("can't go here\n");
				} 
			}
			else{
				BT = StackPop(S);
			}
		}
		return head;
	}
	return NULL;
} 

void PostOrderTraversal(BinTree BT){
	if(BT){
		PostOrderTraversal(BT->Left); 
		PostOrderTraversal(BT->Right); 
		if(!count) {
            printf("%d", BT->Data);
            count++;
        } 
		else {
            printf(" %d", BT->Data);
        }
	}
}




int main(){
	int N;
    BinTree BT;
    BT = Read();
    PostOrderTraversal(BT);
	return 0;
}

总结

二叉树的操作主要涉及递归的成分，同构部分不是很理解，其他的课后题只需要在基本操作上做小小的改动即可。

Mikesuper_blog
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值