树与二叉树

二叉树

1. 链式存储结构

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

2. 访问二叉树结点

   void visit(BiTNode *T)
   {
       printf("%d\n",T->data);
   }
   

3. 先序遍历

   void PreOrder(BiTree T)
   {
       if(T!=NULL)
       {
           visit(T);
           PreOrder(T->lchild);
           PreOrder(T->rchild);
       }
   }
   

4. 中序遍历

   void InOrder(BiTree T)
   {
       if(T!=NULL)
       {
           InOrder(T->lchild);
           visit(T);
           InOrder(T->rchild);
       }
   }
   

5. 后序遍历

   void PostOrder(BiTree T)
   {
       if(T!=NULL)
       {
           PostOrder(T->lchild);
           PostOrder(T->rchild);
           visit(T);
       }
   }
   

6. 非递归先序遍历

   void PreOrder(BiTree T)
   {
       InitStack(S);
       BiTNode* p=T;
       while(p||IsEmpty(S))
       {
           if(p)
           {
               visit(p);
               Push(S,p);
               p=p->lchild;
           }
           else
           {
               Pop(S,p);
               p=p->rchild;
           }
       }
   }
   

7. 非递归中序遍历

   void InOrder(BiTree T)
   {
       InitStack(S);
       BiTNode* p=T;
       while(p||IsEmpty(S))
       {
           if(p)
           {
               Push(S,p);
               p=p->lchild;
           }
           else
           {
               Pop(S,p);
               visit(p);
               p=p->rchild;
           }
       }
   }
   

8. 非递归后序遍历

   void PostOrder(BiTree T)
   {
       InitStack(S);
       BiTNode* p=T,r=NULL;
       while(p||IsEmpty(S))
       {
           if(p)
           {
               Push(S,p);
               p=p->lchild;
           }
           else
           {
               GetTop(S,p);
               if(p->rchild!=NULL&&p->rchild!=r)
               {
                   p=p->rchild;
                   Push(S,p);
                   p=p->lchild;
               }
               else
               {
                   Pop(S,p);
                   visit(p);
                   r=p;
                   p=NULL
               }
               p=p->rchild;
           }
       }
   }
   

9. 层序遍历

   void LevelOrder(BiTree T)
   {
       InitQueue(Q);
       BiTNode* p;
       EnQueue(Q,T);
       while(!IsEmpty(Q))
       {
           DeQueue(Q,p);
           visit(p);
           if(p->lchild!=NULL)
               EnQueue(Q,p->lchild);
           if(p->rchild!=NULL)
               EnQueue(Q,p->rchild);
       }
   }
   

线索二叉树

1. 存储结构

   typedef struct ThreadNode
   {
       ElemType data;
       struct ThreadNode *lchild,*rchild;
       int ltag,rtag;
   } ThreadNode,*ThreadTree;
   

2. 访问线索二叉树结点

   void visit(ThreadNode *T)
   {
       printf("%d\n",T->data);
   }
   

3. 中序线索二叉树的构造

   void InThread(ThreadTree &p,ThreadNode *&pre)
   {
       if(p!=NULL)
       {
           InThread(p->lchild,pre);
           if(p->lchild==NULL)
           {
               p->lchild=pre;
               p->ltag=1;
           }
           if(pre!=NULL&&pre->rchild==NULL)
           {
               pre->rchild=p;
               pre->rtag=1;
           }
           pre=p;
           InThread(p->rchild,pre);
       }
   }
   

4. 通过中序遍历建立中序线索二叉树

   void CreateInThread(ThreadTree T)
   {
       ThreadNode *pre=NULL;
       if(T!=NULL)
       {
           InThread(T,pre);
           pre->rchild=NULL;
           pre->rtag=1;
       }
   }
   

5. 某节点p的中序序列首结点

   ThreadNode *Firstnode(ThreadNode *p)
   {
       while(p->ltag==0)
           p=p->lchild;
       return p;
   }
   

6. 某节点p的后继

   ThreadNode *Nextnode(ThreadNode *p)
   {
       if(p->rtag==0)
           return Firstnode(p->rchild);
       else
           return p->rchild;
   }
   

7. 中序线索二叉树的遍历

   void InOrderThreadTree(ThreadTree T)
   {
       for(ThreadNode *p=Firstnode(T); p!=NULL; p=Nextnode(p))
           visit(p);
   }
   

树

1. 树的双亲表示法存储结构

   #define MAX_TREE_SIZE 100
   typedef struct
   {
       ElemType data;
       int parent;
   } PTNode;
   typedef struct
   {
       PTNode nodes[MAX_TREE_SIZE];
       int n;
   } PTree;
   

2. 树的孩子表示法存储结构

   #define MAX_TREE_SIZE 100
   typedef struct
   {
       ElemType data;
       int child;
   } PTNode;
   typedef struct
   {
       PTNode nodes[MAX_TREE_SIZE];
       int n;
   } PTree;
   

3. 树的孩子兄弟表示法存储结构

   typedef struct CSNode
   {
       ElemType data;
       struct CSNode *firstchild,*nextsibling;
   } CSNode,*CSTree;
   

二叉排序树

1. 存储结构

   typedef struct BSTNode
   {
       ElemType key;
       struct BSTNode *lchild,*rchild;
   } BSTNode,*BSTree;
   

2. 二叉排序树非递归查找算法

   BSTNode *BST_Search(BSTree T,ElemType key)
   {
       while(T!=NULL&&key!=T->key)
           if(key<T->key)
               T=T->lchild;
           else
               T=T->rchild;
       return T;
   }
   

3. 二叉排序树的插入

   bool BST_Insert(BSTree &T,ElemType k)
   {
       if(T==NULL)
       {
           T=(BiTree)malloc(sizeof(BSTNode));
           T->key=k;
           T->lchild=T->rchild=NULL;
           return true;
       }
       else if(k==T->key)
           return false;
       else if(k<T->key)
           return BST_Insert(T->lchild,k);
       else
           return BST_Insert(T->rchild,k);
   }
   

4. 构造二叉排序树

   void Creat_BST(BSTree &T,ElemType str[],int n)
   {
       T=NULL;
       int i=0;
       while(i<n)
           BST_Insert(T,str[i++]);
   }
   

并查集