二叉树的链式存储

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define MAXSIZE 100
typedef char ElemType;
typedef struct Node
{
    ElemType data;
    struct Node *lchild;
    struct Node *rchild;
}*BitTree,BitNode;
/*二叉树的基本操作*/
void InitBitTree(BitTree *T);//二叉树的初始化操作
void DestroyBitTree(BitTree *T);//销毁二叉树
void CreateBitTree(BitTree *T);//递归创建二叉树
void CreateBitTree2(BitTree *T,char str[]);//非递归创建二叉树
int InsertLeftChild(BitTree p,BitTree c);//二叉树的左插入操作
//如果二叉树c存在且非空，则将c插入到p所指向的左子树，使p所指结点的左子树成为c的右子树
int InsertRightChild(BitTree p,BitTree c);//二叉树的右插入操作
//如果二叉树c存在且非空，则将c插入到p所指向的右子树，使p所指结点的右子树成为c的右子树
BitTree Point(BitTree T,ElemType e);//返回二叉树结点的指针操作
ElemType LeftChild(BitTree T,ElemType e);//返回二叉树的结点的左孩子元素值操作
ElemType RightChild(BitTree T,ElemType e);//返回二叉树的结点的右孩子元素值操作
int DeleteLeftChild(BitTree p);//二叉树的左删除操作
int DeleteRightChild(BitTree p);//二叉树的右删除操作
void PreOrderTraverse(BitTree T);//先序遍历二叉树的递归实现
void InOrderTraverse(BitTree T);//中序遍历二叉树的递归实现
void PostOrderTraverse(BitTree T);//后序遍历二叉树的递归实现
void PostOrderTraverse2(BitTree T);//后序遍历二叉树的非递归实现
void PreOrderTraverse2(BitTree T);//先序遍历二叉树的非递归实现
void InOrderTraverse2(BitTree T);//中序遍历二叉树的非递归实现  

#include "LinkBiTree.h"
void InitBitTree(BitTree *T)//二叉树的初始化操作
{
    *T = NULL;
}
void DestroyBitTree(BitTree *T)//销毁二叉树
{
    if(*T)
    {
        if((*T)->lchild)
        {
            DestroyBitTree(&((*T)->lchild));
        }
        if((*T)->rchild)
        {
            DestroyBitTree(&((*T)->rchild));
        }
        free(*T);
        *T = NULL;
    }
}
void CreateBitTree(BitTree *T)//递归创建二叉树
{
    ElemType ch;
    scanf("%c",&ch);
    if(ch == '#')
    {
        *T = NULL;
    }
    else
    {
        *T = (BitTree)malloc(sizeof(BitNode));
        if(!(*T))
        {
            exit(-1);
        }
        else
        {
            (*T)->data = ch;
            CreateBitTree(&((*T)->lchild));
            CreateBitTree(&((*T)->rchild));
        }
    }
}
void CreateBitTree2(BitTree *T,char str[])//递归创建二叉树
{
    char ch;
    BitTree stack[MAXSIZE];
    int top = -1;
    int flag,k;
    BitNode *p;
    *T = NULL,k = 0;
    ch = str[k];
    while(ch != '\0')
    {
        switch(ch)
        {
        case '(':
                stack[++top] = p;
                flag = 1;
                break;
        case ')':
            top--;
            break;
        case ',':
            flag = 2;
            break;
        default:
            p = (BitTree)malloc(sizeof(BitNode));
            p->data = ch;
            p->lchild = NULL;
            p->rchild = NULL;
            if(*T == NULL)
            {
                *T = p;
            }
            else
            {
                switch(flag)
                {
                case 1:
                    stack[top]->lchild = p;
                    break;
                case 2:
                    stack[top]->rchild = p;
                    break;
                }
            }
        }
        ch = str[++k];
    }
}
int InsertLeftChild(BitTree p,BitTree c)//二叉树的左插入操作
{
    if(p)
    {
        c->rchild = p->lchild;
        p->lchild = c;
        return 1;
    }
    return 0;
}
int InsertRightChild(BitTree p,BitTree c)//二叉树的右插入操作
{
    if(p)
    {
        c->rchild = p->rchild ;
        p->rchild = c;
        return 1;
    }
    return 0;
}
BitTree Point(BitTree T,ElemType e)//返回二叉树结点的指针操作
{
    BitTree Q[MAXSIZE];
    int front = 0,rear = 0;
    BitNode *p;
    if(T)
    {
        Q[rear] = T;
        rear++;
        while(front != rear)
        {
            p = Q[front];
            front++;
            if(p->data == e)
            {
                return p;
            }
            if(p->lchild)
            {
                Q[rear] = p->lchild ;
                rear++;
            }
            if(p->rchild)
            {
                Q[rear] = p->rchild ;
                rear++;
            }
        }
    }
    return NULL;
}
ElemType LeftChild(BitTree T,ElemType e)//返回二叉树的结点的左孩子元素值操作
{
    BitTree p;
    if(T)
    {
        p = Point(T,e);
        if(p && p->lchild)
        {
            return p->lchild->data;
        }
    }
    exit(-1);
}
ElemType RightChild(BitTree T,ElemType e)//返回二叉树的结点的右孩子元素值操作
{
    BitTree p;
    if(T)
    {
        p = Point(T,e);
        if(p && p->rchild)
        {
            return p->rchild->data;
        }
    }
    exit(-1);
}
int DeleteLeftChild(BitTree p)//二叉树的左删除操作
{
    if(p)
    {
        DestroyBitTree(&(p->lchild));
        return 1;
    }
    return 0;
}
int DeleteRightChild(BitTree p)//二叉树的右删除操作
{
    if(p)
    {
        DestroyBitTree(&(p->rchild));
        return 1;
    }
    return 0;
}
void PreOrderTraverse(BitTree T)//先序遍历二叉树的递归实现
{
    if(T)
    {
        printf("%2c",T->data);
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}
void InOrderTraverse(BitTree T)//中序遍历二叉树的递归实现
{
    if(T)
    {
        InOrderTraverse(T->lchild);
        printf("%2c",T->data);
        InOrderTraverse(T->rchild);
    }
}
void PostOrderTraverse(BitTree T)//后序遍历二叉树的递归实现
{
    if(T)
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        printf("%2c",T->data);
    }
}
void PreOrderTraverse2(BitTree T)//后序遍历二叉树的非递归实现
{
    BitTree stack[MAXSIZE];//定义一个栈，用于存放结点指针
    int top;//定义栈顶指针
    BitNode *p;//定义一个结点指针
    top = 0;//初始化栈
    p = T;
    while(p != NULL || top > 0)
    {
        while(p != NULL)//如果栈不空访问根结点，遍历左子树
        {
            printf("%2c",p->data);//访问根结点
            stack[top++] = p;//将p入栈
            p = p->lchild ;//遍历左子树
        }
        if(top > 0)//如果栈不空
        {
            p = stack[--top];//栈顶元素出栈
            p = p->rchild ;//遍历右子树
        }
    }
}
void InOrderTraverse2(BitTree T)//先序遍历二叉树的非递归实现
{
    BitTree stack[MAXSIZE];//定义一个栈，用于存放结点指针
    int top;//定义栈顶指针
    BitNode *p;//定义结点指针
    top = 0;//初始化栈
    p = T;
    while(p != NULL || top > 0)
    {
        while(p != NULL)//如果栈不空访问根结点，遍历左子树
        {
            stack[top++] = p;//将p入栈
            p = p->lchild ;//遍历左子树
        }
        if(top > 0)//如果栈不空
        {
            p = stack[--top];//栈顶元素出栈
            printf("%2c",p->data);//访问根结点
            p = p->rchild ;//遍历右子树
        }
    }
}
void PostOrderTraverse2(BitTree T)//中序遍历二叉树的非递归实现
{
    BitTree stack[MAXSIZE];//定义一个栈，用于存放结点指针
    int top;//定义栈顶指针
    BitNode *p,*q;//定义一个结点指针
    top = 0;//初始化栈
    p = T;
    q = NULL;
    while(p != NULL || top > 0)
    {
        while(p != NULL)//如果栈不空访问根结点，遍历左子树
        {
            stack[top++] = p;//将p入栈
            p = p->lchild ;//遍历左子树
        }
        if(top > 0)//如果栈不空
        {
            p = stack[top-1];//栈顶元素出栈
            if(p->rchild == NULL || p->rchild == q)
            {
                printf("%2c",p->data);//访问根结点
                q = p;
                p = NULL;
                top--;
            }
            else
            {
                p = p->rchild ;//遍历右子树
            }
        }
    }
}

时间： 2024-12-20 05:35:55

二叉树的链式存储的相关文章

数据结构：二叉树的链式存储

数据结构:二叉树的链式存储(C语言版) 1.写在前面二叉树同样有两种存储方式,数组和链式存储,对于数组来说,我们利用二叉树的性质然后利用下标可以方便的找到一个节点的子节点和父节点. 二叉树的性质: 1.二叉树的第i层上至多有2i-1个节点 2.深度为K的二叉树至多有2k-1个节点 3.任何一个二叉树中度数为2的节点的个数必度数为0的节点数目少1. 说明:度数为0,为叶子节点. 4.具有n个节点的完全二叉树的深度为|_Log2N_|+1 5.若完全二叉树中的某节点编号为i,则若有左孩子编号为2i

二叉树的链式存储结构－－二叉链表

1 二叉树的链式存储结构 //二叉链表的结点结构定义 typedef struct BiTNode { int data; struct BiTNode *lchild; struct BiTNode *rchild; }BiTNode; typedef struct BiTNode *BiTree; 结构示意图如下: 2 二叉树的遍历方法 (1)前序遍历:先访问根结,然后前序遍历左子树,再前序遍历右子树. (2)

二叉树的链式存储结构----二叉链表

头文件:head.h #include<string.h> #include<ctype.h> #include<malloc.h> /* malloc()等 */ #include<limits.h> /* INT_MAX等 */ #include<stdio.h> /* EOF(=^Z或F6),NULL */ #include<stdlib.h> /* atoi() */ #include<io.h> /* eof()

java实现二叉树的链式存储

package com.fxr.二叉树链式存储; import java.util.Scanner; public class Tree { static final int MAXLEN = 20; static Scanner input = new Scanner(System.in); CBTType InitTree() { CBTType node; if((node = new CBTType()) != null) { System.out.println("请输入一个根节点的数

数据结构之自建算法库——二叉树的链式存储及基本运算

本文是数据结构基础系列(6):树和二叉树中第9课时二叉树的基本运算及其实现的例程. 单链表算法库算法库采用程序的多文件组织形式,包括两个文件: 1.头文件:btree.h,包含定义顺序表数据结构的代码.宏定义.要实现算法的函数的声明: #ifndef BTREE_H_INCLUDED #define BTREE_H_INCLUDED #define MaxSize 100 typedef char ElemType; typedef struct node { ElemType data; //

二叉树的链式存储结构

只复习一下二叉树的遍历,其他的以后再看表示 /* bt_data_t for bi tree */ typedef char bt_data_t; #define NULL_DATA '\0' /* data_t for queue which will hold the pointer of bitree_t */ typedef void *data_t; typedef struct tree_node_t { bt_data_t data; struct tree_node_t *lc

10 二叉树-链式存储-递归遍历

终于进入非线性数据结构的第一站了! 先从简单的开始回忆起来吧! 1.二叉树的链式存储用一个链表来存储一颗二叉树,每一个结点用链表的一个链结点来存储. 通常地,一个二叉链表至少包含3个域:数据域data.左指针域lchild.右指针域rchild. 现实应用的过程中,可以按照自己的需求添加其他指针域. 1 typedef struct BitNode{ 2 int data; 3 struct BitNode *lchild,*rchild; 4 }BitNode,*BiTree; 2.遍历二

二叉树链式存储和遍历

1 二叉树的链式存储 1.1 链式存储顺序存储对空间利用率较低,所以,二叉树一般采用链式存储结构,用一个链表来存储一颗二叉树.二叉链表至少包含3个域:数据域data,左指针域lchild和右指针域rchild,如果再加上一个指向双亲结点的指针就变成了三叉链表. 二叉树的链式存储结构如下: /** * 二叉链表结点 * @author cyhe */ private class Node{ Integer data; Node lchild, rchild; } 根据完全二叉树的序列递归创建二叉

Java实现链式存储的二叉树

二叉树的定义: 二叉树(BinaryTree)是n(n≥0)个结点的有限集,它或者是空集(n=0),或者由一个根结点及两棵互不相交的.分别称作这个根的左子树和右子树的二叉树组成. 二叉树的遍历方式主要有:先序遍历(NLR),中序遍历(LNR),后序遍历(LRN),和层次遍历. 注意: 由二叉树的先序序列和中序序列可以唯一地确定一颗二叉树: 由二叉树的后序序列和中序序列可以唯一地确定一颗二叉树: 由二叉树的层序序列和中序序列可以唯一地确定一棵二叉树: 但,由二叉树的先序序列和后序序列无法唯一地确定