树的构造及其遍历(转)

#include <iostream>
#include<algorithm>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<deque>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
struct tree
{
    char c;
    tree *lchild;
    tree *rchild;
};
tree *build(tree *T)
{
    char c;
    cin>>c;
    if(c=='#')
        T=NULL;
    else
    {
        T=new tree;
        T->c=c;
        T->lchild=build(T->lchild);
        T->rchild=build(T->rchild);
    }
    return T;
}
void preorder1(tree *T)
{
    if(T!=NULL)
    {
        cout<<T->c;
        preorder1(T->lchild);
        preorder1(T->rchild);
    }
}
void preorder2(tree *T)
{
    if(T!=NULL)
    {
        preorder2(T->lchild);
        cout<<T->c;
        preorder2(T->rchild);
    }
}
void preorder3(tree *T)
{
    if(T!=NULL)
    {
        preorder3(T->lchild);
        preorder3(T->rchild);
        cout<<T->c;
    }
}
/*void preorder4(tree *T)
{
    deque<tree*>p;
    if(T!=NULL)//树不为空,把树的根压入队列。
    {
        p.push_back(T);
    }
    while(!p.empty())//队列不为空
    {
        tree*TT;
        TT=p.front();//取出队首元素。
        p.pop_front();
        cout<<TT->c;
        if(TT->lchild!=NULL)//左子树存在,压入队尾。
        {
            p.push_back(TT->lchild);
        }
        if(TT->rchild!=NULL)//右子树存在,压入队尾。
        {
            p.push_back(TT->rchild);
        }
    }
}*/
int main()
{
    tree *T;
    T=build(T);//二叉树的建立。
    preorder1(T);//二叉树的前序遍历。
    cout<<endl;
    preorder2(T);//二叉树的中序遍历。
    cout<<endl;
    preorder3(T);//二叉树的后序遍历。
    /*cout<<endl;
    preorder4(T);//二叉树的层次遍历。*/
}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 二叉构造代码: ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def build_tree(preorder, inorder): if not preorder: return None root_val = preorder[0] root = TreeNode(root_val) idx = inorder.index(root_val) root.left = build_tree(preorder[1:idx+1], inorder[:idx]) root.right = build_tree(preorder[idx+1:], inorder[idx+1:]) return root ``` 四种遍算法实现代码: 1. 前序遍 ```python def preorder_traversal(root): if not root: return [] res = [] stack = [root] while stack: node = stack.pop() res.append(node.val) if node.right: stack.append(node.right) if node.left: stack.append(node.left) return res ``` 2. 中序遍 ```python def inorder_traversal(root): if not root: return [] res = [] stack = [] node = root while stack or node: while node: stack.append(node) node = node.left node = stack.pop() res.append(node.val) node = node.right return res ``` 3. 后序遍 ```python def postorder_traversal(root): if not root: return [] res = [] stack = [root] while stack: node = stack.pop() if node.left: stack.append(node.left) if node.right: stack.append(node.right) res.append(node.val) return res[::-1] ``` 4. 层序遍 ```python def level_order_traversal(root): if not root: return [] res = [] queue = [root] while queue: level = [] for i in range(len(queue)): node = queue.pop(0) level.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) res.append(level) return res ``` ### 回答2: 二叉是一种常见的形结构,每个节点最多有两个子节点。二叉构造可以递归地进行,可以通过节点的左子和右子来构建整棵。 以下是一个二叉构造示例代码: ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def construct_tree(nums): if not nums: return None root = TreeNode(nums[0]) node_queue = [root] front = 0 index = 1 while index < len(nums): node = node_queue[front] front += 1 item = nums[index] index += 1 if item is not None: node.left = TreeNode(item) node_queue.append(node.left) if index >= len(nums): break item = nums[index] index += 1 if item is not None: node.right = TreeNode(item) node_queue.append(node.right) return root ``` 四种二叉的遍算法分别是前序遍、中序遍、后序遍和层序遍: 前序遍(根-左-右)的实现代码如下: ```python def preorder_traversal(root): if not root: return [] traversal = [] stack = [root] while stack: node = stack.pop() traversal.append(node.val) if node.right: stack.append(node.right) if node.left: stack.append(node.left) return traversal ``` 中序遍(左-根-右)的实现代码如下: ```python def inorder_traversal(root): if not root: return [] traversal = [] stack = [] node = root while stack or node: while node: stack.append(node) node = node.left node = stack.pop() traversal.append(node.val) node = node.right return traversal ``` 后序遍(左-右-根)的实现代码如下: ```python def postorder_traversal(root): if not root: return [] traversal = [] stack = [root] while stack: node = stack.pop() traversal.append(node.val) if node.left: stack.append(node.left) if node.right: stack.append(node.right) return traversal[::-1] ``` 层序遍的实现代码如下: ```python def levelorder_traversal(root): if not root: return [] traversal = [] queue = [root] while queue: level = [] size = len(queue) for _ in range(size): node = queue.pop(0) level.append(node.val) if node.left: queue.append(node.left) if node.right: queue.append(node.right) traversal.append(level) return traversal ``` 以上是二叉构造以及四种遍算法的实现代码。 ### 回答3: 二叉构造是通过建立节点对象及其关系来实现的。每个节点包含一个数据域和两个指针域,分别指向左子节点和右子节点。根据节点间的关系,我们可以通过指针域建立起一个二叉的结构。 接下来是四种遍算法的代码实现: 1. 前序遍(Preorder Traversal):先访问根节点,再递归遍左子,最后递归遍右子。 ```Python def preorder_traversal(node): if node is not None: print(node.data) preorder_traversal(node.left) preorder_traversal(node.right) ``` 2. 中序遍(Inorder Traversal):先递归遍左子,再访问根节点,最后递归遍右子。 ```Python def inorder_traversal(node): if node is not None: inorder_traversal(node.left) print(node.data) inorder_traversal(node.right) ``` 3. 后序遍(Postorder Traversal):先递归遍左子,再递归遍右子,最后访问根节点。 ```Python def postorder_traversal(node): if node is not None: postorder_traversal(node.left) postorder_traversal(node.right) print(node.data) ``` 4. 层序遍(Level Order Traversal):从上到下逐层遍二叉的节点。 ```Python from collections import deque def level_order_traversal(root): if root is None: return queue = deque() queue.append(root) while queue: node = queue.popleft() print(node.data) if node.left is not None: queue.append(node.left) if node.right is not None: queue.append(node.right) ``` 以上是二叉构造和四种遍算法的实现。可以根据不同的需求选择适合的遍方式来操作二叉的节点。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值