Wavelet Trees Implementation in Python

Wavelet Trees are a powerful data structure used in computer science and information theory for various applications, including data compression, text indexing, and pattern matching. They offer efficient and flexible ways to process and analyze large datasets. In this article, we will explore the concept of Wavelet Trees and implement them in Python.

Understanding Wavelet Trees

A Wavelet Tree is a binary tree data structure that represents a sequence of symbols or numbers. It is built recursively by splitting the sequence into two halves and storing information about the frequencies of symbols in each half. This process continues until each node in the tree represents a single symbol.

One of the key features of Wavelet Trees is that they allow efficient range queries on the original sequence. For example, given a range [i, j], we can quickly determine the number of occurrences of a specific symbol within that range.

Implementing Wavelet Trees in Python

To implement Wavelet Trees in Python, we will start by defining the main class Wavelet Tree and its constructor. We will also define a helper function build to recursively build the tree.

class WaveletTree:
    def __init__(self, sequence):
        self.sequence = sequence
        self.alphabet = sorted(set(sequence))
        self.root = self.build(sequence)

    def build(self, sequence):
        if len(set(sequence)) == 1:
            return sequence[0]
        else:
            midpoint = len(sequence) // 2
            left_sequence = [c for c in sequence if c in self.alphabet[:midpoint]]
            right_sequence = [c for c in sequence if c in self.alphabet[midpoint:]]
            return (self.build(left_sequence), self.build(right_sequence))

Next, we will implement the rank method to count the number of occurrences of a symbol within a given range.

def rank(self, symbol, i, j):
    if i > j:
        return 0
    if isinstance(self.root, tuple):
        midpoint = len(self.sequence) // 2
        left_count = self.sequence[:j + 1].count(symbol) - self.sequence[:i].count(symbol)
        if symbol in self.alphabet[:midpoint]:
            return self.root[0].rank(symbol, self.sequence[:i].count(symbol), self.sequence[:j + 1].count(symbol) - 1)
        else:
            return self.root[1].rank(symbol, i - self.sequence[:midpoint].count(symbol), j - self.sequence[:midpoint].count(symbol))
    else:
        return self.sequence[:j + 1].count(symbol) - self.sequence[:i].count(symbol)

Finally, we will implement the range_freq method to count the frequencies of all symbols within a given range.

def range_freq(self, i, j):
    freq = {}
    for symbol in self.alphabet:
        freq[symbol] = self.rank(symbol, i, j)
    return freq

Implementation of Full Code:

class WaveletTree:
    def __init__(self, sequence):
        self.sequence = sequence
        self.alphabet = sorted(set(sequence))
        self.root = self.build(sequence)

    def build(self, sequence):
        if len(set(sequence)) == 1:
            return sequence[0]
        else:
            midpoint = len(sequence) // 2
            left_sequence = [c for c in sequence if c in self.alphabet[:midpoint]]
            right_sequence = [c for c in sequence if c in self.alphabet[midpoint:]]
            return (self.build(left_sequence), self.build(right_sequence))

    def rank(self, symbol, i, j):
        if i > j:
            return 0
        if isinstance(self.root, tuple):
            midpoint = len(self.sequence) // 2
            left_count = self.sequence[:j + 1].count(symbol) - self.sequence[:i].count(symbol)
            if symbol in self.alphabet[:midpoint]:
                return self.root[0].rank(symbol, self.sequence[:i].count(symbol), self.sequence[:j + 1].count(symbol) - 1)
            else:
                return self.root[1].rank(symbol, i - self.sequence[:midpoint].count(symbol), j - self.sequence[:midpoint].count(symbol))
        else:
            return self.sequence[:j + 1].count(symbol) - self.sequence[:i].count(symbol)

    def range_freq(self, i, j):
        freq = {}
        for symbol in self.alphabet:
            freq[symbol] = self.rank(symbol, i, j)
        return freq

# Example usage
sequence = "abracadabra"
wt = WaveletTree(sequence)

# Count the number of occurrences of 'a' in the range [0, 5]
print(wt.rank('a', 0, 5)) 
# Count the frequencies of all symbols in the range [0, 5]
print(wt.range_freq(0, 5))  

Output:

3
{'a': 3, 'b': 1, 'c': 0, 'd': 0, 'r': 1}

Applications

Wavelet Trees are used in various applications where efficient processing and analysis of sequences are required. Some common applications include:

Data Compression: Wavelet Trees can be used in data compression algorithms to compress and decompress sequences efficiently. They are particularly useful for compressing text and image data.
Text Indexing: Wavelet Trees can be used to build indexes for text data, allowing fast substring searches and pattern matching in large text corpora.
Data Mining: In data mining applications, Wavelet Trees can be used for clustering, classification, and similarity search tasks on sequences and time series data.
Bioinformatics: Wavelet Trees are used in bioinformatics for analyzing DNA and protein sequences. They can be used for sequence alignment, motif finding, and other sequence analysis tasks.
Signal Processing: In signal processing, Wavelet Trees can be used for signal denoising, compression, and feature extraction from signals.
Database Systems: Wavelet Trees can be used in database systems for efficient storage and retrieval of sequences and for supporting sequence-based queries.

Conclusion

Wavelet Trees are a versatile data structure that can be used in various applications requiring efficient processing of sequences. By implementing Wavelet Trees in Python, we can perform range queries and count the frequencies of symbols within a given range efficiently. This makes Wavelet Trees a valuable tool for handling large datasets in a wide range of applications.

Next TopicWays to filter pandas dataframe by column values in python

← prev next →