How Telecom Companies Use Data Structures to Grow Faster

# Simple telecom tower graph in Python
graph = {
    "TowerA": {"TowerB": 4, "TowerC": 2},
    "TowerB": {"TowerA": 4, "TowerC": 5, "TowerD": 10},
    "TowerC": {"TowerA": 2, "TowerB": 5, "TowerD": 3},
    "TowerD": {"TowerB": 10, "TowerC": 3}
}

# Each number is the latency in ms between two towers.
# Dijkstra will find the fastest route from A to D.

import heapq

def dijkstra(graph, start, end):
    # distances from start to every node
    distances = {node: float("inf") for node in graph}
    distances[start] = 0

    # priority queue of (distance, node)
    queue = [(0, start)]
    visited = set()

    while queue:
        current_dist, current = heapq.heappop(queue)
        if current in visited:
            continue
        visited.add(current)

        if current == end:
            return current_dist

        for neighbor, weight in graph[current].items():
            new_dist = current_dist + weight
            if new_dist < distances[neighbor]:
                distances[neighbor] = new_dist
                heapq.heappush(queue, (new_dist, neighbor))

    return distances[end]

# Result: fastest route from TowerA to TowerD
print(dijkstra(graph, "TowerA", "TowerD"))

from collections import deque
import heapq

# Standard queue for CDR processing
cdr_queue = deque()
cdr_queue.append({"call_id": 1, "duration": 120, "tariff": 0.5})
cdr_queue.append({"call_id": 2, "duration": 45, "tariff": 0.5})

while cdr_queue:
    cdr = cdr_queue.popleft()
    bill = cdr["duration"] * cdr["tariff"]
    print(f"Billed call {cdr['call_id']}: ₹{bill}")

# Priority queue for real-time prepaid billing
priority_queue = [(1, "check_balance"), (5, "low_priority_task")]
heapq.heappush(priority_queue, (2, "recharge"))
heapq.heappush(priority_queue, (0, "urgent_check"))
print(heapq.heappop(priority_queue))  # urgent_check first

# Stack-based retry for failed CDR batches
failed_batches = []

# Simulate failures being pushed
failed_batches.append({"batch_id": 101, "reason": "DB timeout"})
failed_batches.append({"batch_id": 102, "reason": "Payment gateway error"})
failed_batches.append({"batch_id": 103, "reason": "Rate limit"})

# On each retry, pop the most recent failure first
while failed_batches:
    batch = failed_batches.pop()
    print(f"Retrying batch {batch['batch_id']}")
    # ...retry logic...
    # If it fails again, push back
    # if not success:
    #     failed_batches.append(batch)

# Stacks are used because the most recent failure
# is usually the most relevant to fix first.

# In-memory subscriber cache
# (backed by a real database in production)
subscribers = {
    "9876543210": {
        "plan": "prepaid-199",
        "balance": 145.50,
        "region": "Delhi",
        "status": "active"
    },
    "9123456789": {
        "plan": "postpaid-499",
        "balance": None,
        "region": "Noida",
        "status": "active"
    }
}

# O(1) lookup by phone number
def get_subscriber(phone):
    return subscribers.get(phone)

print(get_subscriber("9876543210")["balance"])  # 145.50

# Bloom filter for fraud detection
# (a simple version for demonstration)
from hashlib import md5

class BloomFilter:
    def __init__(self, size=10000):
        self.size = size
        self.bits = [0] * size

    def _hashes(self, item):
        h = md5(item.encode()).hexdigest()
        return [int(h[i:i+8], 16) % self.size for i in range(0, 32, 8)]

    def add(self, item):
        for pos in self._hashes(item):
            self.bits[pos] = 1

    def might_contain(self, item):
        return all(self.bits[pos] for pos in self._hashes(item))

fraud_nums = BloomFilter()
for num in ["1234567890", "9876543211", "5555555555"]:
    fraud_nums.add(num)

# Fast O(1) check — no need to scan a database
print(fraud_nums.might_contain("1234567890"))  # True (flag for review)
print(fraud_nums.might_contain("9999999999"))  # False (likely safe)

import heapq

# Priority queue for QoS packets
# Lower number = higher priority
qos = []

# Voice packets (priority 0) arrive before data packets (priority 5)
heapq.heappush(qos, (0, "voice_packet_1"))
heapq.heappush(qos, (5, "data_packet_1"))
heapq.heappush(qos, (0, "voice_packet_2"))
heapq.heappush(qos, (3, "streaming_packet_1"))
heapq.heappush(qos, (5, "data_packet_2"))

# Packets are processed in priority order
while qos:
    priority, packet = heapq.heappop(qos)
    print(f"Send {packet} (priority {priority})")

# Voice packets always ship first — critical for call quality.

# Simple tower hierarchy tree
class Tower:
    def __init__(self, name, region):
        self.name = name
        self.region = region
        self.children = []

    def add_child(self, tower):
        self.children.append(tower)

# Build a regional hierarchy
india = Tower("India", "national")
delhi = Tower("Delhi", "state")
noida = Tower("Noida", "city")
ghaziabad = Tower("Ghaziabad", "city")

india.add_child(delhi)
delhi.add_child(noida)
delhi.add_child(ghaziabad)

# Traverse the hierarchy
def print_tree(node, depth=0):
    print("  " * depth + f"{node.name} ({node.region})")
    for child in node.children:
        print_tree(child, depth + 1)

print_tree(india)
# India (national)
#   Delhi (state)
#     Noida (city)
#     Ghaziabad (city)