浙大数据结构：树的定义与操作

四种遍历

#include
#include
using namespace std;
typedef struct treenode *BinTree;
typedef BinTree position;
typedef int ElementType;
struct treenode
{
    ElementType data;
    BinTree left;
    BinTree right;
    treenode()
    {
        left=NULL,right=NULL;
    }
};

void inordertraval(BinTree b)
{
    if(b)
    {
        inordertraval(b->left);
        cout<data;
        inordertraval(b->right);
    }
}

void preordertraval(BinTree b)
{
    if(b)
    {
        cout<data;
        preordertraval(b->left);
        preordertraval(b->right);
    }
}

void  postordertraval(BinTree b)
{
    if(b)
    {
        postordertraval(b->left);
        postordertraval(b->right);
        cout<data;
    }
}

void levelordertraval(BinTree b)
{
    queue Q;
    BinTree B;
    if(!b)return ;

    Q.push(*b);
    while(!Q.empty())
    {
        treenode t=Q.front();
        cout<

树的插入与删除

BinTree Insert( BinTree BST, ElementType X )
{
  if(!BST)
  {
   BST=(BinTree)malloc(sizeof(struct TNode));
      BST->Data=X;
      BST->Left=BST->Right=NULL;
      return BST;
  }
    if(X < BST->Data)BST->Left=Insert(BST->Left,X);
    else if(X > BST->Data)BST->Right=Insert(BST->Right,X);

    return BST;
}

BinTree Delete( BinTree BST, ElementType X )
{
 Position tmp;
    if(!BST)printf("Not Found\n");
    else{
    if(XData)BST->Left=Delete(BST->Left,X);
    else if(X>BST->Data)BST->Right=Delete(BST->Right,X);
    else 
    {
if(BST->Left&&BST->Right)
{
  tmp=FindMin(BST->Right);
    BST->Data=tmp->Data;
    BST->Right=Delete(BST->Right,BST->Data);
    
}
        else {
     tmp=BST;
            if(!BST->Left)BST=BST->Right;
            else BST=BST->Left;
            free(tmp);
        }
    }
    }
   return BST;
}

查找，查找最小，查找最大

Position Find( BinTree BST, ElementType X )
{
  if(!BST)return NULL;
    if(X>BST->Data)return Find(BST->Right,X);
    else if(XData)return Find(BST->Left,X);
    else return BST;
}

Position FindMin( BinTree BST )
{
if(!BST)return NULL;
    else if(!BST->Left)return BST;
    else return FindMin(BST->Left);
}

Position FindMax( BinTree BST )
{
   if(!BST)return NULL;
    else if(!BST->Right)return BST;
    else return FindMax(BST->Right);
}