線段樹

線段樹的實現

• 線段樹不是完全二叉樹
• 線段樹是平衡二叉樹
• 第n層的個數為2^(n-1)，前n層總數為2ⁿ，如果有m個元素，最後一排可能裝不下，則擴充一排，空的用null表示，總共需要開闢4m的空間。

線段樹的定義：

public class SegmentTree<E> {

    private E[] tree;
    private E[] data;
    private Merger<E> merger;

    public SegmentTree(E[] arr, Merger<E> merger){

        this.merger = merger;

        data = (E[])new Object[arr.length];
        for(int i = 0 ; i < arr.length ; i ++)
            data[i] = arr[i];

        tree = (E[])new Object[4 * arr.length];
        buildSegmentTree(0, 0, arr.length - 1);
    }

    // 在treeIndex的位置建立表示區間[l...r]的線段樹
    private void buildSegmentTree(int treeIndex, int l, int r){

        if(l == r){
            tree[treeIndex] = data[l];
            return;
        }

        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIndex = rightChild(treeIndex);

        // int mid = (l + r) / 2;
        int mid = l + (r - l) / 2;
        buildSegmentTree(leftTreeIndex, l, mid);
        buildSegmentTree(rightTreeIndex, mid + 1, r);

        tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
    }

    public int getSize(){
        return data.length;
    }

    public E get(int index){
        if(index < 0 || index >= data.length)
            throw new IllegalArgumentException("Index is illegal.");
        return data[index];
    }

    // 返回完全二叉樹的陣列表示中，一個索引所表示的元素的左孩子節點的索引
    private int leftChild(int index){
        return 2*index + 1;
    }

    // 返回完全二叉樹的陣列表示中，一個索引所表示的元素的右孩子節點的索引
    private int rightChild(int index){
        return 2*index + 2;
    }
}

merge操作可自己定義，不一定是相加

public interface Merger<E> {
    E merge(E a, E b);
}

//類的呼叫
public static void main(String[] args) {

    Integer[] nums = {-2, 0, 3, -5, 2, -1};
    SegmentTree<Integer> segTree = new SegmentTree<>(nums,
            (a, b) -> a + b);        //使用函式式介面
}

線段樹的查詢操作：

// 返回區間[queryL, queryR]的值
public E query(int queryL, int queryR){

    if(queryL < 0 || queryL >= data.length ||
            queryR < 0 || queryR >= data.length || queryL > queryR)
        throw new IllegalArgumentException("Index is illegal.");

    return query(0, 0, data.length - 1, queryL, queryR);
}

// 在以treeIndex為根的線段樹中[l...r]的範圍裡，搜尋區間[queryL...queryR]的值
private E query(int treeIndex, int l, int r, int queryL, int queryR){

    if(l == queryL && r == queryR)
        return tree[treeIndex];

    int mid = l + (r - l) / 2;
    // treeIndex的節點分為[l...mid]和[mid+1...r]兩部分

    int leftTreeIndex = leftChild(treeIndex);
    int rightTreeIndex = rightChild(treeIndex);
    if(queryL >= mid + 1)
        return query(rightTreeIndex, mid + 1, r, queryL, queryR);
    else if(queryR <= mid)
        return query(leftTreeIndex, l, mid, queryL, queryR);

    E leftResult = query(leftTreeIndex, l, mid, queryL, mid);
    E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
    return merger.merge(leftResult, rightResult);
}

線段樹的更新操作：

// 將index位置的值，更新為e
public void set(int index, E e){

    if(index < 0 || index >= data.length)
        throw new IllegalArgumentException("Index is illegal");

    data[index] = e;
    set(0, 0, data.length - 1, index, e);
}

// 在以treeIndex為根的線段樹中更新index的值為e
private void set(int treeIndex, int l, int r, int index, E e){

    if(l == r){
        tree[treeIndex] = e;
        return;
    }

    int mid = l + (r - l) / 2;
    // treeIndex的節點分為[l...mid]和[mid+1...r]兩部分

    int leftTreeIndex = leftChild(treeIndex);
    int rightTreeIndex = rightChild(treeIndex);
    if(index >= mid + 1)
        set(rightTreeIndex, mid + 1, r, index, e);
    else // index <= mid
        set(leftTreeIndex, l, mid, index, e);

    tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
}

leetcode相關題目

303. 區域和檢索 - 陣列不可變

解法1：
使用線段樹的query操作，merge函式介面為元素相加。

解法2：(此方法不適合陣列有大量更新的情況，比如下題)

class NumArray {
    private int[] sum; // sum[i]儲存前i個元素和, sum[0] = 0
                       // 即sum[i]儲存nums[0...i-1]的和
                       // sum(i, j) = sum[j + 1] - sum[i]
    public NumArray(int[] nums) {

        sum = new int[nums.length + 1];
        sum[0] = 0;
        for(int i = 1 ; i < sum.length ; i ++)
            sum[i] = sum[i - 1] + nums[i - 1];
    }

    public int sumRange(int i, int j) {
        return sum[j + 1] - sum[i];
    }
}

307. 區域和檢索 - 陣列可修改
解法一：
上題的解法二能夠通過測試，但是所消耗的時間很長。
解法二：
用線段樹的操作。

字典樹

字典樹的實現

• 搜尋1000000個單詞中的一個，一般需要logn的時間複雜度，而使用字典樹則只與單詞的長度有關。

字典樹的定義：

public class Trie {

    private class Node{

        public boolean isWord;
        public TreeMap<Character, Node> next;

        public Node(boolean isWord){
            this.isWord = isWord;
            next = new TreeMap<>();
        }

        public Node(){
            this(false);
        }
    }

    private Node root;
    private int size;

    public Trie(){
        root = new Node();
        size = 0;
    }

    // 獲得Trie中儲存的單詞數量
    public int getSize(){
        return size;
    }
}

增加新的單詞：

// 向Trie中新增一個新的單詞word
public void add(String word){

    Node cur = root;
    for(int i = 0 ; i < word.length() ; i ++){
        char c = word.charAt(i);
        if(cur.next.get(c) == null)
            cur.next.put(c, new Node());
        cur = cur.next.get(c);
    }

    if(!cur.isWord){
        cur.isWord = true;
        size ++;
    }
}

統計是否包含單詞：

// 查詢單詞word是否在Trie中
public boolean contains(String word){

    Node cur = root;
    for(int i = 0 ; i < word.length() ; i ++){
        char c = word.charAt(i);
        if(cur.next.get(c) == null)
            return false;
        cur = cur.next.get(c);
    }
    return cur.isWord;
}

查詢是否在Trie中有單詞以prefix為字首：

// 查詢是否在Trie中有單詞以prefix為字首
public boolean startsWith(String isPrefix){

    Node cur = root;
    for(int i = 0 ; i < isPrefix.length() ; i ++){
        char c = isPrefix.charAt(i);
        if(cur.next.get(c) == null)
            return false;
        cur = cur.next.get(c);
    }
    return true;
}

leetcode相關題目

208. 實現 Trie (字首樹)
解法：使用上述字首樹即可，略。

211. 新增與搜尋單詞 - 資料結構設計
解法：（難點在於“.”代表任意字元）

public boolean search(String word) {
    return match(root, word, 0);
}

private boolean match(Node node, String word, int index){

    if(index == word.length())
        return node.isWord;

    char c = word.charAt(index);

    if(c != '.'){
        if(node.next.get(c) == null)
            return false;
        return match(node.next.get(c), word, index + 1);
    }
    else{
        for(char nextChar: node.next.keySet())
            if(match(node.next.get(nextChar), word, index + 1))
                return true;
        return false;
    }
}

677. 鍵值對映
解法：（難點在於先遍歷到字首的末尾，然後再sum操作）

public int sum(String prefix) {

   Node cur = root;
   for(int i = 0 ; i < prefix.length() ; i ++){
       char c = prefix.charAt(i);
       if(cur.next.get(c) == null)
           return 0;
       cur = cur.next.get(c);
   }

   return sum(cur);
}

private int sum(Node node){

   int res = node.value;
   for(char c: node.next.keySet())
       res += sum(node.next.get(c));
   return res;
}