LeetCode5

Tree

• 102 Binary Tree Level Order Traversal

就是一个dfs，控制dfs每一层node数目的方法，用一个for循环，在进入for循环之前记录栈中的node树，以此作为for循环的次数。

• 106 Construct Binary Tree from Inorder and Postorder Traversal

基本思想和它的兄弟问题Construct Binary Tree from Inorder and Preorder Traversal是一样的。

主要需要注意的是它的base case，应该是当startI > endI || startP > endP return null. 不需要把还剩一个节点的情况作为base case，这样会麻烦很多。

• Count Univalue Subtree

这道题很简单就不多说了，要注意的是&&如果前面的计算结果是false则后面的表达式不会进行计算。

• Populating Nect Right Pointers in Each Node ||

我的方法是使用BFS做的，O（n）complexity 但是有O（n）space

学习一下别人Iteration的方法：

public class Solution {
    
    //based on level order traversal
    public void connect(TreeLinkNode root) {

        TreeLinkNode head = null; //head of the next level
        TreeLinkNode prev = null; //the leading node on the next level
        TreeLinkNode cur = root;  //current node of current level

        while (cur != null) {
            
            while (cur != null) { //iterate on the current level
                //left child
                if (cur.left != null) {
                    if (prev != null) {
                        prev.next = cur.left;
                    } else {
                        head = cur.left;
                    }
                    prev = cur.left;
                }
                //right child
                if (cur.right != null) {
                    if (prev != null) {
                        prev.next = cur.right;
                    } else {
                        head = cur.right;
                    }
                    prev = cur.right;
                }
                //move to next node
                cur = cur.next;
            }
            
            //move to next level
            cur = head;
            head = null;
            prev = null;
        }
        
    }
}

这个方式是通过iteration来做的，用head记忆下一层的第一个node，用来标记下一层的开始。

两个while loop，第一个while是用来控制整个树的遍历，第二个while是用来控制每一层的遍历。因为是从上至下一层层做的，所以可以根据上一层的next指针横向的遍历。

• 103 Binary Tree Zigzag Level Order Traversal

我使用的方法是两个栈，一个负责丛左向右遍历一个负责从右向左遍历。

O（n）space O（n）complecity

public class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) 
    {
        List<List<Integer>> sol = new ArrayList<>();
        travel(root, sol, 0);
        return sol;
    }
    
    private void travel(TreeNode curr, List<List<Integer>> sol, int level)
    {
        if(curr == null) return;
        
        if(sol.size() <= level)
        {
            List<Integer> newLevel = new LinkedList<>();
            sol.add(newLevel);
        }//如果当前层的list还没有创建
        
        //如果已经创建了直接取出来
        List<Integer> collection  = sol.get(level);//由于是ArrayList 所以get是O(n)
        //偶数层从前往后，奇数层从后往前
        if(level % 2 == 0) collection.add(curr.val);
        else collection.add(0, curr.val);//由于是LinkedList所以add是O(1)
        
        travel(curr.left, sol, level + 1);
        travel(curr.right, sol, level + 1);
    }
}
    

 

• 总结

     1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 
     2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 
     3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。 

ArrayList 是线性表（数组）
get() 直接读取第几个下标，复杂度 O(1)
add(E) 添加元素，直接在后面添加，复杂度O（1）
add(index, E) 添加元素，在第几个元素后面插入，后面的元素需要向后移动，复杂度O（n）
remove（）删除元素，后面的元素需要逐个移动，复杂度O（n）

LinkedList 是链表的操作
get() 获取第几个元素，依次遍历，复杂度O(n)
add(E) 添加到末尾，复杂度O(1)
add(index, E) 添加第几个元素后，需要先查找到第几个元素，直接指针指向操作，复杂度O(n)
remove（）删除元素，直接指针指向操作，复杂度O(1)