二叉树前、中、后序遍历(递归与非递归)

树节点结构体:

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
};

递归建立二叉树:

TreeNode *createTree()
{
    TreeNode *root;
    int x;
   scanf("%d", &x);
    if (x == -1)
       root = NULL;
    else
    {
       root = (TreeNode *)malloc(sizeof(TreeNode));
       root->val = x;
       root->left = createTree();
       root->right = createTree();
    }
    return root;
}
递归先、中、后续:

void PreOrder(TreeNode *root)
{
    if (root == 0)
        return;
    printf("%d", root->val);
    PreOrder(root->left);
    PreOrder(root->right);
}
void InOrder(TreeNode *root)
{
    if (root == 0)
        return;
    InOrder(root->left);
    printf("%d", root->val);
    InOrder(root->right);
}
void PostOrder(TreeNode *root)
{
    if (root == 0)
        return;
    PostOrder(root->left);
    PostOrder(root->right);
    printf("%d", root->val);
}
非递归先序:(借助stack)

void PreOrder_Nonrecursive(TreeNode *root)
{
    if  (root == 0)
         return;
    TreeNode *p = root;
    stack<TreeNode *> S;
    while (!s.empty() || p)
    {
        while (p)
        {
            cout << p->val << endl;
            S.push(p);
            p = p->left;
         }
         p = S.top();
         S.pop();
         p = p->right;
    }
}

非递归中序:(借助stack,和先序区别在于:先序入栈时访问节点,中序出栈时访问节点)

void InOrder_Nonrecursive(TreeNode *root)
{
    if (root == 0)
        return;
    TreeNode *p = root;
    stack<TreeNode *> S;
    while (!S.empty() || p)
    {
        while (p)
        {
             S.push(p);
             p = p->left;
         }
         p = S.top();
         S.pop();
         cout << p->val << endl;
         p = p->right;
     }
}

非递归后续:(利用一个栈,精髓在于记录上一个访问节点,判断是否右孩子为空或为previsited)

void PostOrder_Nonrecursive1(TreeNode *root)
{
     if (root == 0)
        return;
    TreeNode *p = root;
    stack<TreeNode *> S;
    TreeNode *previsited = NULL;
    while (!S.empty() || p)
    {
        while (p)
        {
            S.push(p);
            p = p->left;
        }
        p = S.top();
        if (p->right == previsited || p->right == NULL)
        {
           cout << p->val << endl;
           previsited = p;
           S.pop();
           p = NULL;
         }
         else
            p = p->right;
      }
} 

接下来是巧妙地双栈后续:

void PostOrder_Dualstack(TreeNode *root)
{
    if (root == 0)
       return;
    TreeNode *p = root;
    stack<TreeNode *> S1;
    stack<TreeNode *> S2;
    S1.push(p);
    while (!S1.empty())
    {
        p = S1.top();
        S1.pop();
        S2.push(p);
        if (p->left) S1.push(p->left);
        if (p->right) S2.push(p->right);
    }
    while (!S2.empty())
    {
        p = S2.top();
        S2.pop();
        cout << p->val << endl;
      }
}


---------------------------------------------------------------------------------------------------------------------------------------------------------------------

利用前、中序遍历确定二叉树:

TreeNode* create(int pre[], int in[], int l1,int r1, int l2, int r2)
{
    if (l1 > r1) return NULL;
    TreeNode *node = new TreeNode(pre[l1];
    int l = l2;
    int i = 0;
    for (; l <= r2; l++, i++)
    {
        if (pre[l1] == in[l])
           break;
     }
     node->left = create(pre, in, l1+1, l1+i, l2, l-1);
     node->right = create(pre, in, l1+i+1, r1, l+1, r2);
     return node;
}


文章借鉴自http://blog.csdn.net/hackbuteer1/article/details/6583988




    

    










阅读更多
文章标签: 基本算法 二叉树
个人分类: 数据结构
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭