AI and Programming Glossary

Programming terms

Jump to a definition, expand its code example, then use a related lesson or problem to practise the idea.

Algorithm

A step-by-step sequence of instructions that takes an input and produces a specific output in a finite number of steps.

Explanation

An algorithm is a precise, unambiguous set of steps for solving a problem — not just a loose description of an approach, but one specific enough that a computer (or a person following it exactly) could carry it out without guessing what to do next. A recipe for baking bread is a loose, everyday example: it lists ingredients (the input), a sequence of actions, and a finished loaf (the output). In programming, an algorithm is the plan your code follows, separate from the actual code that implements it — the same algorithm for sorting a list of numbers could be written in Python, JavaScript, or any other language and would still be "the same algorithm" underneath.

Example. Consider the goal "find the largest number in a list of five numbers." One algorithm: start by assuming the first number is the largest so far; then look at each remaining number one at a time, and whenever you find one bigger than your current "largest so far," update it; after checking every number, whatever you're holding is the answer. That sequence of steps — with no ambiguity about what to do at each stage — is an algorithm, regardless of which programming language eventually implements it.

Big O NotationTime ComplexitySortingSearchingRecursion

Array

A collection of elements stored in ordered, indexed positions, so any element can be accessed directly using its numeric position.

Explanation and code example

An array stores a sequence of values side by side, each one labeled by a numeric index that usually starts at 0 for the first element. Because every element's position is known, you can jump straight to any element — read it or change it — without stepping through the ones before it, which is what makes arrays fast for lookup by position. Python doesn't have a built-in type literally called "array" for everyday use; its list type fills that role and behaves like a resizable array, growing or shrinking as you add or remove elements.

Python

temperatures = [68, 72, 75, 71]
print(temperatures[2])      # 75 — the element at index 2 (the third value)
temperatures.append(69)
print(temperatures)          # [68, 72, 75, 71, 69]

Read the related lesson →Try a practice problem →Data StructureTwo PointersBinary SearchSorting

Big O Notation

A mathematical notation that describes how an algorithm's running time or memory use grows as its input size grows, ignoring constant factors.

Explanation

Big O notation describes how an algorithm's resource use — usually time, sometimes memory — scales as the input gets larger, without getting bogged down in exact numbers like "this took 3 milliseconds." It focuses on the growth trend for large inputs and drops constant factors and smaller terms, so an algorithm that does "2n + 5" operations is still described as O(n), because doubling the input still roughly doubles the work, and that linear relationship is what matters. Common categories, ordered from slowest-growing to fastest-growing work, include O(1) (constant, unaffected by input size), O(log n) (logarithmic), O(n) (linear), and O(n²) (quadratic).

Example. Searching a phone book of n entries by checking every entry one at a time takes an amount of work that grows in direct proportion to n — that's O(n). Searching the same phone book by repeatedly jumping to the middle of the remaining range and eliminating half of it (as binary search does) takes an amount of work that grows only in proportion to how many times n can be cut in half — that's O(log n), which grows far more slowly as n gets large.

Time ComplexitySpace ComplexityAlgorithm

Binary Search

A fast search algorithm that repeatedly halves a sorted sequence to locate a target value in logarithmic time.

Explanation and code example

Binary search finds a target value in a sorted list by checking the middle element and using the result to eliminate half the remaining list at each step: if the middle element is too small, the target (if present) must be in the right half, and if it's too large, the target must be in the left half. Repeating this halving process quickly narrows the search down to a single element or confirms the target isn't present, which is why binary search examines only about log₂(n) elements instead of all n of them. The one requirement that makes this work is that the list must already be sorted — binary search cannot be used correctly on an unsorted sequence.

Python

def binary_search(numbers, target):
    low, high = 0, len(numbers) - 1
    while low <= high:
        mid = (low + high) // 2
        if numbers[mid] == target:
            return mid
        elif numbers[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

print(binary_search([1, 3, 5, 7, 9, 11], 7))  # 3

Try a practice problem →ArraySearchingAlgorithmTime Complexity

Data Structure

A specific way of organizing and storing data in memory so it can be accessed and modified efficiently for a given task.

Explanation

A data structure is a container with rules: it decides how values are arranged, which operations are allowed — adding, removing, looking something up — and how fast each of those operations is. Different data structures make different trade-offs, and no single one is best for every job: an array gives fast access by position but slow insertion in the middle, while a linked list gives fast insertion anywhere but slow access by position. Choosing the right data structure for a task is often the single biggest factor in how efficient your program ends up being, well before you worry about fine-tuning the code itself.

Example. If your program mainly needs to look values up by a name or ID rather than by position, a hash table will typically serve that need far faster than scanning through a plain list every time it needs an answer; if it mainly needs to add and remove items from one end in a strict order, a stack or a queue fits the job better than either one.

ArrayHash TableStackQueueLinked List

Dynamic Programming

A problem-solving technique that speeds up recursive algorithms by storing the results of subproblems so they're never recomputed.

Explanation and code example

Some recursive solutions end up solving the exact same subproblem many times over — for example, a naive recursive Fibonacci function recalculates fibonacci(2) dozens of times while computing fibonacci(10). Dynamic programming fixes this by saving each subproblem's result the first time it's computed, usually in a dictionary or list, and reusing that saved result instead of recalculating it — a technique called memoization. This trade of a little extra memory for a large reduction in repeated work can turn a recursive solution that takes exponential time into one that takes only linear time.

Python

def fibonacci(n, memo=None):
    if memo is None:
        memo = {}
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    return memo[n]

print(fibonacci(10))   # 55

Try a practice problem →RecursionAlgorithmTime ComplexitySpace Complexity

Edge Case

An input or condition at the extreme boundaries of what a program must handle — such as an empty input, a single element, or a maximum value — that's easy to overlook when writing code.

Explanation and code example

An edge case is an input that sits at the boundary of what your code was designed to handle, rather than a typical, "normal" input — an empty list, a single-character string, a negative number where you expected a positive one, or the very first or last element of a collection. Code that looks correct when you test it with ordinary inputs can still fail on these boundary inputs if you didn't specifically consider them while writing it, which is why deliberately testing edge cases is one of the most effective habits for catching bugs before they reach users. Common edge cases worth checking include an empty collection, a collection with exactly one element, duplicate values, and the largest or smallest values a program is expected to support.

Python

def average(numbers):
    return sum(numbers) / len(numbers)

print(average([2, 4, 6]))   # 4.0 — works fine for a typical list
print(average([]))           # ZeroDivisionError — the empty-list edge case was never handled

AlgorithmArrayString

Hash Table

A data structure that maps keys to values using a hash function, giving average-case constant-time lookup, insertion, and deletion.

Explanation and code example

A hash table stores data as key-value pairs and uses a hash function — a calculation that turns a key into a number — to decide exactly where that pair should be stored. That's what makes lookups so fast: instead of scanning through every stored item to find a match, the hash table recalculates the hash of the key you're searching for and jumps almost directly to where it should be. Python's built-in dict type is a hash table: keys can be strings, numbers, or other immutable values, and looking up a value by its key takes roughly the same amount of time whether the dictionary holds ten entries or ten million.

Python

inventory = {"apples": 40, "bananas": 25}
inventory["cherries"] = 60      # insert a new key-value pair
print(inventory["bananas"])      # 25 — found directly by key, no scanning required
print("grapes" in inventory)      # False

Try a practice problem →Data StructureArrayTime Complexity

Linked List

A data structure made of nodes, where each node holds a value and a reference to the next node, forming a chain instead of contiguous memory.

Explanation and code example

Unlike an array, whose elements sit next to each other in memory at fixed positions, a linked list is built from separate nodes scattered wherever memory happens to be free, each one holding a value plus a pointer (a reference) to the next node in the chain. To reach the fifth node, you have to walk the chain from the first node through the fourth, since there's no way to jump directly to a position the way you can with an array index. That trade-off — slower access by position, but the ability to insert or remove a node anywhere without shifting every other element — is what makes linked lists useful in situations where an array's contiguous layout would be inconvenient.

Python

class Node:
    def __init__(self, value, next=None):
        self.value = value
        self.next = next

head = Node("a", Node("b", Node("c")))
current = head
while current:
    print(current.value)     # prints "a", then "b", then "c"
    current = current.next

Data StructureArrayQueue

Palindrome

A sequence — such as a word, phrase, or number — that reads the same forwards and backwards.

Explanation and code example

A palindrome is any sequence that's identical whether you read it from the front or from the back — "racecar" and "level" are palindromes, while "python" is not, since reversing it gives a different sequence. Checking whether something is a palindrome is a common exercise for practicing string manipulation and the two-pointers technique, since you can compare characters from both ends moving inward instead of building and comparing a fully reversed copy. Palindrome checks sometimes need to decide how to treat spaces, punctuation, and letter case — "A man, a plan, a canal: Panama" only reads as a palindrome once those are stripped out and the letters are lowercased.

Python

def is_palindrome(word):
    return word == word[::-1]     # word[::-1] reverses the string

print(is_palindrome("racecar"))  # True
print(is_palindrome("python"))    # False

Try a practice problem →StringTwo Pointers

Queue

A first-in, first-out (FIFO) data structure where elements are added at the back and removed from the front.

Explanation and code example

A queue models a waiting line: new elements join at the back, and the only element you can remove is the one at the front, which is whichever element has been waiting longest. This "first in, first out" order is the opposite of a stack's last-in-first-out order, even though both structures restrict you to adding and removing at specific ends. Queues show up naturally whenever things need to be processed in the order they arrived, such as tasks waiting to be handled or messages waiting to be delivered.

Python

from collections import deque

line = deque()
line.append("Alex")
line.append("Bo")
line.append("Cam")
print(line.popleft())  # "Alex" — the first person to join is the first to leave
print(line)              # deque(['Bo', 'Cam'])

Data StructureStackLinked List

Recursion

A technique where a function solves a problem by calling itself on smaller versions of the same problem until it reaches a base case.

Explanation and code example

A recursive function is one that calls itself, but with a smaller or simpler input each time, gradually working its way down toward a base case — a version of the problem simple enough to answer directly, without any further self-calls. Every recursive function needs that base case, or it will keep calling itself forever (in practice, Python will eventually raise a RecursionError once it runs out of call-stack space). Recursion suits problems that are naturally defined in terms of smaller versions of themselves, such as computing a factorial or walking through a nested structure like a linked list.

Python

def factorial(n):
    if n == 0:                     # base case: stop recursing
        return 1
    return n * factorial(n - 1)     # recursive case: solve a smaller subproblem

print(factorial(4))   # 24  (4 * 3 * 2 * 1 * 1)

Try a practice problem →AlgorithmDynamic ProgrammingStackSpace Complexity

Searching

The process of locating a specific value or item within a collection of data.

Explanation and code example

Searching means checking a collection to find out whether a particular value is present, and if so, where. The simplest approach, linear search, checks each element one at a time from the start until it finds a match or runs out of elements — it works on any collection, sorted or not, but in the worst case has to examine every element. When the data is already sorted, a smarter approach like binary search can find a match while examining far fewer elements, which is why the structure of your data often determines which search strategy makes sense.

Python

def linear_search(items, target):
    for index, value in enumerate(items):
        if value == target:
            return index      # found it — return its position
    return -1                  # target not found anywhere in items

print(linear_search([4, 8, 15, 16, 23], 15))  # 2

Try a practice problem →AlgorithmBinary SearchArrayTime Complexity

Sorting

The process of arranging the elements of a collection into a specific order, typically ascending or descending.

Explanation and code example

Sorting rearranges a collection's elements — numbers, strings, or any comparable values — into a defined order, most often smallest-to-largest or largest-to-smallest. Many different sorting algorithms exist, and they differ mainly in how much time and extra memory they need as the list grows: some, like bubble sort, are simple to understand but slow on large lists, while others, like the algorithm behind Python's built-in sort, are more complex but scale well. Sorting is also a common first step before other operations, since some techniques — including binary search — only work correctly on data that's already sorted.

Python

scores = [42, 17, 89, 3, 56]
print(sorted(scores))                 # [3, 17, 42, 56, 89] — ascending order
print(sorted(scores, reverse=True))    # [89, 56, 42, 17, 3] — descending order

AlgorithmArrayTime ComplexitySearching

Space Complexity

A measure of how much extra memory an algorithm needs as its input size grows, usually expressed using Big O notation.

Explanation and code example

Space complexity measures how much additional memory an algorithm needs beyond the input it was given, and how that extra memory usage grows as the input grows. A function that builds a brand-new list the same size as its input needs O(n) extra space, while a function that only uses a few fixed variables — no matter how large the input is — needs O(1) extra space, also called constant space. Recursive functions have a space cost that's easy to overlook: each call waits on the call stack until its recursive call returns, so a recursive function with n nested calls uses O(n) space for the call stack alone, even if it never creates a single new list.

Python

def double_values(numbers):           # O(n) space — builds a brand-new list of the same size
    return [n * 2 for n in numbers]

def double_values_in_place(numbers):  # O(1) extra space — modifies the existing list directly
    for i in range(len(numbers)):
        numbers[i] *= 2
    return numbers

Big O NotationTime ComplexityRecursion

Stack

A last-in, first-out (LIFO) data structure where elements are added and removed only from the same end, called the top.

Explanation and code example

A stack only lets you interact with one end of its collection, called the top: you can push a new element onto the top, or pop the top element off, but you can't reach into the middle. This "last in, first out" behavior means the most recently added item is always the first one to come back out — like a stack of plates, where you add and remove plates from the top, not the bottom. Stacks are a natural fit for problems involving nested or reversible structure, such as checking whether every opening bracket in an expression has a matching closing bracket.

Python

stack = []
stack.append("a")
stack.append("b")
stack.append("c")
print(stack.pop())   # "c" — the most recently added item comes off first
print(stack)           # ["a", "b"]

Try a practice problem →Data StructureQueueRecursion

String

A sequence of characters used to represent text, treated in Python as an ordered, immutable collection you can index and slice.

Explanation and code example

A string is a piece of text — a sequence of individual characters stored in order, written between quotes in Python source code. Like an array, each character in a string sits at a numeric index, so you can read a single character or a range of characters by position. Unlike a Python list, however, a string is immutable: once created, you can't change one of its characters in place, so any "modification" — like uppercasing it or replacing a letter — actually produces a brand-new string rather than editing the original.

Python

greeting = "hello"
print(greeting[1])        # "e" — the character at index 1
print(greeting.upper())    # "HELLO" — a new string; greeting itself is unchanged
print(greeting)             # "hello"

Try a practice problem →ArrayPalindromeTwo Pointers

Time Complexity

A measure of how the number of operations an algorithm performs grows as its input size grows, usually expressed using Big O notation.

Explanation and code example

Time complexity answers the question "as the input gets bigger, how much more work does this algorithm have to do?" — not measured in actual seconds, which depends on the computer running it, but in how the number of basic operations scales with input size. A function that loops once over every element of a list of size n does roughly n units of work, so its time complexity is O(n); a function that only ever looks at one fixed element, regardless of how big the list is, does a constant amount of work, so its time complexity is O(1). Comparing time complexities lets you predict which of two approaches will hold up better as the input grows, even before you've measured either one running.

Python

def print_all(items):        # O(n) — one loop through every item, work grows with input size
    for item in items:
        print(item)

def print_first(items):      # O(1) — constant time, regardless of how long items is
    print(items[0])

Big O NotationSpace ComplexityAlgorithm

Two Pointers

A technique that uses two index variables moving through a sequence — often from opposite ends or at different speeds — to solve problems in a single pass.

Explanation and code example

The two-pointers technique tracks two positions in a list or string at the same time, instead of just one, and moves them according to rules that depend on the problem. A common pattern is to start one pointer at the beginning and one at the end, then move them toward each other, comparing the elements they point to as they go — useful for checking whether a sequence reads the same forwards and backwards. Because both pointers move through the sequence only once between them, this technique often turns a solution that would otherwise need nested loops into one that runs in a single linear pass.

Python

def is_palindrome(text):
    left, right = 0, len(text) - 1
    while left < right:
        if text[left] != text[right]:
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome("level"))  # True

Try a practice problem →ArrayStringPalindrome