为何是线段树？

2024-02-18 13:05:20

线段树：高效解决区间算法问题

什么是线段树？

线段树是一种数据结构，用于高效地处理区间查询和更新操作。它将一个给定的数组划分为多个区间，并将每个区间的相关信息存储在树的节点中。

线段树如何工作？

线段树通常通过递归来构建。它将数组的第一个元素作为根节点的区间，然后将根节点的区间划分为两个子区间，并将每个子区间的相关信息存储在根节点的两个子节点中。这个过程不断重复，直到所有区间都被划分为单元素区间。

线段树的查询和更新操作

线段树可以通过以下方式进行查询：给定一个查询区间，找到包含该区间的线段树节点，然后返回该节点存储的区间信息。线段树可以通过以下方式进行更新：给定一个要更新的元素及其新的值，找到包含该元素的线段树节点，更新该节点存储的区间信息，并更新该节点的祖先节点的区间信息。

线段树的时间复杂度

线段树的时间复杂度如下：

构建线段树：O(n log n)，其中 n 是数组的长度
查询线段树：O(log n)
更新线段树：O(log n)

使用线段树解决区间算法问题

线段树可以用来解决各种区间算法问题，例如求一个数组的最大值、最小值和总和。我们只需要将数组作为线段树的输入，就可以通过查询线段树来获得所需的信息。

代码示例

import math

class SegmentTree:
    def __init__(self, array):
        self.array = array
        self.segment_tree = self._build_segment_tree(0, len(array) - 1, 0)

    def _build_segment_tree(self, start, end, index):
        if start == end:
            self.segment_tree[index] = self.array[start]
            return self.array[start]

        mid = (start + end) // 2
        left_value = self._build_segment_tree(start, mid, 2 * index + 1)
        right_value = self._build_segment_tree(mid + 1, end, 2 * index + 2)

        self.segment_tree[index] = max(left_value, right_value)
        return self.segment_tree[index]

    def query_max(self, start, end):
        return self._query_max(start, end, 0, 0, len(self.array) - 1)

    def _query_max(self, start, end, index, segment_start, segment_end):
        if segment_start == start and segment_end == end:
            return self.segment_tree[index]

        mid = (segment_start + segment_end) // 2

        if end <= mid:
            return self._query_max(start, end, 2 * index + 1, segment_start, mid)
        elif start > mid:
            return self._query_max(start, end, 2 * index + 2, mid + 1, segment_end)
        else:
            left_max = self._query_max(start, mid, 2 * index + 1, segment_start, mid)
            right_max = self._query_max(end, end, 2 * index + 2, mid + 1, segment_end)

            return max(left_max, right_max)

    def query_min(self, start, end):
        return self._query_min(start, end, 0, 0, len(self.array) - 1)

    def _query_min(self, start, end, index, segment_start, segment_end):
        if segment_start == start and segment_end == end:
            return self.segment_tree[index]

        mid = (segment_start + segment_end) // 2

        if end <= mid:
            return self._query_min(start, end, 2 * index + 1, segment_start, mid)
        elif start > mid:
            return self._query_min(start, end, 2 * index + 2, mid + 1, segment_end)
        else:
            left_min = self._query_min(start, mid, 2 * index + 1, segment_start, mid)
            right_min = self._query_min(end, end, 2 * index + 2, mid + 1, segment_end)

            return min(left_min, right_min)

    def query_sum(self, start, end):
        return self._query_sum(start, end, 0, 0, len(self.array) - 1)

    def _query_sum(self, start, end, index, segment_start, segment_end):
        if segment_start == start and segment_end == end:
            return self.segment_tree[index]

        mid = (segment_start + segment_end) // 2

        if end <= mid:
            return self._query_sum(start, end, 2 * index + 1, segment_start, mid)
        elif start > mid:
            return self._query_sum(start, end, 2 * index + 2, mid + 1, segment_end)
        else:
            left_sum = self._query_sum(start, mid, 2 * index + 1, segment_start, mid)
            right_sum = self._query_sum(end, end, 2 * index + 2, mid + 1, segment_end)

            return left_sum + right_sum

    def update(self, index, new_value):
        self._update(index, new_value, 0, 0, len(self.array) - 1)

    def _update(self, index, new_value, tree_index, segment_start, segment_end):
        if segment_start == segment_end:
            self.segment_tree[tree_index] = new_value
            self.array[index] = new_value
            return

        mid = (segment_start + segment_end) // 2

        if index <= mid:
            self._update(index, new_value, 2 * tree_index + 1, segment_start, mid)
        else:
            self._update(index, new_value, 2 * tree_index + 2, mid + 1, segment_end)

        self.segment_tree[tree_index] = max(self.segment_tree[2 * tree_index + 1], self.segment_tree[2 * tree_index + 2])


if __name__ == "__main__":
    array = [1, 2, 3, 4, 5, 6, 7, 8]
    segment_tree = SegmentTree(array)

    max_value = segment_tree.query_max(0, 7)
    min_value = segment_tree.query_min(0, 7)
    sum_value = segment_tree.query_sum(0, 7)

    print(max_value)
    print(min_value)
    print(sum_value)