Data Structures Jobs in Travel Industry — Roles & Responsibilities

# Trie — autocomplete for flight destinations.
# Real travel search bars use this pattern for instant
# suggestions as the user types.

class DestinationTrie:
    def __init__(self):
        self.children = {}
        self.airport_code = None  # full code at leaf

    def insert(self, name, code):
        node = self
        for ch in name.lower():
            if ch not in node.children:
                node.children[ch] = DestinationTrie()
            node = node.children[ch]
        node.airport_code = (name, code)

    def search_prefix(self, prefix):
        node = self
        for ch in prefix.lower():
            if ch not in node.children:
                return []
            node = node.children[ch]
        return self._collect(node)

    def _collect(self, node):
        results = []
        if node.airport_code:
            results.append(node.airport_code)
        for child in node.children.values():
            results.extend(self._collect(child))
        return results

# What this proves in an interview:
# - You know that prefix search is a trie problem, not a LIKE query
# - You can explain why "SELECT * WHERE name LIKE 'del%'" is
#   much slower than a trie
# - You understand that autocomplete needs sub-10ms response
# - You can name the time complexity: O(prefix + results)

# Every travel search bar relies on this pattern. It is
# one of the most common production DSA uses in the industry.

# Min-heap — find the cheapest flight across many
# results. Travel search pages use this to show
# "cheapest first" or top-N results instantly.

import heapq

class FlightSearchResult:
    def __init__(self, flights):
        self.flights = flights

    def cheapest_n(self, n):
        # Min-heap on price — O(N log n), but n is small
        # (usually 5–20 results shown on the page)
        return heapq.nsmallest(
            n, self.flights, key=lambda f: f["price"]
        )

    def fastest_n(self, n):
        # Min-heap on duration — a separate ranking
        return heapq.nsmallest(
            n, self.flights, key=lambda f: f["duration_minutes"]
        )

# What this proves in an interview:
# - You know that "top-N" is a heap problem, not a full sort
# - You can compute different rankings cheaply
# - You understand nsmallest is O(N log n), not O(N log N)
# - You can explain why this matters when N is 500K flights

# Travel search returns "cheapest 5" and "fastest 5"
# from a pool of hundreds of thousands. Heap is the answer.

# Graph BFS — find flight connections.
# "Which destinations can I reach in 2 stops?" is a
# classic graph traversal problem.

from collections import defaultdict, deque

class FlightGraph:
    def __init__(self):
        self.edges = defaultdict(list)  # origin -> [(destination, weight)]

    def add_flight(self, origin, dest, price):
        self.edges[origin].append((dest, price))

    def reachable_within(self, origin, max_stops):
        visited = {origin}
        queue = deque([(origin, 0)])
        reachable = []

        while queue:
            current, stops = queue.popleft()
            if stops > 0:
                reachable.append(current)
            if stops == max_stops:
                continue
            for next_dest, _ in self.edges[current]:
                if next_dest not in visited:
                    visited.add(next_dest)
                    queue.append((next_dest, stops + 1))

        return reachable

# What this proves in an interview:
# - You can model real travel problems as graphs
# - You know BFS is the right traversal for "within N"
# - You bound the search (max_stops) — production systems
#   always have to bound graph queries
# - You understand the difference between BFS and DFS

# "How far can I travel from DEL with 2 stops?" is a
# BFS problem. Travel recommendation engines use this
# pattern to suggest reachable destinations.