二叉树的构建及各种遍历回顾

直接上代码

#ifndef TREE_H
#define TREE_H

#include <iostream>
#include <malloc.h>

typedef int ElemType;

typedef struct Bintree
{
    ElemType key;
    struct Bintree* left;
    struct Bintree* right;
}Bintree,*pBintree;


pBintree BT_Insert(ElemType target,pBintree* ppTree);
void BT_InOrder(pBintree root);
void BT_InOrderNoRec(pBintree root);
void BT_PreOrder(pBintree root);
void BT_PreOrderNoRec(pBintree root);
void BT_PostOrder(pBintree root);
void BT_PostOrderNoRec(pBintree root);
void BT_LevelOrder(pBintree root);

void BT_Destory(pBintree root);
#endif

基本函数实现

/**********************************
 对二叉树的各种操作
 BY wei 2012-09-09

 ***********************************/

#include <queue>
#include <stack>
#include "bintree.h"
using namespace std;

// 访问
static void visit(pBintree root)
{
    if(root != NULL)
    {
        printf("%d\n",root->key);
    }
}

//生成一个新的节点
static pBintree BT_MakeNode(ElemType target)
{
    pBintree pNode = (pBintree)malloc(sizeof(Bintree));
    if(pNode == NULL)
    {
        printf("malloc failed");
        return NULL;
    }
    pNode->key = target;
    pNode->left = NULL;
    pNode->right = NULL;
    return pNode;
}

//插入
pBintree BT_Insert(ElemType target,pBintree* ppTree)
{
    pBintree Node;
    if(ppTree==NULL)
    {
        printf("failed\n");
        return NULL;
    }
    Node = *ppTree;
    if(Node == NULL)
    {
        printf("--**%d\n",target);
        return *ppTree = BT_MakeNode(target);
    }
    if(Node->key == target)    //不允许出现相同的元素
    {
        return NULL;
    }
    else if(Node->key > target)
    {
        //printf("--left:%d\n",target);
        return BT_Insert(target,&Node->left);
    }
    else
    {
        //printf("----right:%d\n",target);
        return BT_Insert(target, &Node->right);
    }

}

//中序遍历的递归实现
void BT_InOrder(pBintree root)
{
    if(root != NULL)
    {
        BT_InOrder(root->left);
            visit(root);
            BT_InOrder(root->right);
    }
}
//中序遍历的非递归实现
void BT_InOrderNoRec(pBintree root)
{
    stack<pBintree>    s;
    
    while((root != NULL) || (!s.empty()) )
    {
        if(root != NULL)
        {
            s.push(root);
            root = root->left;
        }
        else
        {
            root = s.top();
            visit(root);
            s.pop();
            root = root->right;
        }
    }
}

//前序遍历的递归实现
void BT_PreOrder(pBintree root)
{
    if(root != NULL)
    {
        visit(root);
        BT_PreOrder(root->left);
        BT_PreOrder(root->right);
    }
}
//前序遍历的非递归实现
void BT_PreOrderNoRec(pBintree root)
{
    stack<pBintree>    s;
    
    while((root != NULL) || (!s.empty()) )
    {
        if(root != NULL)
        {
            visit(root);
            s.push(root);
            root = root->left;
        }
        else
        {
            root = s.top();
            s.pop();
            root = root->right;
        }
    }
}



//后序遍历的递归实现
void BT_PostOrder(pBintree root)
{
    if(root != NULL)
    {
        BT_PostOrder(root->left);
        BT_PostOrder(root->right);
        visit(root);
    }
}
//后序遍历的非递归实现
void BT_PostOrderNoRec(pBintree root)
{
    stack<pBintree> s;
    pBintree pre = NULL;
    pBintree top = NULL;
    while((root != NULL) || (!s.empty()))
    {
        if(root != NULL)
        {
            s.push(root);
            root = root->left;
        }
        else
        {
            top = s.top();
            if(top->right != NULL && top->right != pre)
                root = top->right;
            else
            {
                visit(top);
                pre = top;
                s.pop();
            }
        }
    }
}

//层次遍历的实现
void BT_LevelOrder(pBintree root)
{
    queue<pBintree> q;
    pBintree ptree;

    if(root==NULL) return;
    
    q.push(root);

    while(!q.empty())
    {
        ptree = q.front();
        q.pop();
        visit(ptree);
        if(ptree->left != NULL)
        {
            q.push(ptree->left);
        }
        if(ptree->right != NULL)
        {
            q.push(ptree->right);
        }
    }
}

void BT_Destory(pBintree root)
{
    stack<pBintree>    s;
     pBintree top = NULL;

    while((root != NULL) || (!s.empty()) )
    {
        if(root != NULL)
        {
            s.push(root);
            root = root->left;
        }
        else
        {
            top = root = s.top();
            s.pop();
            root = root->right;
            if(top != NULL){ free(top);top=NULL;}
        }
    }
}

main函数

 

#include <iostream>
#include <time.h>
#include "bintree.h"

#define MAX_CNT 10
#define BASE 100

int main()
{
    int i;
    pBintree root = NULL;

    srand((unsigned)time(NULL));

    for(i=0; i<MAX_CNT; i++)
    {
        BT_Insert(rand()%BASE,&root);
    }

    //前序
    printf("PreOrder\n");
    BT_PreOrder(root);

    printf("\n");
    BT_PreOrderNoRec(root);
    printf("---------------------\n");


    //中序
    printf("InOrder:\n");
    BT_InOrder(root);
    printf("\n");
    BT_InOrderNoRec(root);
    printf("_____________________\n");
    
    //后序
    printf("PostOrder\n");
    BT_PostOrder(root);
    printf("\n");
    BT_PostOrderNoRec(root);
    printf("======================\n");

    //层次
    printf("BY LEVELOrder\n");
    BT_LevelOrder(root);
    printf("\n");


    //destory
    BT_Destory(root);
    return 0;
}

参考http://www.cppblog.com/ngaut/archive/2011/10/19/2351.html

cppblog上的东西转不过来，自己把代码敲了一遍