数据结构实验-二叉树的基本操作

实验内容：输出二叉树的中序遍历，前序遍历，后序遍历。

遍历过程

前序遍历

递归：若二叉树为空，则空操作返回，否则先访问根结点，然后前序遍历左子树，再前序遍历右子树。

非递归：可以使用一个栈来模拟这种操作。（利用回溯思想）。

若二叉树为空，则空操作返回。

当根节点（root）与栈（stack）同时不为空，判断 root 是否为空，

不为空：输出 root.val，将 root 压栈，并将 root 指向 root.left

为空：让 root 指向 stack.pop() ，并将 root 指向 root.right

中序遍历

递归：若二叉树为空，则空操作返回，否则从根结点开始（注意并不是先访问根结点），中序遍历根结点左子树，然后访问根结点，最后中序遍历右子树。

非递归：可以使用一个栈来模拟这种操作。（利用回溯思想）

若二叉树为空，则空操作返回，

当根节点（root）与栈（stack）同时不为空，判断 root 是否为空，

不为空：将root压栈，并将 root 指向其左孩子节点 root.left

为空：输出栈顶节点值（stack.peek().val），让 root 指向 stack.pop()，并将 root 重新指向 root.right

后序遍历

递归：若二叉树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问左右子树，最后是访问根结点。

非递归：可以使用一个栈（stack）和上一个访问节点来模拟这种操作。（利用回溯思想）

若二叉树为空，则空操作返回，

当根节点（root）与 stack 同时不为空，判断 root 是否为空，

不为空：将 root 压栈，并将 root 指向 root.left

为空：让 root 指向 stack.peek().right（栈顶节点的右节点）。

遍历方式的比较

程序代码

import java.util.Stack;
class Bianli {
    public void preOrder(TwoTree root) {
        if(root!=null)
        {
            System.out.print(root.getData()+" ");
            preOrder(root.getLeftNode());
            preOrder(root.getRightNode());
        }
    }
    public void preOrderNoDigui(TwoTree root) {
        Stack<TwoTree> stack=new Stack<>();
        while (true) {
            while (root!=null) {
                System.out.print(root.getData()+" ");
                stack.push(root);
                root=root.getLeftNode();
            }
            if(stack.isEmpty())
                break;
            root=stack.pop();
            root=root.getRightNode();
        }
    }
    public void inOrder(TwoTree root) {
        if(root!=null) {
            inOrder(root.getLeftNode());
            System.out.print(root.getData()+" ");
            inOrder(root.getRightNode());
        }
    }
    public void inOrderNoDigui(TwoTree root) {
        Stack<TwoTree> stack=new Stack<>();
        while (true) {
            while (root!=null) {
                stack.push(root);
                root=root.getLeftNode();
            }
            if(stack.isEmpty())
                break;
            root=stack.pop();
            System.out.print(root.getData()+" ");
            root=root.getRightNode();
        }
    }
    public void deOrder(TwoTree root) {
        if (root!=null) {
            deOrder(root.getLeftNode());
            deOrder(root.getRightNode());
            System.out.print(root.getData()+" ");
        }
    }
    public void deOrderNoDigui(TwoTree root) {
        Stack<TwoTree> stack=new Stack<>();
        while (true) {
            if(root!=null) {
                stack.push(root);
                root=root.getLeftNode();
            }else {
                if(stack.isEmpty())
                    return;
                if(stack.lastElement().getRightNode()==null) {
                    root=stack.pop();
                    System.out.print(root.getData()+" ");
                    while (root==stack.lastElement().getRightNode()) {
                        System.out.print(stack.lastElement().getData()+" ");
                        root=stack.pop();
                        if(stack.isEmpty())
                            break;
                    }
                }
                if(!stack.isEmpty())
                    root=stack.lastElement().getRightNode();
                else {
                    root=null;
                }
            }

        }
    }
    public static void main(String[] args) {
        TwoTree node10=new TwoTree(10,null,null);
        TwoTree node8=new TwoTree(8,null,null);
        TwoTree node9=new TwoTree(9,null,node10);
        TwoTree node4=new TwoTree(4,null,null);
        TwoTree node5=new TwoTree(5,node8,node9);
        TwoTree node6=new TwoTree(6,null,null);
        TwoTree node7=new TwoTree(7,null,null);
        TwoTree node2=new TwoTree(2,node4,node5);
        TwoTree node3=new TwoTree(3,node6,node7);
        TwoTree node1=new TwoTree(1,node2,node3);
        Bianli tree=new Bianli();
        System.out.println("------前序遍历-------");
        tree.preOrder(node1);
        System.out.println();
        tree.preOrderNoDigui(node1);
        System.out.println();
        System.out.println("------中序遍历-------");
        tree.inOrder(node1);
        System.out.println();
        tree.inOrderNoDigui(node1);
        System.out.println();
        System.out.println("------后序遍历-------");
        tree.deOrder(node1);
        System.out.println();
        tree.deOrderNoDigui(node1);
        System.out.println();

    }
}
public class TwoTree{
    private int data;
    private TwoTree LeftNode;
    private TwoTree RightNode;
    public TwoTree(int data,TwoTree left,TwoTree right) {
        this.data=data;
        this.LeftNode=left;
        this.RightNode=right;
    }
    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
    public TwoTree getLeftNode() {
        return LeftNode;
    }
    public void setLeftNode(TwoTree leftNode) {
        LeftNode = leftNode;
    }
    public TwoTree getRightNode() {
        return RightNode;
    }
    public void setRightNode(TwoTree rightNode) {
        RightNode = rightNode;
    }
}