二叉树——数据结构课堂作业

 

↖(^ω^)↗

/*

编写算法函数void preorder1(bintree t)实现二叉树t的非递归前序遍历。

*/

#include "bintree.h"
char *a="ABC##D#E##F##";  /*扩充二叉树序树t的前序序列*/

/*函数preorder1()的功能是非递归前序遍历二叉树t，请将函数补充完整并调试运行*/
void preorder1(bintree t)
{
    bintree p = t;

    seqstack s;
    init(&s);
    while(p!=NULL||!empty(&s))
    {

        while(p!=NULL)
        {
            printf("%c",p->data);
            push(&s,p);
            p = p->lchild;
        }

        if(!empty(&s))
        {
            p=pop(&s);
            p=p->rchild;
        }
    }
}

int main()
{
    bintree t;
    t=creatbintree();   /*建立二叉树t的存储结构*/
    printf("二叉树的前序序列为：\n");
    //preorder(t);
    preorder1(t);       /*前序非递归遍历二叉树*/
    return 0;
}

/*
编写算法函数void levelbintree(bintree t)，实现二叉树的层次遍历。
*/

#include "bintree.h"
#include "queue"

using namespace std;

char *a="ABC##D#E##F##";              /*扩充二叉树序树t的前序序列*/
void levelbintree(bintree t)
{
    queue<bintree> q;
    q.push(t);

    while(!q.empty()) {
        bintree s = q.front();
        q.pop();
        printf("%c",s->data);
        if(s->lchild!=NULL) {
            q.push(s->lchild);
        }
        if(s->rchild!=NULL) {
            q.push(s->rchild);
        }

    }
}

int main()
{   bintree t;
    t=creatbintree();       /*建立二叉树t的存储结构*/
    printf("二叉树的层次序列为：\n");
    levelbintree(t);       /*层次遍历二叉树*/
    return 0;
}

/*
编写函数bintree prelist(bintree t)，bintree postfirst(bintree t)，
分别返回二叉树t在前序遍历下的最后一个结点地址和后序遍历下的第一个结点地址。
*/

#include "bintree.h"
char *a="ABC##D##EF#G###";  /*扩充二叉树序树t的前序序列*/


bintree prelast(bintree t)
{
    while(t->lchild!=NULL||t->rchild!=NULL)
    {
        if(t->rchild!=NULL)
            while(t->rchild!=NULL)
                t = t->rchild;
        if(t->lchild!=NULL)
            t= t->lchild;
    }
    return t;

}

bintree postfirst(bintree t)
{
    while(t->lchild!=NULL||t->rchild!=NULL)
    {
        if(t->lchild!=NULL)
            while(t->lchild!=NULL)
                t = t->lchild;

        if(t->rchild!=NULL)
            t= t->rchild;
    }
    return t;

}

int main()
{
    bintree t,p,q;
    t=creatbintree();       /*建立二叉树t的存储结构*/
   // preorder(t);
    p=prelast(t);
    q=postfirst(t);
    if (t!=NULL)
    {
        printf("前序遍历最后一个结点为：%c\n",p->data);
        printf("后序遍历第一个结点为：%c\n",q->data);
    }
    else    printf("二叉树为空！");
    return 0;
}

/*
假设二叉树采用链式方式存储，t为其根结点，编写一个函数int Depth(bintree t, char x)，求值为x的结点在二叉树中的层次。
*/
#include "bintree.h"
char *a="ABC##D##EF#G###";          /*扩充二叉树序树t的前序序列*/

/*
     函数Depth，功能：求结点x所在的层次
*/

int d;
int dfs(bintree t,char x,int level)
{
    if(t->data==x)
    {
        d = level;
    }
    if(t->lchild!=NULL)
    {
        dfs(t->lchild,x,level+1);
    }
    if(t->rchild!=NULL)
    {
        dfs(t->rchild,x,level+1);
    }
}

int Depth(bintree t,char x)
{
    dfs(t,x,0);
    return d;
}

int main()
{
    bintree root;
    char x;
    int k=0;
    root=creatbintree();
    printf("请输入树中的1个结点值：\n");
    scanf("%c",&x);
    k=Depth(root,x);
    printf("%c结点的层次为%d\n",x,k);
}

/*
   试编写一个函数，将一棵给定二叉树中所有结点的左、右子女互换。
*/
#include "bintree.h"
#include "algorithm"

using namespace std;

char *a="ABC##D##EF#G###";          /*扩充二叉树序树t的前序序列*/
/*请将本函数补充完整，并进行测试*/

void change(bintree t)
{
    if(t->lchild!=NULL&&t->rchild!=NULL) {
        swap(t->lchild,t->rchild);
        change(t->lchild);
        change(t->rchild);
    }

}

int main()
{
    bintree root;
    root=creatbintree();
    change(root);
    preorder(root);
}

/*
试编写一个递归函数bintree buildBintree(char *pre, char *mid, int length)，
根据二叉树的前序序列pre、中序序列mid和前序序列长度length，构造二叉树的二叉链表存储结构，
函数返回二叉树的树根地址。
*/

#include "bintree.h"
#include <string.h>
char *a="";
/*请将本函数补充完整，并进行测试*/

char pre[100],in[100];

int find(int l,int r,char ch)
{
    for(int i=l;i<r;i++)
        if(in[i] == ch)
            return i;
    return -1;
}

void make(int prel,int prer,int inl,int inr)
{
    if(prel>=prer)
        return ;
    if(prel==prer-1)
    {
        printf("%c",pre[prel]);
        return ;
    }

    int pos = find(inl,inr,pre[prel]);

    make(prel+1,prel+pos-inl+1,inl,pos);
    make(prel+pos-inl+1,prer,pos+1,inr);
    printf("%c",pre[prel]);
}


bintree buildBintree(char *pre, char *mid,int length)
{
    make(0,length,0,length);
    puts("");
}

int main()
{
    bintree root;

    puts("请输入前序序列：");
    gets(pre);
    puts("请输入中序序列：");
    gets(in);
    puts("后序序列是：");
    //root=buildBintree(pre,mid,strlen(pre));
    buildBintree(pre,in,strlen(pre));

    //postorder(root);
}