Data Structures and Algorithms Overview

The algorithmic paradigm that breaks a problem into smaller pieces, solves each individually, and then recombines the results.

An algorithmic paradigm that builds up the solution to a problem by solving subproblems in a bottom-up manner.

An algorithmic paradigm that makes the best-looking decision at each step, hoping it leads to the optimal final solution.

The number of times a node is visited in a Breadth First Search (BFS) traversal of a graph.

The total number of connections pointing to a node in a directed graph.

A sequence of nodes in a graph that cannot be the sequence examined during a search for a specific key in a Binary Search Tree.

The time complexity required by an algorithm that examines every subsequence of a sequence to check if it is also a subsequence of another sequence. In the worst case, this approach is exponentially inefficient.

The technique of storing previously calculated values in dynamic programming to avoid recalculating them.

A method for searching through a linked list in a linear fashion, one element at a time, until the target element is found.

A data structure that provides fast access to elements using their index, making it suitable for storing fixed sequences of data.

The process of sorting elements in an array by iterating through the array and placing each element in its correct sorted position.

A sorting algorithm that repeatedly selects the minimum element from the unsorted portion of an array and places it at the beginning of the sorted portion.

A heap data structure that maintains the property that the value of each parent node is greater than or equal to the values of its children.

A type of hash table where collision resolution is handled by linearly probing for the next available slot in the table.

A binary tree where the values of the nodes are arranged in a specific order, such that the value of any node is greater than all the values in its left subtree and less than all the values in its right subtree.

The order in which nodes are visited during a depth-first traversal of a tree.

The order in which nodes are visited during a depth-first traversal of a tree where each node is visited after its left subtree and right subtree are fully explored.

The order in which nodes are visited during a depth-first traversal of a tree where each node is visited before its left subtree and right subtree.

An algorithm that finds the shortest paths between all pairs of vertices in a graph. It uses dynamic programming to store intermediate results and build up solutions.

A data structure that allows elements to be added and removed from only one end, like a stack of plates where you can only add plates on top or remove plates from the top.

A data structure that allows elements to be added and removed from both ends, like a line of people where you can join at the back or leave from the front.

A data structure that represents relationships between objects, where each object is a node and each relationship is an edge.

A data structure that organizes elements in a hierarchical structure where each element has a parent and zero or more children.

The average time complexity of a search operation in a linear probing hash table, especially when the keys are randomly distributed and the hash table is not too full.

The worst-case time complexity of finding an edge between two vertices in an undirected graph represented using an adjacency list.

A connected, undirected graph with a minimum number of edges that connects all the vertices in the graph.

The time complexity required to merge two sorted arrays in the mergesort algorithm, which is proportional to the total number of elements in both arrays.

The order in which nodes are visited in a depth-first traversal of a graph.

A special type of edge in a depth-first search (DFS) traversal of a graph that connects a node to an ancestor node, indicating a cycle in the graph.

The worst-case time complexity for a specific sorting algorithm, indicating the maximum amount of time the algorithm could take to sort a given input.

The sorting algorithm that typically results in the fewest swap operations, making it efficient in terms of minimizing the number of exchanges between elements.