章三二叉樹和分制

阿新 • • 發佈：2017-08-25

最大 range swa return || sea 遞歸 tree zigzag

1 前序遍歷三種方式

非遞歸 1

    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        
while (!stack.empty()) {
            TreeNode node = stack.pop();
            res.add(node.val);
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }
        return 
 res;
    }

View Code

1 錯棧中應該先加入右節點

非遞歸2

    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new 
 Stack<>();
        while (root != null || !stack.isEmpty()){
            while (root != null) {
                res.add(root.val);
                stack.push(root);
                root = root.left;
            }
            TreeNode node = stack.pop();
            root = node.right;
        }
        return res;
    }

View Code

遞歸1

    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        help(root, res);
        return res;
    }
    void help(TreeNode root, List<Integer> res) {
        if (root == null) return;
        res.add(root.val);
        help(root.left, res);
        help(root.right, res);
    }

View Code

遞歸2

    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        List<Integer> left = preorderTraversal(root.left);
        List<Integer> right = preorderTraversal(root.right);
        res.add(root.val);
        res.addAll(left);
        res.addAll(right);
        return res;
    }

View Code

2 中序遍歷非遞歸

非遞歸

    public ArrayList<Integer> inorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        while (root != null || !stack.isEmpty()){
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            TreeNode node = stack.pop();
            res.add(node.val);
            root = node.right;
        }
        return res;
    }

View Code

3 後序遍歷

非遞歸

    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        TreeNode pre = null;
        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        while (root != null || !stack.isEmpty()) {
            if (root != null) {
                stack.push(root);
                root = root.left;
            } else {
                TreeNode node = stack.peek();
                if (node.right == null || pre == node.right) {
                    stack.pop();
                    res.add(node.val);
                    pre = node;
                } else {
                    root = node.right;
                }
            }
        }
        return res;
    }

View Code

時間太長，不熟練。

4 歸並排序先局部有序，在整體有序

    public void sortIntegers2(int[] a) {
        mergesort(a, 0, a.length - 1);
    }
    void mergesort(int[] a, int start, int end) {
        if (start < end) {
            int mid = start + (end - start) / 2;
            mergesort(a, start, mid);
            mergesort(a, mid + 1, end);
            merge(a, start, mid, end);
        }
    }
    void merge(int[] a, int start, int mid, int end) {
        int[] m = new int[end - start + 1];
        int i = start;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= end) {
            if (a[i] <= a[j]) {
                m[k++] = a[i++];
            } else {
                m[k++] = a[j++];
            }
        }
        while (i <= mid) {
            m[k++] = a[i++];
        }
        while (j <= end) {
            m[k++] = a[j++];
        }
        for (int h = 0; h < k; h++) {
            a[start + h] = m[h];
        }
    }

View Code

時間長，不熟練

5快速排序

    public void sortIntegers2(int[] a) {
        quicksort(a, 0, a.length - 1);
    }
    void quicksort(int[] a, int start, int end) {
        if (start < end) {
            int mid = start + (end - start) / 2;
            int p = partion(a, start, end);
            quicksort(a, start, p - 1);
            quicksort(a, p + 1, end);
        }
    }
    int partion(int[] a, int start, int end) {
        int x = a[end];
        int i = start - 1;
        for (int j = start; j < end; j++) {
            if (a[j] <= x) {
                i++;
                swap(a, i, j);
            }
        }
        swap(a, i + 1, end);
        return i + 1;
    }
    void swap(int[] a, int l, int r) {
        int temp = a[l];
        a[l] = a[r];
        a[r] = temp;
    }
}

View Code

很久沒做，忘了

6 二叉樹的最大深度

    public int maxDepth(TreeNode root) 
    {
        if (root == null) {
            return 0;
        }
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }

View Code

7 平衡二叉樹

    public boolean isValidBST(TreeNode root) 
    {
        return help(root) != -1;
    }
    int help(TreeNode root) {
        if (root == null) return 0;
        int left = help(root.left);
        int right = help(root.right);
        if (left == -1 || right == -1 || Math.abs(left - right) > 1){
            return -1;
        }
        return Math.max(left, right) + 1;
    }

View Code

8 Binary Tree Maximum Path Sum

public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: An integer.
     */
    public int maxPathSum(TreeNode root) 
    {
        ResultType result = help(root);
        return result.max;
    }
    public ResultType help(TreeNode root) {
        if (root == null) {
            return new ResultType(0, Integer.MIN_VALUE);
        }
        ResultType left = help(root.left);
        ResultType right = help(root.right);
        
        int singlePath = Math.max(left.single, right.single) + root.val;
        singlePath = Math.max(singlePath, 0);
        
        int maxPath = Math.max(left.max, right.max);
        maxPath = Math.max(maxPath, left.single + right.single + root.val);
        return new ResultType(singlePath, maxPath);
    }
}
class ResultType {
    int single;
    int max;
    ResultType(int single, int max) {
        this.single = single;
        this.max = max;
    }
}

View Code

不熟練

9 Lowest Common Ancestor

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode a, TreeNode b) {
        // write your code here
        if (root == null || a == root || b == root) return root;
        TreeNode left = lowestCommonAncestor(root.left, a, b);
        TreeNode right = lowestCommonAncestor(root.right, a, b);
        if (left != null && right != null) {
            return root;
        }
        return left != null ? left : right;
    }

View Code

不熟練

10 二叉樹層次遍歷

    public List<List<Integer>> levelOrder(TreeNode root) {
        // write your code here
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        // 1 初始化
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            ArrayList<Integer> res = new ArrayList<>(size);
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                res.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(res);
        }
        return result;
    }

View Code

11 Binary Tree Zigzag Level Order Traversal

        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        // 1 初始化
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            ArrayList<Integer> res = new ArrayList<>(size);
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                res.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(res);
        }
        return result;

View Code

12 Validate Binary Search Tree

    public boolean isValidBST(TreeNode root) 
    {
        return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }
    boolean isValidBST(TreeNode root, long min, long max) {
        if (root == null) return true;
        if (root.val <= min || root.val >= max) return false;
        return isValidBST(root.left, min, root.val) &&
               isValidBST(root.right, root.val, max);
    }

View Code

錯誤範圍

13 Insert Node in a Binary Search Tree

    public TreeNode insertNode(TreeNode root, TreeNode node) {
        if(root == null) return node;
        if (root.val < node.val) {
            root.right = insertNode(root.right, node);
        } else {
            root.left = insertNode(root.left, node);
        }
        return root;
    }

View Code

    public TreeNode insertNode(TreeNode root, TreeNode node) {
        if(root == null) return node;
        TreeNode tep = root;
        TreeNode last = null;
        while (tep != null) {
            last = tep;
            if (tep.val < node.val) {
                tep = tep.right;
            } else {
                tep = tep.left;
            }
        }
        if (last != null) {
            if (last.val < node.val) {
                last.right = node;
            } else {
                last.left = node;
            }
        }
        return root;
    }

View Code

不熟悉

14 Search Range in Binary Search Tree

    public ArrayList<Integer> searchRange(TreeNode root, int k1, int k2) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<>();
        help(root, k1, k2, res);
        return res;
    }
    void help(TreeNode root, int k1, int k2, List<Integer> res) {
        if (root == null) return;
        if (root.val > k1) {
            help(root.left, k1, k2, res);
        }
        if (k1 <= root.val && root.val <= k2) {
            res.add(root.val);
        }
        if (root.val < k2) {
            help(root.right, k1, k2, res);
        }
    }

View Code

不熟悉

15 Implement iterator of Binary Search Tree

public class BSTIterator {
    //@param root: The root of binary tree.
    Stack<TreeNode> stack = new Stack<>();
    TreeNode next = null;
    
    void addNodeToStack(TreeNode root) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
    }
    public BSTIterator(TreeNode root) {
        // write your code here
        next = root;
    }
    

    //@return: True if there has next node, or false
    public boolean hasNext() {
        // write your code here
        if (next != null) {
            addNodeToStack(next);
            next = null;
        }
        return !stack.isEmpty();
    }
    
    //@return: return next node
    public TreeNode next() {
        // write your code here
        if (!hasNext()){
            return null;
        }
        TreeNode cur = stack.pop();
        next = cur.right;
        return cur;
    }
}

View Code

不熟悉

章三二叉樹和分制

最大 range swa return || sea 遞歸 tree zigzag 1 前序遍歷三種方式非遞歸 1 public ArrayList<Integer> preorderTraversal(TreeNode root) {

演算法班筆記第五章二叉樹和基於樹的DFS

第五章二叉樹和基於樹的DFS 在這一章節的學習中，我們將要學習一個數據結構——二叉樹（Binary Tree），和基於二叉樹上的搜尋演算法。在二叉樹的搜尋中，我們主要使用了分治法（Divide Conquer）來解決大部分的問題。之所以大部分二叉樹的問題可以使用分治法

PTA 5-11 玩轉二叉樹 (25分)【已知中序和前序求樹】

5-11 玩轉二叉樹 (25分) 給定一棵二叉樹的中序遍歷和前序遍歷，請你先將樹做個鏡面反轉，再輸出反轉後的層序遍歷的序列。所謂鏡面反轉，是指將所有非葉結點的左右孩子對換。這裡假設鍵值都是互

數據結構第5章樹的二叉樹單元小結（2）遍歷二叉樹和線索二叉樹

進行深度 bsp iteration oid 基礎二叉樹線索 push 概念：遍歷二叉樹：遍歷：指按某條搜索路線遍訪每個結點且不重復（又稱周遊）。遍歷的用途：它是樹結構插入、刪除、修改、查找和排序運算的前提，是二叉樹一切運算的基礎和核心。時間效率: O

二叉樹和廣義表的轉換

def har out char emp typedef con 逗號字符串 1 //廣義表轉二叉樹： 2 設置一個標記變量k，初始值為-1； 3 設置一個標記結點p； 4 循環遍歷廣義表的字符串str； 5 如果str[i]是左括號：

(2)Java數據結構--二叉樹 -和排序算法實現

運行至少 exceptio 子節點註釋 heapsort borde 搜索樹選擇排序 === 註釋：此人博客對很多個數據結構類都有講解-並加以實例 Java API —— ArrayList類 & Vector類 & Link

第六章例題二叉樹層次遍歷

ear 指針內存寬度優先 def delete back blog value 1.指針實現 #include <iostream> #include <vector> #include <queue> #include <

劍指offer---二叉樹和雙向鏈表

劍指offer 中序 logs style nbsp return public void cnblogs //肯定是要用中序遍歷。。。可是開始不怎麽會弄 //為什麽這麽菜 /* struct TreeNode { int val; struct Tr

算法學習筆記（六）二叉樹和圖遍歷—深搜 DFS 與廣搜 BFS

創建 mark preorder 第一個高度變量初始化 term link 文章圖的深搜與廣搜復習下二叉樹、圖的深搜與廣搜。從圖的遍歷說起。圖的遍歷方法有兩種：深度優先遍歷(Depth First Search),

二叉樹和二叉查找樹--數據結構與算法JavaScript描述(10)

高效二叉查找樹 2層連接結構數據結構與算法計算所有二叉二叉樹和二叉查找樹概念樹是一種非線性的數據結構，以分層的方式存儲數據。樹被用來存儲具有層級關系的數據，比如文件系統的文件；樹還被用來存儲有序列表。一棵樹最上面的節點稱為根節點。如果一個節點下

二叉樹和哈希表的優缺點對比與選擇

尋址 rac 二叉樹得出數據結構個數 ron 之前理論二叉樹(binary tree)和哈希表(hash table)都是很基本的數據結構，但是我們要怎麽從兩者之間進行選擇呢？他們的不同是什麽？優缺點分別是什麽？回答這個問題不是一兩句話可以說清楚的，原因是在不同

二叉樹和雜湊表的優缺點對比與選擇

二叉樹(binary tree)和雜湊表(hash table)都是很基本的資料結構，但是我們要怎麼從兩者之間進行選擇呢？他們的不同是什麼？優缺點分別是什麼？回答這個問題不是一兩句話可以說清楚的，原因是在不同的情況下，選擇的依據肯定也不同。首先來回顧一下這兩個資料結構：雜湊表使用hash functi

劍指offer——找出二叉樹和為n的路徑

連結串列和二叉樹比較難做，主要因其均以鏈相連線，.next and .left 來輸出結構中的資料，無法精確定位，所以通常用遞迴方法實現。通過遞迴方法，本人感覺最重要的是確定.next的這部中具體實現的操作，然後逐漸實現遞迴。找出二叉樹和為n的路徑，就針對每一步做加和操作以及記錄路徑，並判

線索二叉樹和二叉樹基本操作的實現

2018-11-18-18:25:23 一：二叉樹 1.二叉樹的性質　　①：在二叉樹的第i層上至多有pow(2,i-1)個結點(i>=1)。　　②：深度為k的二叉樹至多有pow(2,k)-1個結點(k>=1)。　　③：對任何一顆二叉樹T,如果其終端結點的個數為n0，度為2的結點數為

給定一個二叉樹和其中的一個結點，請找出中序遍歷順序的下一個結點並且返回。注意，樹中的結點不僅包含左右子結點，同時包含指向父結點的指標。

題目描述給定一個二叉樹和其中的一個結點，請找出中序遍歷順序的下一個結點並且返回。注意，樹中的結點不僅包含左右子結點，同時包含指向父結點的指標。 /* 分析二叉樹的下一個節點，一共有以下情況： 1.二叉樹為空，則返回空； 2.節點右孩子存在，則設定一個指標從該節點的右孩子出發，一直沿著指向左

【資料結構學習筆記】二叉樹和其他樹

基礎定義一個樹t是一個非空的有限元素的集合，其中一個元素為根（root），其餘的元素（如果有的話）組成t的子樹（subtree）樹的另一常用術語為級（level）。樹根是1級，其孩子（如果有）是2級，孩子的孩子是3級，等等。一棵樹的高度（height）或深度（de

刷題：輸入一顆二叉樹和一個整數，打印出二叉樹中結點值的和為輸入整數的所有路徑。

原題：輸入一顆二叉樹和一個整數，打印出二叉樹中結點值的和為輸入整數的所有路徑。路徑定義為從樹的根結點開始往下一直到葉結點所經過的結點形成一條路徑。思路分析：首先思考節點值的和為輸入的整數，每條路徑都一定是從根節點到葉子節點，在資料結構中從根節點到葉子節點的遍歷稱之為深度優先遍歷DFS。因此整

層次遍歷二叉樹和採用棧的方式遍歷二叉樹

//中序遍歷非遞迴 @Override public void inOrderByStack() { System.out.println("中序遍歷非遞迴操作"); //建立棧 Deque<Node> stack=new LinkedList&

二叉樹和完全二叉樹一些規律

1、二叉樹具有以下規律： 1）二叉樹高度為i所在的層至多有個節點 2）高度為k的二叉樹至多有 -1個節點 3）對於任何一棵二叉樹，若度為2的

二叉樹：搜尋二叉樹和完全二叉樹

搜尋二叉樹又叫作二叉樹查詢樹或者二叉排序樹，所謂搜尋二叉樹是指對於任何一個結點，它的左子樹的所有結點都比這個根結點要小，它的右子樹的所有結點都比這個根結點要大。注意是根結點與左右子樹上所有的結點進行比較而不是僅僅與左右孩子結點進行比較，因此根據這個定義，那麼當按照中序

章三 二叉樹和分制

相關推薦

章三二叉樹和分制