Tree Basic DSA

1. Tree Data Structure

2. Tree Traversal

Tree Representation

struct node{
  int data;
  struct node* left;
  struct node* right;
}

Linear data structures like arrays, stacks, queues, and linked list (singly, doubly, circular) have only one way to read the data. But hierarchical data strcuture like a tree can be travrersed in different ways. 

无论什么样的structure，我们都可以吧tree看成: (1) A node carrying data; (2) Two subtrees

可以先画出stack, 再去判断如何traverse

(1) In-order

- Visit all the nodes in the left subtree

- Then the root node

- Visit all the nodes in the right subtree

inorder(root -> left)
display(root -> data)
inorder(root -> right)

(2) Post-order

- Visit all the nodes in the left subtree

- Visit all the nodes in the right subtree

- Then the root node

postorder(root -> left)
display(root -> right)
postorder(root -> data)

(3) Pre-order

- First root node

- Visit all the nodes in the left subtree

- Visit all the nodes in the right subtree

preorder(root -> data)
display(root -> left)
preorder(root -> right)

Java Code Example

class TreeNode {
    int value;
    TreeNode left, right;

    TreeNode(int item) {
        value = item;
        left = right = null;
    }
}

class BinaryTree {
    TreeNode root;

    void inorderTraversal(TreeNode node) {
        if (node == null) return;
        inorderTraversal(node.left);
        System.out.print(node.value + " ");
        inorderTraversal(node.right);
    }

    void preorderTraversal(TreeNode node) {
        if (node == null) return;
        System.out.print(node.value + " ");
        preorderTraversal(node.left);
        preorderTraversal(node.right);
    }

    void postorderTraversal(TreeNode node) {
        if (node == null) return;
        postorderTraversal(node.left);
        postorderTraversal(node.right);
        System.out.print(node.value + " ");
    }
}

public class TreeTraversalDemo {
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        tree.root = new TreeNode(1);
        tree.root.left = new TreeNode(2);
        tree.root.right = new TreeNode(3);
        tree.root.left.left = new TreeNode(4);
        tree.root.left.right = new TreeNode(5);

        System.out.println("Inorder traversal");
        tree.inorderTraversal(tree.root);

        System.out.println("\nPreorder traversal");
        tree.preorderTraversal(tree.root);

        System.out.println("\nPostorder traversal");
        tree.postorderTraversal(tree.root);
    }
}

//Inorder Ouput: 4 2 5 1 3.
//Preorder output: 1 2 4 5 3
//Postorder output: 4 5 2 3 1