leetCode589 N叉樹的前序遍歷

589 N叉樹前序遍歷
給定一個 N 叉樹，返回其節點值的前序遍歷。

返回其前序遍歷:[1, 3, 5, 6, 2, 4].

// 遞歸: 時間複雜度O(M),M爲N叉樹中的子節點個數,空間複雜度爲O(M),M表示節點個數

class Node {
	public int val;
	public List<Node> children;
	public Node(int val) {
		this.val = val;
	}
}

 List<Integer> list = new ArrayList<>();
    public List<Integer> preorder(Node root) {
        if (null == root) return list;
        list.add(root.val);
        for (Node item: root.children) {
            preorder(item);
        }
        return list;
    }

// 迭代 : 時間複雜度O(M),M爲N叉樹中的節點數,每個節點入棧出棧各一次,空間複雜度爲O(M),M表示棧的大小

public class Node {
	public int val;
	public List<Node> children;
	public Node(int val) {
		this.val = val;
	}

}

public List<Integer> preorder(Node root) {
	LinkedList<Node> stack = new LinkedList<>();
	LinkedList<Integer> output = new LinkedList<>();
	if (root == null) return output;

	stack.add(root);
	while(!stack.isEmpty()) {
		Node node = stack.pollLast();
		output.add(node.val);
		Collections.reverse(node.children);
		for (Node item: node.children) {
			stack.add(item);
		}
	}
	return output;
}

144 二叉樹的前序遍歷
給定一個二叉樹，返回它的 前序 遍歷。
示例
輸入: [1,null,2,3]
1

2
/
3

輸出: [1,2,3]

// 遞歸 時間O(n),每個節點都遍歷一遍, 空間O(n) 節點個數

public class TreeNode {
	int val;
	TreeNode left;
	TreeNode right;
	TreeNode(int val) {
		this.val = val;
	}
}
 List<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if (root == null)
            return list;
        list.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        return list;
    }

// 
class Solution {
    List<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
     
     if (root == null) return list;
     list.add(root.val);
        if (root.left != null) {
            preorderTraversal(root.left);
        }
        if (root.right != null) {
            preorderTraversal(root.right);
        }
     return list;
    }    
}

 class Solution {

    public List<Integer> preorderTraversal(TreeNode root) {
     List<Integer> list = new ArrayList<>();
     if (root == null) return list;
     begin_preorderTraversal(root, list);
     return list;
    }

public void begin_preorderTraversal(TreeNode node, List<Integer> list) {
    if (node != null) {
        list.add(node.val);
        if (node.left != null) {
            begin_preorderTraversal(node.left, list);
        }
        if (node.right != null) {
            begin_preorderTraversal(node.right, list);
        }
    }
}
      
}

// 迭代 時O(n),空間O(n)

public List<Integer> preorderTraversal(TreeNode root) {
	LinkedList<TreeNode> stack = new LinkedList<>();
	LinkedList<Integer> output = new LinkedList<>();
	if (root == null) return output;
	stack.add(root);
	while (!stack.isEmpty()) {
		TreeNode node = stack.pollLast();
		output.add(node.val);
		if (node.right != null) {
			stack.add(node.right);
		}
		if (node.left != null) {
			stack.add(node.left);
		}
	}
	return output;
}

// 前序
public static void preOrderTraversal(TreeNode head) {
    if (head == null) {
        return;
    }
    System.out.print(head.value + " ");
    preOrderTraversal(head.left);
    preOrderTraversal(head.right);
}

// 中序
public static void inOrderTraversal(TreeNode head) {
    if (head == null) {
        return;
    }
  inOrderTraversal(head.left);
    System.out.print(head.value + " ");
    inOrderTraversal(head.right);
}

// 後續
public static void postOrderTraversal(TreeNode head) {
    if (head == null) {
        return;
    }
    postOrderTraversal(head.left);
    postOrderTraversal(head.right);
    System.out.print(head.value + " ");
}