二叉树的二叉链表存储表示

// Header.h

#ifndef HEADER_H
#define HEADER_H    1

// 预定义常量和类型
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;

#endif // HEADER_H

///////////////////////////////////////////////////////////////////////////////////////

// BiTree.h

/* 二叉树的二叉链表存储表示 */

#ifndef BITREE_H
#define BITREE_H

#include "Header.h"

const int Nil = -2147483647 - 1;

typedef int TElemType;

typedef struct BiTNode {
    TElemType data;
    BiTNode *lchild, *rchild;
} *BiTree;

// 二叉树的二叉链表存储的基本操作(22个)
#define ClearBiTree DestroyBiTree // 清空二叉树和销毁二叉树的操作一样

void CreateBiTree(BiTree& T);
Status DestroyBiTree(BiTree& T);
Status BiTreeEmpty(BiTree T);
int BiTreeDepth(BiTree T);
TElemType Root(BiTree T);
TElemType Parent(BiTree T, TElemType e);
BiTree Point(BiTree T, TElemType s);
TElemType LeftChild(BiTree T, TElemType e);
TElemType RightChild(BiTree T, TElemType e);
TElemType LeftSibling(BiTree T, TElemType e);
TElemType RightSibling(BiTree T, TElemType e);
Status InsertChild(BiTree p, int LR, BiTree c);
Status DeleteChild(BiTree p, int LR);
void InOrderTraverse1(BiTree T, void(*Visit)(TElemType));
void InOrderTraverse2(BiTree T, void(*Visit)(TElemType));
Status ClearBiTree(BiTree& T);
void PostOrderTraverse(BiTree T, void (*Visit)(TElemType));
void LevelOrderTraverse(BiTree T, void (*Visit)(TElemType));
void Visit(TElemType data);

#endif // BITREE_H

///////////////////////////////////////////////////////////////////////////////////////////////////

// BiTree.cpp

#include
#include
#include
#include
#include "BiTree.h"

using namespace std;

/* 按先序次序输入二叉树中节点的值, 构造二叉树T, 变量Nil表示空(子)树 */
void CreateBiTree(BiTree& T)
{
    TElemType ch;
    cin >> ch;
    if (ch == Nil) // 空
        T = NULL;
    else {
        T = new BiTNode; // 生成根节点
        if (!T)
            exit(OVERFLOW);
        T->data = ch;
        CreateBiTree(T->lchild); // 构造左子树
        CreateBiTree(T->rchild); // 构造右子树
    }
}

// 销毁二叉树
Status DestroyBiTree(BiTree& T)
{
  if (T)
    delete T; // 销毁根节点
  if (T->lchild)
    DestroyBiTree(T->lchild); // 销毁左子树
  if (T->rchild)
    DestroyBiTree(T->rchild); // 销毁右子树

  return OK;
}

/* 初始条件: 二叉树T存在.
 * 操作结果: 若T为空二叉树, 则返回TRUE, 否则返回FALSE
 */
Status BiTreeEmpty(BiTree T)
{
    if (T)
        return FALSE;
    else
        return TRUE;
}

/* 初始条件: 二叉树T存在
 * 操作结果: 返回T的深度
 */
int BiTreeDepth(BiTree T)
{
    int i, j;
    if (!T)
        return 0; // 空树深度为0
    if (T->lchild)
        i = BiTreeDepth(T->lchild); // i为左子树的深度
    else
        i = 0;
    if (T->rchild)
        j = BiTreeDepth(T->rchild); // j为右子树深度
    else
        j = 0;

    return i > j ? i + 1 : j + 1; // T的深度为其左右子树深度较大者+1
}

/* 初始条件: 二叉树T存在
 * 操作结果: 返回T的根
 */
TElemType Root(BiTree T)
{
    if (BiTreeEmpty(T))
        return Nil;
    else
        return T->data;
}

/* 初始条件: 二叉树T存在, e是T中某个节点
 * 操作结果: 若e是T的非根节点, 则返回它的双亲, 否则返回空
 */
TElemType Parent(BiTree T, TElemType e)
{
    queue q;
    BiTree a;
    if (T) { // 非空树
        q.push(T); // 树根指针入队
        while (!q.empty()) { // 队不空
            a = q.front();
            q.pop();
            if ((a->lchild && a->lchild->data == e) ||( a->rchild && a->rchild->data == e)) // 找到e(是其左或右孩子
                return a->data; // 返回e的双亲的值
            else { // 没找到e, 则入队其左右孩子指针(如果非空)
                if (a->lchild)
                    q.push(a->lchild);
                if (a->rchild)
                    q.push(a->rchild);
            }
        }
    }

    return Nil; // 树空或没找到e
}

/* 返回二叉树T中指向元素值为s的节点的指针 */
BiTree Point(BiTree T, TElemType s)
{
  queue q;
  BiTree a;
  if (T) { // 非空树
    q.push(T);
    while (!q.empty()) { // 队不空
      a = q.front();
      q.pop();
      if (a->data == s)
    return a;
      if (a->lchild) // 有左孩子
    q.push(a->lchild); // 入队左孩子
      if (a->rchild) // 有右孩子
    q.push(a->rchild); // 入队右孩子
    }
  }

  return NULL;
}

/* 初始条件: 二叉树T存在,e是T中某个节点.
 * 操作结果: 返回e的左孩子.若e无左孩子,则返回空
 */
TElemType LeftChild(BiTree T, TElemType e)
{
  BiTree a;
  if (T) { // 非空树
    a = Point(T, e); // a是节点e的指针
    if (a && a->lchild) // T中存在节点e且e存在左孩子
      return a->lchild->data; // 返回e的左孩子的值
  }

  return Nil; // 其余情况返回空
}

/* 初始条件: 二叉树T存在, e是T中某个节点
 * 操作结果: 返回e的右孩子, 若e无右孩子, 则返回空
 */
TElemType RightChild(BiTree T, TElemType e)
{
    BiTree a;
    if (T) { // 非空树
        a = Point(T, e); // a是节点e的指针
        if (a && a->rchild) // T中存在节点e且e存在右孩子
            return a->rchild->data; // 返回e的右孩子的值
    }

    return Nil; // 其余情况返回空
}

/* 初始条件: 二叉树T存在, e是T中某个节点
 * 操作结果: 返回e的左兄弟, 若e是T的左孩子或无左兄弟, 则返回空
 */
TElemType LeftSibling(BiTree T, TElemType e)
{
    TElemType a;
    BiTree p;
    if (T) { // 非空树
        a = Parent(T, e); // a为e的双亲
        if (a != Nil) { // 找到e的双亲
            p = Point(T, a); // p为指向节点a的指针
            if (p->lchild && p->rchild && p->rchild->data == e) // p存在左右孩子且右孩子是e
                return p->lchild->data;
        }
    }

    return Nil; // 其余情况返回空
}

/* 初始条件: 二叉树T存在, e是T中某个节点
 * 操作结果: 返回e的右兄弟, 若e是T的右孩子或无右兄弟, 则返回空
 */
TElemType RightSibling(BiTree T, TElemType e)
{
    TElemType a;
    BiTree p;
    if (T) { // 非空树
        a = Parent(T, e); // a为e的双亲
        if (a != Nil) { // 找到e的双亲
            p = Point(T, a); // p为指向节点a的指针
            if (p->lchild && p->rchild && p->lchild->data == e) // p存在左右孩子且左孩子是e
                return p->rchild->data; // 返回p的右孩子(e的右兄弟)
        }
    }

    return Nil; // 其余情况返回空
}

/* 初始条件: 二叉树T存在,p指向T中某个节点,LR为0或1,非空二叉树c与T不相交且右子树为空
 * 操作结果: 根据LR为1或0,插入c为T中p所指节点的左或右子树,p所指节点的原有左或右子树则成为c的右子树
 */
Status InsertChild(BiTree p, int LR, BiTree c)
{
  if (p) { // p不空
    if (LR == 0) {
      c->rchild = p->lchild;
      p->lchild = c;
    } else { // LR == 1
      c->rchild = p->rchild;
      p->rchild = c;
    }

    return OK;
  }

  return ERROR; // p空
}

/* 初始条件：二叉树T存在，p指向T中某个节点，LR为0或1
 * 操作结果：根据LR为0或1，删除T中p所指节点的左或右子树
 */

Status DeleteChild(BiTree p, int LR)
{
  if (p) { // p不空
    if (LR == 0) // 删除左子树
      ClearBiTree(p->lchild);
    else
      ClearBiTree(p->rchild);
    return OK;
  }
  return ERROR; // p空
}

/* 采用二叉链表存储结构，Visit是对数据元素操作的应用函数。
 * 中序遍历二叉树T的非递归算法（利用栈），对每个数据元素调用函数Visit
 */
void InOrderTraverse1(BiTree T, void (*Visit)(TElemType))
{
  stack S;
  while (T || ! S.empty()) {
    if (T) {
      S.push(T); // 根指针入栈，遍历左子树
      T = T->lchild;
    } else { // 根指针出栈，访问根节点，遍历右子树
      T = S.top();
      S.pop();
      Visit(T->data);
      T = T->rchild;
    }
  }
  cout << endl;
}

void InOrderTraverse2(BiTree T, void (*Visit)(TElemType))
{
  stack S;
  BiTree p;
  S.push(T);
  while (!S.empty()) {
    while ((p = S.top()))
      S.push(p->lchild); // 向左走到尽头

    S.pop(); // 空指针出栈
    if (!S.empty()) { // 访问节点，向右一步
      p = S.top();
      S.pop();
      Visit(p->data);
      S.push(p->rchild);
    }
  }
  cout << endl;
}

void PostOrderTraverse(BiTree T, void (*Visit)(TElemType))
{
  if (T) {
    PostOrderTraverse(T->lchild, Visit);
    PostOrderTraverse(T->rchild, Visit);
    Visit(T->data);
  }
}

void LevelOrderTraverse(BiTree T, void (*Visit)(TElemType))
{
  queue q;
  BiTree a;
  if (T) {
    q.push(T); // 根指针入队
    while (!q.empty()) { // 队列不空
      a = q.front();
      q.pop();
      Visit(a->data); // 访问a所指节点
      if (a->lchild != NULL) // a有左孩子
        q.push(a->lchild); // 入队a的左孩子
      if (a->rchild != NULL) // a有右孩子
        q.push(a->rchild); // 入队a的右孩子
    }
    cout << endl;
  }
}

void Visit(TElemType data)
{
  cout << data << " ";
}

//////////////////////////////////////////////////////////////////////////////////////////

// main.cpp

#include
#include "BiTree.h"

using namespace std;

int main()
{
    BiTree tree;
    CreateBiTree(tree);
    int depth = BiTreeDepth(tree);
    cout << "depth = " << depth << endl;
    int root = Root(tree);
    cout << "root = " << root << endl;
    int parent = Parent(tree, 4);
    cout << "parent = " << parent << endl;
    BiTree point = Point(tree, 2);
    cout << point->data << endl;
    cout << LeftChild(tree, 2) << endl;
    cout << RightChild(tree, 2) << endl;
    cout << LeftSibling(tree, 4) << endl;
    cout << RightSibling(tree, 3) << endl;
    InOrderTraverse1(tree, Visit);
    InOrderTraverse2(tree, Visit);
    LevelOrderTraverse(tree, Visit);
    PostOrderTraverse(tree, Visit);
    DestroyBiTree(tree);

    return 0;
}