数据结构之二叉树遍历

二叉树的存储

二叉树的存储方式分为顺序存储和链式存储。
二叉树的链式存储是通过一个个节点引用起来的，常见的表示方式二叉表示法和三叉表示法。

//孩子表示法 （二叉）
class Node{
	int value;   //数据域
	Node left;   //左孩子  即左孩子为根的左子树
	Node right;  //右孩子  即右孩子为根的右子树
}

//孩子双亲表示法 （三叉）
class Node{
	int value;   //数据域
	Node left;   //左孩子  即左孩子为根的左子树
	Node right;  //右孩子  即右孩子为根的右子树
	Node parent; //当前节点的根结点
}

二叉树的基本操作

二叉树的遍历

遍历：指沿着某条搜索路线，一次对树上每个节点均做一次且只做一次访问。
根据遍历根节点的前后顺序分为三种遍历方式：前序遍历、中序遍历和后序遍历。

• 前序遍历(先序遍历)：Preorder Traversal
  先访问根结点 —》访问根的左子树 —》访问根的右子树

• 中序遍历：Inorder Traversal
  先访问根的左子树 —》访问根节点 —》访问根的右子树

• 后序遍历：Postorder Traversal
  先访问根的左子树 —》访问根的右子树 —》访问根节点
  

二叉树的基本操作

二叉树的基本操作多是利用递归实现.

遍历结果直接打印代码实现：

class Node{
	public char value;   //数据域
	public Node left;   //左孩子  即左孩子为根的左子树
	public Node right; 
	public Node(char value){
        this.value = value;
    }
}
public class BinaryTree{
	//建立一个二叉树
	public Node BuildTree(){
        Node A = new Node('A');
        Node B = new Node('B');
        Node C = new Node('C');
        Node D = new Node('D');
        Node E = new Node('E');
        Node F = new Node('F');
        Node G = new Node('G');
        Node H = new Node('H');
        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        E.right = H;
        C.left = F;
        C.right = G;
        return A;
    }
	//前序遍历（根左右）
	/*
	*如果根结点不为空，先打印根结点，再遍历左子树，最后遍历右子树
	*/
	public void preOrderTraversal(Node root){
        if (root == null){
            return;
        }
        System.out.print(root.value + " ");
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);

    }
    //中序遍历（左根右）
    void inOrderTraversal(Node root){
        if (root ==null){
            return;
        }
        inOrderTraversal(root.left);
        System.out.print(root.value + " ");
        inOrderTraversal(root.right);
    }
	//后序遍历（左右根）
	 public void postOrderTraversal(Node root){
        if (root == null){
            return;
        }
        postOrderTraversal(root.left);
        postOrderTraversal(root.right);
        System.out.print(root.value + " ");
    }
 }

遍历结果放在一个list链表中，返回链表。
代码实现：

class Node{
    public char value;   //数据域
    public Node left;   //左子树
    public Node right;  //右子树

    public Node(char value){
        this.value = value;
    }
}

public class BinaryTree {
    public Node BuildTree(){
        Node A = new Node('A');
        Node B = new Node('B');
        Node C = new Node('C');
        Node D = new Node('D');
        Node E = new Node('E');
        Node F = new Node('F');
        Node G = new Node('G');
        Node H = new Node('H');
        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        E.right = H;
        C.left = F;
        C.right = G;
        return A;
    }

    // 前序遍历   递归实现
    public List<Character> preorderTraversal(Node root) {
        List<Character> list = new ArrayList<>();
        if (root == null){
            return list;
        }
        list.add(root.value);
        List<Character> left = preorderTraversal(root.left);
        list.addAll(left);
        List<Character> right = preorderTraversal(root.right);
        list.addAll(right);
        return list;
    }
    
    // 中序遍历
    public List<Character> inorderTraversal(Node root) {
        if (root == null){
            return list;
        }
        List<Character> left = inorderTraversal(root.left);
        list.addAll(left);
        list.add(root.value);
        List<Character> right = inorderTraversal(root.right);
        list.addAll(right);
        return list;
    }

    // 后序遍历
    public List<Character> postorderTraversal(Node root) {
        if (root == null){
            return list;  //打印[]
        }
        List<Character> left = postorderTraversal(root.left);
        list.addAll(left);
        List<Character> right = postorderTraversal(root.right);
        list.addAll(right);
        list.add(root.value);
        return list;
    }
    
}