数据结构（四）树---二叉树实现

（一）顺序结构创建二叉树

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100    //存储空间初始分配量
#define MAX_TREE_SIZE 100    //二叉树的最大结点数

typedef char TElemType;
typedef int Status;

typedef TElemType SqBiTree[MAX_TREE_SIZE];    //定义顺序二叉树的结构

typedef struct
{
    int level, order;    //结点的层，本层的序号
}Position;

TElemType Nil = ‘^‘;    //设置结点以^为空

Status InitBiTree(SqBiTree T);    //构造空二叉树T，因为T是固定数组，不会改变，故不需要&
Status CreateBiTree(SqBiTree T);//按照层序次序输入二叉树中结点的值，构造顺序存储的二叉树
Status BiTreeEmpty(SqBiTree T);//判断二叉树是否为空
int BiTreeDepth(SqBiTree T);//获取二叉树的深度
Status Root(SqBiTree T, TElemType* e);//返回根节点数据
TElemType Value(SqBiTree T, Position e);//获取具体位置的结点值
Status Assign(SqBiTree T, Position e, TElemType value);//对某个叶子结点赋值
TElemType Parent(SqBiTree T, TElemType e);//根据元素，获取其双亲结点的值
TElemType LeftChild(SqBiTree T, TElemType e);//返回结点的左孩子
TElemType RightChild(SqBiTree T, TElemType e);//返回结点的右孩子
TElemType LeftSibling(SqBiTree T, TElemType e);//返回结点的左兄弟
TElemType RightSibling(SqBiTree T, TElemType e);//返回结点的右兄弟
void PreOrderTraverse(SqBiTree T, int e);//开始进行前序遍历
void InOrderTraverse(SqBiTree T, int e);//开始进行中序遍历
void PostOrderTraverse(SqBiTree T, int e);//开始进行后序遍历
void LevelOrderTraverse(SqBiTree T);//开始进行层序遍历

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100    //存储空间初始分配量
#define MAX_TREE_SIZE 100    //二叉树的最大结点数

typedef char TElemType;
typedef int Status;

typedef TElemType SqBiTree[MAX_TREE_SIZE];    //定义顺序二叉树的结构

typedef struct
{
    int level, order;    //结点的层，本层的序号
}Position;

TElemType Nil = ‘^‘;    //设置结点以^为空

//构造空二叉树T，因为T是固定数组，不会改变，故不需要&
Status InitBiTree(SqBiTree T)
{
    int i;
    for (i = 0; i < MAX_TREE_SIZE; i++)
        T[i] = Nil;
    return OK;
}

//按照层序次序输入二叉树中结点的值，构造顺序存储的二叉树T
Status CreateBiTree(SqBiTree T)
{
    int i = 0;
    char ch;
    printf("please enter value for node(^ is Nil,# exit) number must <= %d:\n",MAX_TREE_SIZE);
    scanf("%c", &ch);
    while (ch!=‘#‘)
    {
        T[i++] = ch;
        if (i != 0 && T[i] != Nil &&T[(i + 1) / 2 - 1] == Nil)    //不为根节点，自己又不为空，父节点又不存在，一定是错的
        {
            printf("exist a node not parents node:%c",T[i]);
            exit(ERROR);
        }
        scanf("%c", &ch);
    }
    //将后面的结点全部置为空：是为了防止使用时创建两次二叉树，出现数据冗余
    while (i<MAX_TREE_SIZE)
    {
        T[i++] = Nil;    //将空值赋给T后面的结点
    }
    return OK;
}

#define ClearBiTree InitBiTree    //在顺序存储结构中，两者是一致的

//判断二叉树是否为空
Status BiTreeEmpty(SqBiTree T)
{
    if (T[0] == Nil)
        return TRUE;
    return FALSE;
}

//获取二叉树的深度
int BiTreeDepth(SqBiTree T)
{
    int i, j=-1;
    for (i = MAX_TREE_SIZE-1; i >= 0; i--)    //获取最后一个结点
        if (T[i] != Nil)
            break;
    //根据pow判断深度
    i++;    //获取从1开始的二叉树，而不是以0开始，方便下面计算
    do
    {
        j++;
    } while (i>=pow(2,j));
    return j;
}

//返回根节点数据
Status Root(SqBiTree T, TElemType* e)
{
    if (BiTreeEmpty(T))
        return ERROR;
    *e = T[0];
    return OK;
}

//获取具体位置的结点值
TElemType Value(SqBiTree T, Position e)
{
    return T[(int)pow(2,e.level-1)-2+e.order];
}

//对某个叶子结点赋值
Status Assign(SqBiTree T, Position e, TElemType value)
{
    //先将e转换Wie一维数组的下标
    int index = (int)pow(2, e.level - 1) - 2 + e.order;
    //判断其双亲是否存在
    if (index != 0 && T[(index + 1) / 2 - 1] == Nil)
        return ERROR;
    //若是我们赋值为空，但是其子节点存在，也返回空
    if (value == Nil && (T[index * 2 + 1] != Nil || T[index * 2 + 2] != Nil))
        return ERROR;
    T[index] = value;
    return OK;
}

//根据元素，获取其双亲结点的值
TElemType Parent(SqBiTree T, TElemType e)
{
    int i;
    //若是空树
    if (T[0] == Nil)
        return Nil;
    for (i = 1; i < MAX_TREE_SIZE; i++)    //注意这里从1开始，若是出现在头结点，会直接在下面返回Nil
        if (T[i] == e)    //找到该结点
            return T[(i + 1) / 2 - 1];
    return Nil;
}

//返回结点的左孩子
TElemType LeftChild(SqBiTree T, TElemType e)
{
    int i;
    //若是空树
    if (T[0] == Nil)
        return Nil;
    for (i = 1; i < MAX_TREE_SIZE; i++)    //注意这里从1开始，若是出现在头结点，会直接在下面返回Nil
        if (T[i] == e)    //找到该结点
            return T[2*i+1];
    return Nil;
}

//返回结点的右孩子
TElemType RightChild(SqBiTree T, TElemType e)
{
    int i;
    //若是空树
    if (T[0] == Nil)
        return Nil;
    for (i = 1; i < MAX_TREE_SIZE; i++)    //注意这里从1开始，若是出现在头结点，会直接在下面返回Nil
        if (T[i] == e)    //找到该结点
            return T[2 * i + 2];
    return Nil;
}

//返回结点的左兄弟
TElemType LeftSibling(SqBiTree T, TElemType e)
{
    int i;
    //若是空树
    if (T[0] == Nil)
        return Nil;
    for (i = 1; i < MAX_TREE_SIZE; i++)    //注意这里从1开始，若是出现在头结点，会直接在下面返回Nil
        if (T[i] == e&&i%2==0)    //找到右节点
            return T[i-1];
    return Nil;
}

//返回结点的右兄弟
TElemType RightSibling(SqBiTree T, TElemType e)
{
    int i;
    //若是空树
    if (T[0] == Nil)
        return Nil;
    for (i = 1; i < MAX_TREE_SIZE; i++)    //注意这里从1开始，若是出现在头结点，会直接在下面返回Nil
        if (T[i] == e&&i % 2 == 1)    //找到左节点
            return T[i + 1];
    return Nil;
}

//开始进行前序遍历
void PreOrderTraverse(SqBiTree T,int e)
{
    if (T&&e<MAX_TREE_SIZE)
    {
        if (T[e] != Nil)
            printf("%c", T[e]);
        PreOrderTraverse(T, 2 * e + 1);
        PreOrderTraverse(T, 2 * e + 2);
    }
}

//开始进行中序遍历
void InOrderTraverse(SqBiTree T, int e)
{
    if (T&&e<MAX_TREE_SIZE)
    {
        InOrderTraverse(T, 2 * e + 1);
        if (T[e] != Nil)
            printf("%c", T[e]);
        InOrderTraverse(T, 2 * e + 2);
    }
}

//开始进行后序遍历
void PostOrderTraverse(SqBiTree T, int e)
{
    if (T&&e<MAX_TREE_SIZE)
    {
        PostOrderTraverse(T, 2 * e + 1);
        PostOrderTraverse(T, 2 * e + 2);
        if (T[e]!=Nil)
            printf("%c", T[e]);
    }
}

//开始进行层序遍历
void LevelOrderTraverse(SqBiTree T)
{
    int i = MAX_TREE_SIZE - 1;
    int j;
    while (T[i] == Nil)
        i--;
    for (j = 0; j <= i; j++)
        if (T[j] != Nil)
            printf("%c", T[j]);    //值获取非空数据
}

函数实现代码

int main()
{
    TElemType e;
    Status i;
    Position p;
    SqBiTree T;
    printf("1.InitBiTree\n");
    InitBiTree(T);
    printf("2.CreateBiTree\n");
    CreateBiTree(T);
    printf("3.LevelOrderTraverse\n");
    LevelOrderTraverse(T);
    printf("\n");
    printf("4.PreOrderTraverse\n");
    PreOrderTraverse(T,0);
    printf("\n");
    printf("5.InOrderTraverse\n");
    InOrderTraverse(T,0);
    printf("\n");
    printf("6.PostOrderTraverse\n");
    PostOrderTraverse(T, 0);
    printf("\n");
    printf("7.PostOrderTraverse\n");
    if (Root(T, &e))
        printf("8.Root:%d\n", e);
    printf("9.PostOrderTraverse\n");
    printf("10.LeftChild for D --> %c\n", LeftChild(T, ‘D‘));
    printf("11.RightChild for D --> %c\n", RightChild(T, ‘D‘));
    printf("12.LeftSibling for H --> %c\n", LeftSibling(T, ‘H‘));
    printf("13.RightSibling for G --> %c\n", RightSibling(T, ‘G‘));
    printf("14.BiTreeDepth:%d\n", BiTreeDepth(T));
    p.level = 4;
    p.order = 2;
    printf("15.Value row4 col2:Z\n");
    Assign(T, p, ‘Z‘);
    LevelOrderTraverse(T);

    system("pause");
    return 0;
}

main函数测试

（二）链式结构创建二叉树

//按照前序输入二叉树中结点的值（一个字符）
//#表示空树，构造二叉树表表示二叉树T
void CreateBiTree(BiTree *T)
{
    TElemType ch;
    scanf("%c", &ch);
    if (ch == ‘#‘)
        *T = NULL;
    else
    {
        *T = (BiTree)malloc(sizeof(BiTNode));
        if (!*T)
            exit(ERROR);
        (*T)->data = ch;    //生成根节点数据
        CreateBiTree(&(*T)->lchild);    //构造左子树
        CreateBiTree(&(*T)->rchild);    //构造右子树
    }
}

（三）使用递归实现对二叉树的遍历

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#ifndef BINTREE_H
#define BINTREE_H
typedef char TElemType;
typedef int Status;

//二叉树的二叉链表结点结构定义
typedef struct BiTNode    //结点结构
{
    TElemType data;    //结点数据
    struct BiTNode *lchild, *rchild;    //左右孩子指针
}BiTNode, *BiTree;
#endif

BinT.h

#define _CRT_SECURE_NO_WARNINGS
#include "BinT.h"
void PreOrderTraverse(BiTree T, int level)
{
    if (T)
    {
        printf("%c in level %d\n", T->data,level + 1);
        PreOrderTraverse(T->lchild, level + 1);
        PreOrderTraverse(T->rchild, level + 1);
    }
}

void InOrderTraverse(BiTree T, int level)
{
    if (T)
    {
        InOrderTraverse(T->lchild, level + 1);
        printf("%c in level %d\n", T->data, level + 1);
        InOrderTraverse(T->rchild, level + 1);
    }
}

void PostOrderTraverse(BiTree T, int level)
{
    if (T)
    {
        PostOrderTraverse(T->lchild, level + 1);
        PostOrderTraverse(T->rchild, level + 1);
        printf("%c in level %d\n", T->data, level + 1);
    }
}

int main()
{
    BiTree T;
    printf("1.CreateBiTree\n");
    CreateBiTree(&T);
    printf("2.PreOrderTraverse\n");
    PreOrderTraverse(T, 0);
    printf("3.InOrderTraverse\n");
    InOrderTraverse(T, 0);
    printf("4.PostOrderTraverse\n");
    PostOrderTraverse(T, 0);

    system("pause");
    return 0;
}

（四）.使用栈实现非递归，遍历二叉树

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100

typedef BiTree ElemType;

typedef struct
{
    ElemType data[MAXSIZE];
    int top;
}sqStack;

Status InitStack(sqStack *s);    //初始化操作，建立一个空栈
Status ClearStack(sqStack *s);    //将栈清空
Status StackEmpty(sqStack s);    //若栈存在，返回true，否则返回false

Status Push(sqStack *s, ElemType e);    // 若是栈存在，则插入新的元素e到栈S中并成为栈顶元素
Status Pop(sqStack *s, ElemType *e);    //若是栈存在且非空，删除栈顶元素，并用e返回其值

stack.h

#define _CRT_SECURE_NO_WARNINGS
#include "stack.h"

//初始化操作，建立一个空栈
Status InitStack(sqStack *s)
{
    if (!s)
        return ERROR;
    memset(s->data, 0, MAXSIZE*sizeof(ElemType));
    s->top = -1;
    return OK;
}

//将栈清空
Status ClearStack(sqStack *s)
{
    if (!s)
        return ERROR;
    s->top = -1;
    return OK;
}

//若栈存在，返回true，否则返回false
Status StackEmpty(sqStack s)
{
    if (s.top == -1)
        return OK;
    return ERROR;
}

// 若是栈存在，则插入新的元素e到栈S中并成为栈顶元素
Status Push(sqStack *s, ElemType e)
{
    if (s->top == MAXSIZE||!s)
        return ERROR;
    s->top++;
    s->data[s->top] = e;
    return OK;
}

//若是栈存在且非空，删除栈顶元素，并用e返回其值
Status Pop(sqStack *s, ElemType *e)
{
    if (!s || StackEmpty(*s) || !e)
        return ERROR;
    *e = s->data[s->top--];
    return OK;
}

stack.c使用顺序栈

void PreOrderTraverseByStack(BiTree BT)
{
    BiTree T = BT;
    sqStack s;
    InitStack(&s);
    while (T || !StackEmpty(s))
    {
        while (T)
        {
            printf("%c", T->data);
            Push(&s, T);
            T = T->lchild;
        }
        if (!StackEmpty(s))
        {
            Pop(&s, &T);
            T = T->rchild;
        }
    }
    printf("\n");
}

void InOrderTraverseByStack(BiTree BT)
{
    BiTree T = BT;
    sqStack s;
    InitStack(&s);
    while (T || !StackEmpty(s))
    {
        while (T)
        {
            Push(&s, T);
            T = T->lchild;
        }
        if (!StackEmpty(s))
        {
            Pop(&s, &T);
            printf("%c", T->data);
            T = T->rchild;
        }
    }
    printf("\n");
}
void PostOrderTraverseByStack(BiTree BT)
{
    BiTree T = BT;
    sqStack s;
    InitStack(&s);
    while (T||!StackEmpty(s))
    {
        while (T)
        {
            Push(&s, T);
            T = T->lchild;
        }
        if (!StackEmpty(s))
        {
            Pop(&s, &T);
            if (!T->rchild||T->first==2)
            {
                printf("%c", T->data);
                T = NULL;
            }
            else
            {
                T->first = 2;
                Push(&s,T);
                T = T->rchild;
            }
        }
    }
    printf("\n");
}

//二叉树的二叉链表结点结构定义
typedef struct BiTNode    //结点结构
{
    TElemType data;    //结点数据
    int first;    //对于非递归后序而言
    struct BiTNode *lchild, *rchild;    //左右孩子指针
}BiTNode, *BiTree;

注意：针对后序非递归遍历，我们需要为结点设置一个标识

int main()
{
    BiTree T;
    printf("1.CreateBiTree\n");
    CreateBiTree(&T);
    printf("2.PreOrderTraverse\n");
    PreOrderTraverse(T, 0);
    printf("3.InOrderTraverse\n");
    InOrderTraverse(T, 0);
    printf("4.PostOrderTraverse\n");
    PostOrderTraverse(T, 0);
    printf("5.PreOrderTraverseByStack\n");
    PreOrderTraverseByStack(T);
    printf("6.InOrderTraverseByStack\n");
    InOrderTraverseByStack(T);
    printf("7.PostOrderTraverseByStack\n");
    PostOrderTraverseByStack(T);

    system("pause");
    return 0;
}

（五）使用队列完成层序遍历

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef BiTree ElemType;
typedef int Status;

//设置队列的数据结点
typedef struct QNode
{
    ElemType data;    //存放队列中的数据
    struct QNode* next;    //队列结点的指针域
}QNode, *QNodePtr;

//设置队列的结构体
typedef struct
{
    QNodePtr front, rear;    //队列头尾指针
}LinkQueue;

//四个基础操作
Status InitQueue(LinkQueue *Q);    //初始化操作，建立一个空队列Q
Status ClearQueue(LinkQueue *Q);//将队列清空
Status QueueEmpty(LinkQueue Q);    //若队列为空，返回true，否则返回false

Status EnQueue(LinkQueue *Q, ElemType e);    //若是队列存在，则插入新的元素e入队为队尾
Status DeQueue(LinkQueue *Q, ElemType *e);    //若是队列存在且非空，进行出队操作，用e接收数据

queue.h

#include "queue.h"

//初始化操作，建立一个空队列Q
Status InitQueue(LinkQueue *Q)
{
    if (!Q)
        return ERROR;
    Q->front = Q->rear = (QNodePtr)malloc(sizeof(QNode));
    if (!Q->front)
        return ERROR;
    Q->front->next = Q->rear->next = NULL;
    return OK;
}

//将队列清空,保留头结点,注意队尾指针
Status ClearQueue(LinkQueue *Q)
{
    QNodePtr head = Q->front->next;    //获取开始结点
    QNodePtr cur;    //游标指针
    if (!Q)
        return ERROR;
    while (head)    //将数据全部释放
    {
        cur = head;
        head = head->next;
        free(cur);
    }
    Q->rear = Q->front;    //将队尾指向队头
    Q->rear->next = Q->front->next = NULL;    //记得：重点
    return OK;
}

//若队列为空，返回true，否则返回false
Status QueueEmpty(LinkQueue Q)
{
    if (!Q.front->next)
        return TRUE;
    return FALSE;
}

//若是队列存在，则插入新的元素e入队为队尾,注意还要考虑队尾指针
Status EnQueue(LinkQueue *Q, ElemType e)
{
    if (!Q)
        return ERROR;
    QNodePtr q = (QNodePtr)malloc(sizeof(QNode));
    if (!q)
        return ERROR;
    q->data = e;
    q->next = Q->rear->next;
    Q->rear->next = q;
    Q->rear = q;
    return OK;
}

//若是队列存在且非空，进行出队操作，用e接收数据,注意还要考虑队尾指针
Status DeQueue(LinkQueue *Q, ElemType *e)
{
    QNodePtr q;
    if (!Q || !e || QueueEmpty(*Q))
        return ERROR;
    q = Q->front->next;    //开始结点
    *e = q->data;
    Q->front->next = q->next;    //指针后移(这一步注意：重点，且易错)
    if (Q->rear == q)    //若是我们队列中只有一个结点，删除后需要修改队尾指针
        Q->rear = Q->front;
    free(q);    //释放结点
    return OK;
}

queue.c

void LevelOrderTraverseByQueue(BiTree T)
{
    LinkQueue Q;
    BiTree Tmp;
    InitQueue(&Q);
    if (!T)
        return ;
    EnQueue(&Q, T);
    while (!QueueEmpty(Q))
    {
        DeQueue(&Q, &Tmp);
        printf("%c", Tmp->data);
        if (Tmp->lchild)
            EnQueue(&Q, Tmp->lchild);
        if (Tmp->rchild)
            EnQueue(&Q, Tmp->rchild);
    }
    printf("\n");
}

原文地址：https://www.cnblogs.com/ssyfj/p/9463922.html

时间： 2024-08-08 04:48:18

数据结构（四）树---二叉树实现的相关文章

数据结构-非线性-树-二叉树

//概述 //线性结构用于描述数据元素之间的线性关系,实际应用的数据元素之间的关系错综复杂,很难用线性关系描述,这就用到非线性结构, //树它描述客观世界中事务之间的层次关系,一切具有层次关系的问题都可以用树来描述 //例如,家族的族谱,各种社会结构,(操作系统的文件系统中,用树表示目录结构)(编译程序中,用树表示源程序的语法结构) #pragma mark --树的定义 //树,是有n(n>=0)个结点的有限集合,当n=0时称为空树,否则在任意非空树种 //1>必须有一个特定的成为根的结点

Java数据结构四之——二叉树的前、中、后序遍历

程序来自Program Creek 前 Preorder binary tree traversal is a classic interview problem about trees. The key to solve this problem is to understand the following: What is preorder? (parent node is processed before its children) Use Stack from Java Core lib

数据结构课程设计题目四_二叉树

本文出自:http://blog.csdn.net/svitter 题目4:二叉树给出一颗无线的二叉树.树的每一个结点用一整数对标识.二叉树构造如下树根被标识为(1, 1): 如果一个结点被标识为(a, b), 则其左孩子被标识为(a+b,b),右孩子被标识为(a, a+b).现在给出某一结点(a, b),求树根到该结点的最短路径,并且同时求出从树根出发向左走和向右走的次数.建议完成人数1人. 注:此处使用了STL_stack库函数,是不允许的,我图方便. //===============

34. 蛤蟆的数据结构笔记之三十四树的概念

34. 蛤蟆的数据结构笔记之三十四树的概念本篇名言:"过去属于死神,未来属于你自己.--雪莱" 本篇笔记开始我们要进入新的概念了,树!是不是有点小激动呢?让我们从概念开始吧当然概念要理解,如果当前不能立刻理解,可以后续结合代码一起理解效果更佳. 1. 树型结构之前我们学习的那么多,其实都是线性数据结构. 树则不同,它是非线性结构. 树形结构指的是数据元素之间存在着"一对多"的树形关系的数据结构,是一类重要的非线性数据结构.在树形结构中,树根结点没有前驱结点

数据结构（十四）——二叉树

数据结构(十四)--二叉树一.二叉树简介 1.二叉树简介二叉树是由n(n>=0)个结点组成的有序集合,集合或者为空,或者是由一个根节点加上两棵分别称为左子树和右子树的.互不相交的二叉树组成.二叉树的五种形态: 2.二叉树的存储结构模型树的另一种表示法:孩子兄弟表示法A.每个结点都有一个指向其第一个孩子的指针B.每个结点都有一个指向其第一个右兄弟的指针孩子兄弟表示法的特性:A.能够表示任意的树形结构B.每个结点包含一个数据成员和两个指针成员C.孩子结点指针和兄弟结点指针构成树杈 3.满二叉树

SDUT 3343 数据结构实验之二叉树四：还原二叉树

数据结构实验之二叉树四:还原二叉树 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 给定一棵二叉树的先序遍历序列和中序遍历序列,要求计算该二叉树的高度. Input 输入数据有多组,每组数据第一行输入1个正整数N(1 <= N <= 50)为树中结点总数,随后2行先后给出先序和中序遍历序列,均是长度为N的不包含重复英文字母(区分大小写)的字符串. Output 输出一个整数,即该二叉树的

SDUT 3340 数据结构实验之二叉树一：树的同构

数据结构实验之二叉树一:树的同构 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 给定两棵树T1和T2.如果T1可以通过若干次左右孩子互换就变成T2,则我们称两棵树是"同构"的.例如图1给出的两棵树就是同构的,因为我们把其中一棵树的结点A.B.G的左右孩子互换后,就得到另外一棵树.而图2就不是同构的. 图1 图2 现给定两棵树,请你判断它们是否是同构的. Input 输入数据包含

（转）数据结构：树、二叉树、最优二叉树

来源:http://www.cnblogs.com/coder2012/archive/2013/06/05/3102868.html 树树形结构是一类非常重要的非线性结构,它可以很好地描述客观世界中广泛存在的具有分支关系或层次特性的对象,因此在计算机领域里有着广泛应用,如操作系统中的文件管理.编译程序中的语法结构和数据库系统信息组织形式等. 树的相关定义节点的度:一个节点含有的子树的个数称为该节点的度: 树的度:一棵树中,最大的节点的度称为树的度: 叶节点或终端节点:度为零的节点: 非终端

javascript实现数据结构：树和二叉树,二叉树的遍历和基本操作

树型结构是一类非常重要的非线性结构.直观地,树型结构是以分支关系定义的层次结构. 树在计算机领域中也有着广泛的应用,例如在编译程序中,用树来表示源程序的语法结构:在数据库系统中,可用树来组织信息:在分析算法的行为时,可用树来描述其执行过程等等. 下面讲解的内容完整代码在这:https://github.com/LukeLin/data-structure-with-js/blob/master/Binary%20tree/BinaryTree.js 首先看看树的一些概念: 1.树(Tree)是n

javascript实现数据结构：树和二叉树的应用--最优二叉树（赫夫曼树），回溯法与树的遍历--求集合幂集及八皇后问题

赫夫曼树及其应用赫夫曼(Huffman)树又称最优树,是一类带权路径长度最短的树,有着广泛的应用. 最优二叉树(Huffman树) 1 基本概念 ① 结点路径:从树中一个结点到另一个结点的之间的分支构成这两个结点之间的路径. ② 路径长度:结点路径上的分支数目称为路径长度. ③ 树的路径长度:从树根到每一个结点的路径长度之和. 以下图为例: A到F :结点路径 AEF : 路径长度(即边的数目) 2 : 树的路径长度:3*1+5*2+2*3=19: ④ 结点的带权路径长度:从该结点的到树的根结