2015-11-16 【项目1 - 二叉树算法验证】

最新推荐文章于 2017-11-09 10:45:12 发布
最新推荐文章于 2017-11-09 10:45:12 发布
阅读量791 收藏
点赞数
文章标签： 上机 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SupreEvi/article/details/49867233
版权

1.问题及代码

运行并重复测试教学内容中涉及的算法。改变测试数据进行重复测试的意义在于，可以从更多角度体会算法，以达到逐渐掌握算法的程度。使用你的测试数据，并展示测试结果，观察运行结果，以此来领会算法。 

（1）层次遍历算法的验证

 实现二叉树的层次遍历算法，并对用”A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”创建的二叉树进行测试。 
 请利用二叉树算法库。

#include <stdio.h>
#include "btree.h"

void LevelOrder(BTNode *b)
{
    BTNode *p;
    BTNode *qu[MaxSize];    //定义环形队列,存放节点指针
    int front,rear; //定义队头和队尾指针
    front=rear=-1;      //置队列为空队列
    rear++;
    qu[rear]=b;     //根节点指针进入队列
    while (front!=rear) //队列不为空
    {
        front=(front+1)%MaxSize;
        p=qu[front];        //队头出队列
        printf("%c ",p->data);  //访问节点
        if (p->lchild!=NULL)    //有左孩子时将其进队
        {
            rear=(rear+1)%MaxSize;
            qu[rear]=p->lchild;
        }
        if (p->rchild!=NULL)    //有右孩子时将其进队
        {
            rear=(rear+1)%MaxSize;
            qu[rear]=p->rchild;
        }
    }
}

int main()
{
    BTNode *b;
    CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
    printf("二叉树b: ");
    DispBTNode(b);
    printf("\n");
    printf("层次遍历序列:\n");
    LevelOrder(b);
    DestroyBTNode(b);
    return 0;
}

这里写图片描述

（2）二叉树构造算法的验证 

1.由先序序列和中序序列构造二叉树

  • 定理：任何n（n≥0）个不同节点的二叉树，都可由它的中序序列和先序序列唯一地确定。
  • 证明（数学归纳法） 
    基础：当n=0时，二叉树为空，结论正确。 
    假设：设节点数小于n的任何二叉树，都可以由其先序序列和中序序列唯一地确定。 
    归纳：已知某棵二叉树具有n（n＞0）个不同节点，其先序序列是 a0a1…an−1 ；中序序列是 b0b1…bk−1bkbk+1…bn−1 。 
    • 先序遍历“根-左-右”， a0 必定是二叉树的根节点
    • a0 必然在中序序列中出现，设在中序序列中必有某个 bk（0≤k≤n−1） 就是根节点 a0 。 
      这里写图片描述
    • 由于 bk 是根节点，中序遍历“左-根-右”，故中序序列中 b0b1…bk−1 必是根节点 bk(a0) 左子树的中序序列，即 bk 的左子树有k个节点， bk+1…bn−1 必是根节点 bk（a0） 右子树的中序序列，即 bk 的右子树有 n−k−1 个节点。
    • 对应先序序列，紧跟在根节点 a0 之后的k个节点 a1…ak 是左子树的先序序列， ak+1…an−1 这 n−k−1 就是右子树的先序序列。 
      这里写图片描述
    • 根据归纳假设，子先序序列 a1…ak 和子中序序列 b0b1…bk−1 可以唯一地确定根节点 a0 的左子树，而先序序列 ak+1…an−1 和子中序序列 bk+1…bn−1 可以唯一地确定根节点 a0 的右子树。
    • 综上所述，这棵二叉树的根节点己经确定，而且其左、右子树都唯一地确定了，所以整个二叉树也就唯一地确定了。

  • 例 
    这里写图片描述

    根据定理的证明，写出下面的算法。

    品味：以上构造性证明是突出体现计算机科学的案例。计算机学科的精髓就在于制造，即使在“理论性”味道的定理中，其证明过程，给出的就是“存在的这么一个东西”的构造方法。

#include <stdio.h>
#include <malloc.h>
#include "btree.h"

BTNode *CreateBT1(char *pre,char *in,int n)
/*pre存放先序序列,in存放中序序列,n为二叉树结点个数,
本算法执行后返回构造的二叉链的根结点指针*/
{
    BTNode *s;
    char *p;
    int k;
    if (n<=0) return NULL;
    s=(BTNode *)malloc(sizeof(BTNode));     //创建二叉树结点*s
    s->data=*pre;
    for (p=in; p<in+n; p++)                 //在中序序列中找等于*ppos的位置k
        if (*p==*pre)                       //pre指向根结点
            break;                          //在in中找到后退出循环
    k=p-in;                                 //确定根结点在in中的位置
    s->lchild=CreateBT1(pre+1,in,k);        //递归构造左子树
    s->rchild=CreateBT1(pre+k+1,p+1,n-k-1); //递归构造右子树
    return s;
}

int main()
{
    ElemType pre[]="ABDGCEF",in[]="DGBAECF";
    BTNode *b1;
    b1=CreateBT1(pre,in,7);
    printf("b1:");
    DispBTNode(b1);
    printf("\n");
    return 0;
}

2.由后序序列和中序序列构造二叉树

  • 定理：任何n（n＞0）个不同节点的二叉树，都可由它的中序序列和后序序列唯一地确定。
  • 证明：(略) 
    这里写图片描述
#include <stdio.h>
#include <malloc.h>
#include "btree.h"

BTNode *CreateBT2(char *post,char *in,int n)
/*post存放后序序列,in存放中序序列,n为二叉树结点个数,
本算法执行后返回构造的二叉链的根结点指针*/
{
    BTNode *s;
    char r,*p;
    int k;
    if (n<=0) return NULL;
    r=*(post+n-1);                          //根结点值
    s=(BTNode *)malloc(sizeof(BTNode));     //创建二叉树结点*s
    s->data=r;
    for (p=in; p<in+n; p++)                 //在in中查找根结点
        if (*p==r)
            break;
    k=p-in;                                 //k为根结点在in中的下标
    s->lchild=CreateBT2(post,in,k);         //递归构造左子树
    s->rchild=CreateBT2(post+k,p+1,n-k-1);  //递归构造右子树
    return s;
}

int main()
{
    ElemType in[]="DGBAECF",post[]="GDBEFCA";
    BTNode *b2;
    b2=CreateBT2(post,in,7);
    printf("b2:");
    DispBTNode(b2);
    printf("\n");
    return 0;
}
3.由顺序存储结构转为二叉链存储结构 
这里写图片描述 
#include <stdio.h>
#include <malloc.h>
#include "btree.h"
#define N 30
typedef ElemType SqBTree[N];
BTNode *trans(SqBTree a,int i)
{
    BTNode *b;
    if (i>N)
        return(NULL);
    if (a[i]=='#')
        return(NULL);           //当节点不存在时返回NULL
    b=(BTNode *)malloc(sizeof(BTNode)); //创建根节点
    b->data=a[i];
    b->lchild=trans(a,2*i);                 //递归创建左子树
    b->rchild=trans(a,2*i+1);               //递归创建右子树
    return(b);                              //返回根节点
}
int main()
{
    BTNode *b;
    ElemType s[]="0ABCD#EF#G####################";
    b=trans(s,1);
    printf("b:");
    DispBTNode(b);
    printf("\n");
    return 0;
}
（3）中序线索化二叉树的算法验证
这里写图片描述 
#include <stdio.h>
#include <malloc.h>

#define MaxSize 100
typedef char ElemType;
typedef struct node
{
    ElemType data;
    int ltag,rtag;      //增加的线索标记
    struct node *lchild;
    struct node *rchild;
} TBTNode;

void CreateTBTNode(TBTNode * &b,char *str)
{
    TBTNode *St[MaxSize],*p=NULL;
    int top=-1,k,j=0;
    char ch;
    b=NULL;             //建立的二叉树初始时为空
    ch=str[j];
    while (ch!='\0')    //str未扫描完时循环
    {
        switch(ch)
        {
        case '(':
            top++;
            St[top]=p;
            k=1;
            break;      //为左结点
        case ')':
            top--;
            break;
        case ',':
            k=2;
            break;                          //为右结点
        default:
            p=(TBTNode *)malloc(sizeof(TBTNode));
            p->data=ch;
            p->lchild=p->rchild=NULL;
            if (b==NULL)                    //*p为二叉树的根结点
                b=p;
            else                            //已建立二叉树根结点
            {
                switch(k)
                {
                case 1:
                    St[top]->lchild=p;
                    break;
                case 2:
                    St[top]->rchild=p;
                    break;
                }
            }
        }
        j++;
        ch=str[j];
    }
}

void DispTBTNode(TBTNode *b)
{
    if (b!=NULL)
    {
        printf("%c",b->data);
        if (b->lchild!=NULL || b->rchild!=NULL)
        {
            printf("(");
            DispTBTNode(b->lchild);
            if (b->rchild!=NULL) printf(",");
            DispTBTNode(b->rchild);
            printf(")");
        }
    }
}

TBTNode *pre;                       //全局变量

void Thread(TBTNode *&p)
{
    if (p!=NULL)
    {
        Thread(p->lchild);          //左子树线索化
        if (p->lchild==NULL)        //前驱线索
        {
            p->lchild=pre;          //建立当前结点的前驱线索
            p->ltag=1;
        }
        else p->ltag=0;
        if (pre->rchild==NULL)      //后继线索
        {
            pre->rchild=p;          //建立前驱结点的后继线索
            pre->rtag=1;
        }
        else pre->rtag=0;
        pre=p;
        Thread(p->rchild);          //右子树线索化
    }
}

TBTNode *CreaThread(TBTNode *b)     //中序线索化二叉树
{
    TBTNode *root;
    root=(TBTNode *)malloc(sizeof(TBTNode));  //创建根结点
    root->ltag=0;
    root->rtag=1;
    root->rchild=b;
    if (b==NULL)                //空二叉树
        root->lchild=root;
    else
    {
        root->lchild=b;
        pre=root;               //pre是*p的前驱结点,供加线索用
        Thread(b);              //中序遍历线索化二叉树
        pre->rchild=root;       //最后处理,加入指向根结点的线索
        pre->rtag=1;
        root->rchild=pre;       //根结点右线索化
    }
    return root;
}

void ThInOrder(TBTNode *tb)
{
    TBTNode *p=tb->lchild;      //指向根结点
    while (p!=tb)
    {
        while (p->ltag==0) p=p->lchild;
        printf("%c ",p->data);
        while (p->rtag==1 && p->rchild!=tb)
        {
            p=p->rchild;
            printf("%c ",p->data);
        }
        p=p->rchild;
    }
}

int main()
{
    TBTNode *b,*tb;
    CreateTBTNode(b,"A(B(D(,G)),C(E,F))");
    printf(" 二叉树:");
    DispTBTNode(b);
    printf("\n");
    tb=CreaThread(b);
    printf(" 线索中序序列:");
    ThInOrder(tb);
    printf("\n");
    return 0;
}
（4）哈夫曼编码的算法验证

这里写图片描述

#include <stdio.h>
#include <string.h>

#define N 50        //叶子结点数
#define M 2*N-1     //树中结点总数

//哈夫曼树的节点结构类型
typedef struct
{
    char data;  //结点值
    double weight;  //权重
    int parent;     //双亲结点
    int lchild;     //左孩子结点
    int rchild;     //右孩子结点
} HTNode;

//每个节点哈夫曼编码的结构类型
typedef struct
{
    char cd[N]; //存放哈夫曼码
    int start;
} HCode;

//构造哈夫曼树
void CreateHT(HTNode ht[],int n)
{
    int i,k,lnode,rnode;
    double min1,min2;
    for (i=0; i<2*n-1; i++)         //所有结点的相关域置初值-1
        ht[i].parent=ht[i].lchild=ht[i].rchild=-1;
    for (i=n; i<2*n-1; i++)         //构造哈夫曼树
    {
        min1=min2=32767;            //lnode和rnode为最小权重的两个结点位置
        lnode=rnode=-1;
        for (k=0; k<=i-1; k++)
            if (ht[k].parent==-1)   //只在尚未构造二叉树的结点中查找
            {
                if (ht[k].weight<min1)
                {
                    min2=min1;
                    rnode=lnode;
                    min1=ht[k].weight;
                    lnode=k;
                }
                else if (ht[k].weight<min2)
                {
                    min2=ht[k].weight;
                    rnode=k;
                }
            }
        ht[i].weight=ht[lnode].weight+ht[rnode].weight;
        ht[i].lchild=lnode;
        ht[i].rchild=rnode;
        ht[lnode].parent=i;
        ht[rnode].parent=i;
    }
}

//实现哈夫曼编码
void CreateHCode(HTNode ht[],HCode hcd[],int n)
{
    int i,f,c;
    HCode hc;
    for (i=0; i<n; i++) //根据哈夫曼树求哈夫曼编码
    {
        hc.start=n;
        c=i;
        f=ht[i].parent;
        while (f!=-1)   //循序直到树根结点
        {
            if (ht[f].lchild==c)    //处理左孩子结点
                hc.cd[hc.start--]='0';
            else                    //处理右孩子结点
                hc.cd[hc.start--]='1';
            c=f;
            f=ht[f].parent;
        }
        hc.start++;     //start指向哈夫曼编码最开始字符
        hcd[i]=hc;
    }
}

//输出哈夫曼编码
void DispHCode(HTNode ht[],HCode hcd[],int n)
{
    int i,k;
    double sum=0,m=0;
    int j;
    printf("  输出哈夫曼编码:\n"); //输出哈夫曼编码
    for (i=0; i<n; i++)
    {
        j=0;
        printf("      %c:\t",ht[i].data);
        for (k=hcd[i].start; k<=n; k++)
        {
            printf("%c",hcd[i].cd[k]);
            j++;
        }
        m+=ht[i].weight;
        sum+=ht[i].weight*j;
        printf("\n");
    }
    printf("\n  平均长度=%g\n",1.0*sum/m);
}

int main()
{
    int n=8,i;      //n表示初始字符串的个数
    char str[]= {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
    double fnum[]= {0.07,0.19,0.02,0.06,0.32,0.03,0.21,0.1};
    HTNode ht[M];
    HCode hcd[N];
    for (i=0; i<n; i++)
    {
        ht[i].data=str[i];
        ht[i].weight=fnum[i];
    }
    printf("\n");
    CreateHT(ht,n);
    CreateHCode(ht,hcd,n);
    DispHCode(ht,hcd,n);
    printf("\n");
    return 0;
}



2.运行结果



3.知识总结

  二叉树的算法验证。


4.学习心得

SupreEvi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树相关算法的实验验证+判别给定二叉树是否为完全二叉树。
12-29
1、 定义链接存储的二叉树类。 2、 实验验证如下算法的正确性、各种功能及指标： 1） 创建一棵二叉树，并对其初始化； 2）先根、中根、后根遍历二叉树； 3） 在二叉树中搜索给定结点的父结点； 4） 搜索二叉树中符合数据域条件的结点； 3、 由教师随机指定树结构，测试上述功能； 判别给定二叉树是否为完全二叉树。两个要求写了一份代码
K-近邻算法KNN学习笔记
01-27
K-近邻算法（K-Nearest Neighbor, KNN）是一种基础的机器学习算法，主要用于分类和回归任务。它的核心思想是基于实例的学习，通过在训练数据集中寻找与新样本最为相似的邻居来做出预测。KNN算法由Cover T和Hart P在...
二叉树算法验证（2）二叉树构造算法的验证
wangjiyuan123的博客
11-16 336
问题描述: 运行并重复测试教学内容中涉及的算法。改变测试数据进行重复测试的意义在于， 可以从更多角度体会算法，以达到逐渐掌握算法的程度。 使用你的测试数据，并展示测试结果，观察运行结果，以此来领会算法。 输入描述： 若干测试数据。 程序输出： 对应数据的输出。 1.由先序和中序构造二叉树 BTNode *CreateBT1(char *pre,char *
第十一周项目1 - 二叉树算法验证（3）中序线索化二叉树的算法验证
liu的博客
11-13 512
问题及代码： /* Copyright (c)2015,烟台大学计算机与控制工程学院 All rights reserved. 文件名称：第十一周项目1 - 二叉树算法验证.cpp 作 者：刘强 完成日期：2015年11月13日 版 本 号：v1.0 问题描述: 运行并重复测试教学内容中涉及的算法。改变测试数据进行重复测试的意义在于， 可以从更多角度体会算法，以达到逐渐掌握算
数据结构上机实践第10周项目1 - 二叉树算法验证
Moresweet 猫甜
11-09 264
二叉树算法验证 本次实践主要是对于二叉树算法的验证，达成对于算法熟练掌握的目的。 实践所用的二叉树算法库点击此处可以参考（编译环境：VC++6.0） 一、层次遍历算法验证 验证具体要求如下： 实现二叉树的层次遍历算法，并对用”A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”创建的二叉树进行测试。 注：在main函数中，创建的用于测试的二叉树如下——
数据结构例程——二叉树的构造
weixin_33979745的博客
10-20 338
本文是数据结构基础系列(6)：树和二叉树中第13课时二叉树的构造的例程。 1.由先序序列和中序序列构造二叉树 定理：任何n（n≥0）个不同节点的二叉树，都可由它的中序序列和先序序列唯一地确定。 证明（数学归纳法） 基础：当n=0时，二叉树为空，结论正确。 假设：设节点数小于n的任何二叉树，都可以由其先序序列和中序序列唯一地确定。 ...
二维矩形装箱算法--二叉树--java实现
03-22
`TestMain.java`通常是测试驱动代码，包含了运行算法、打印结果和验证正确性的测试用例。`CarBlock.java`和`Car.java`分别表示车上的一个装载区域（区块）和整个车辆对象，可能包含了关于矩形尺寸、装载限制等属性和...
算法设计与分析--2NP完全理论.ppt
11-03
"算法设计与分析--2NP完全理论" 本节课程主要讨论算法设计与分析中的NP完全理论，涵盖了NP完全问题的概念、...确定性算法是指每一步都只有一个确定的选择的算法，而非确定性算法是指以猜测并验证的方式工作的算法。
8606-二叉树的构建及遍历操作.rar_二叉树_遍历算法
09-21
在ColdBlick环境下，可以编写对应的函数实现这些遍历算法，并通过测试数据验证其正确性。遍历算法的应用非常广泛，例如在查找、复制或删除树节点时，或者在打印树的结构时。 在“8606-二叉树的构建及遍历操作”这个...
cpp-算法导论第三版习题答案
08-16
1. **基础算法**：包括排序（如快速排序、归并排序、堆排序）、搜索（如二分查找、深度优先搜索、广度优先搜索）和图算法（如Dijkstra算法、Floyd-Warshall算法）。 2. **数据结构**：如数组、链表、栈、队列、树...
实验七 二叉树操作验证
04-27
实验七 二叉树操作验证 1. 实验目的 ⑴ 掌握二叉树的逻辑结构； ⑵ 掌握二叉树的二叉链表存储结构； ⑶ 掌握基于二叉链表存储的二叉树的遍历操作的实现。 2. 实验内容 ⑴ 建立一棵含有n个结点的二叉树，采用二叉链表存储； ⑵ 前序（或中序、后序）遍历该二叉树。
数据结构遍历二叉树算法C语言版(附完成版实验报告)
06-27
数据结构遍历二叉树算法(前序、中序、后序)，C语言版程序(附完成版实验报告)，完全可运，供大家参考。
设二叉树采用链式存储结构，试设计一个算法计算一颗给定二叉树叶子节点的数目
05-22
设二叉树采用链式存储结构，试设计一个算法计算一颗给定二叉树叶子节点的数目
吉林大学软件学院2011数据结构实验题C++实现
01-14
第一次实验： 题目1 单链表相关算法的实验验证。 [实验目的] 验证单链表及其上的基本操作。 [实验内容及要求] 1、 定义单链表类。 2、 实验验证如下算法的正确性、各种功能及指标： 1）创建单链表； 2）插入操作：分别在当前结点后、表头、表尾插入值为x的结点； 3）删除操作：分别删除表头结点、表尾结点和当前结点的后继结点； 4）存取操作：分别存取当前结点的值和单链表中第k个结点的值； 5）查找操作：查找值为x的元素在单链表中的位置（下标）。 题目2 分别给出堆栈、队列相关算法的实验验证。 [实验目的] 验证堆栈、队列及其上的基本操作。 [实验内容及要求]（以队列为例） 1、 定义队列类。 2、 实验验证如下算法的正确性、各种功能及指标： 1）创建队列； 2）插入操作：向队尾插入值为x的元素； 3）删除操作：删除队首元素； 4）存取操作：读取队首元素。 第二次实验 题目1 二叉树相关算法的实验验证。 [实验目的] 验证二叉树的链接存储结构及其上的基本操作。 [实验内容及要求] 1、 定义链接存储的二叉树类。 2、 实验验证如下算法的正确性、各种功能及指标： 1）创建一棵二叉树，并对其初始化； 2）先根、中根、后根遍历二叉树(递归算法)； 3）在二叉树中搜索给定结点的父结点； 4）搜索二叉树中符合数据域条件的结点； 5）从二叉树中删除给定结点及其左右子树。 题目2 树和森林的遍历算法的实验验证。 [实验目的] 验证树和森林的遍历算法。 [实验内容及要求] 1、 定义左儿子—右兄弟链接存储的树类和森林类。 2、 实验验证如下算法的正确性、各种功能及指标： 1）创建树和森林； 2）树和森林的先根遍历的递归和迭代算法； 3）树和森林的后根遍历的递归和迭代算法； 4）树和森林的层次遍历算法。 题目3 二叉查找树的验证实验。 [实验目的] 验证二叉查找树及其相关操作。 [实验内容及要求] 1、 定义二叉查找树的类。 2、 实验验证如下算法的正确性、各种功能及指标： 1）实现二叉查找树结构； 2） 实现二叉查找树的查找、插入和删除等算法； 第三次实验 题目1 邻接表存储的图相关算法的实验验证。 [实验目的] 验证邻接表存的图及其上的基本操作。 [实验内容及要求] 1、 定义邻接表存储的图类。 2、 实验验证如下算法的正确性、各种功能及指标： 1）创建一个邻接表存储的图； 2）返回图中指定边的权值； 3）返回图中某顶点的第一个邻接顶点； 4）返回图中某顶点关于另一个顶点的下一个邻接顶点的序号； 5）插入操作：向图中插入一个顶点，插入一条边； 6）删除操作：从图中删除一个顶点，删除一条边。 题目2 图的遍历算法的实验验证。 [实验目的] 验证图的遍历算法。 [实验内容及要求] 1、 定义邻接表存储的图。 2、 实验验证如下算法的正确性、各种功能及指标： 1）创建一个图； 2）图的深度优先遍历的递归算法； 3）图的深度优先遍历的迭代算法； 4）图的广度优先遍历算法。 第四次实验 折半插入排序，堆排序，快速排序 请阅读说明文档
数据结构第十周项目一-二叉树算法验证
zx735211469的博客
11-02 224
一个三文件工程验证二叉树算法，代码如下： 头文件（btree.h） /* *Copyright (c) 2017,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：多文件组织 *作 者：张昕 *完成日期：2017年11月2日 *版 本 号：v1.0 */ #ifndef BTREE_H_INCLUDED #define
第11周上机实践项目1—二叉树算法验证（2）二叉树构造算法的验证
yxxhilda的博客
11-09 376
问题及代码： 头文件：btree.h，包含定义顺序表数据结构的代码、宏定义、要实现算法的函数的声明； #ifndef BTREE_H_INCLUDED #define BTREE_H_INCLUDED #define MaxSize 100 typedef char ElemType; typedef struct node { ElemType data;
【封装】二叉树相关算法的实验验证
weixin_33816300的博客
05-09 149
二叉树的一些基本知识： 二叉树与树有许多相似之处，但二叉树不是树的特殊情形。 定义 在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二 叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i...
【第十周项目1】二叉树算法验证（一）
swzzz的博客
11-09 294
/* Copyright (c)2017,烟台大学计算机与控制工程学院 All rights reserved. 文件名称：33.cpp 作 者：尚文哲 完成日期：2017年11月9日 问题描述: 运行并重复测试教学内容中涉及的算法。改变测试数据进行重复测试的意义在于， 可以从更多角度体会算法，以达到逐渐掌握算法的程度。
第十周项目实践1 二叉树算法验证
sxy201658506207的博客
11-02 213
#ifndef BTREE_H_INCLUDED #define BTREE_H_INCLUDED #define MaxSize 100 typedef char ElemType; typedef struct node { ElemType data; //数据元素 struct node *lchild; //指向左孩子 st
数据结构平衡二叉树基本算法验证
最新发布
05-12
平衡二叉树是一种特殊的二叉搜索树，它具有以下特点： 1. 左子树和右子树的高度差不超过 1； 2. 左子树和右子树都是平衡二叉树。 常见的平衡二叉树有 AVL 树、红黑树等。 平衡二叉树基本算法验证包括以下部分： 1. 插入节点：在插入节点时，需要保证插入后树仍然是平衡的。具体操作是：首先按照二叉搜索树的插入方法将节点插入到树中，然后从插入节点开始向上逐层检查，如果检查到某个节点不平衡，就进行旋转操作，使得该节点重新平衡。旋转操作包括左旋、右旋、左右旋和右左旋四种，具体实现可参考 AVL 树、红黑树等平衡二叉树的旋转操作； 2. 删除节点：在删除节点时，同样需要保证删除后树仍然是平衡的。具体操作是：先按照二叉搜索树的删除方法将节点删除，然后从删除节点的父节点开始向上逐层检查，如果检查到某个节点不平衡，就进行旋转操作，使得该节点重新平衡； 3. 查找节点：在平衡二叉树中查找节点的方法与二叉搜索树相同，具体操作是从根节点开始，比较待查找节点与当前节点的大小关系，然后根据比较结果向左子树或右子树遍历，直到找到目标节点或遍历到叶子节点为止。 以上就是平衡二叉树基本算法验证的内容。需要注意的是，不同的平衡二叉树可能存在一些细微的差异，具体实现时需要结合具体的平衡二叉树来进行调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值