Learn to sort an array by arranging its elements in increasing order, preserving the same values, with examples like sorting by price or number of orders.

Discover how selection sort builds a sorted section by repeatedly finding the smallest element in the unsorted part and swapping it with the first unsorted position, advancing the wall.

Bubble sort moves the largest element to the end with each pass by comparing adjacent numbers and swapping when out of order. Repeat passes until no swaps occur.

Implement bubble sort by swapping adjacent elements to bubble the largest value to the end, and use a swapped flag to stop early when no swaps occur.

Learn recursion, a central idea in computer science, where a function calls itself with smaller arguments and requires a termination condition to avoid cycles.

Merge sort uses recursion to split an array into two halves until single elements, then merges them with two pointers to produce a sorted output.

Learn how merge sort splits an array at the middle, recursively sorts left and right parts, and merges them into a single sorted array using two indices and temporary arrays.

Quicksort uses the last element as pivot to partition an array into smaller left and bigger right parts, swapping elements and recursively sorting parts until each has one item.

Understand quicksort in C++ by partitioning an array with a pivot, using from and to indexes, swapping elements, and recursing on left and right.

Compare sorting algorithms by time and space using big O notation, noting quicksort is often fastest, while merge sort is stable and useful for large data sets.

Compare sorting algorithms in C++ by testing random arrays, verifying order, and measuring execution time, including selection sort, bubble sort, merge sort, quick sort, and quick sort with medium pivot.

Understand how big O notation hides unimportant constants and highlights growth rates, comparing constant, linear, and quadratic time. Analyze practical examples using arrays and worst-case scenarios to determine time complexity.

Define data structures as the way to organize and store data for fast access and modification, and compare array inefficiencies to illustrate how to improve search time.

Explore binary search trees, including root, left and right subtrees, and leaves, and learn insertion, search, and deletion cases with related complexity.

The lecture explains how a binary search tree uses nodes with left and right children and covers insert, search, and delete operations, including the successor.

Insert numbers into an AVL tree using binary-tree logic, recomputing balance factors along the path to the root and applying left, right, and left-right rotations as needed.

Delete in an AVL tree follows binary search tree deletion, then update balance factors up to the root, performing rotations such as right-left to restore balance when factors reach ±2.

Implement an AVL tree with parent pointers, left and right children, and balance-aware rotations. Learn inserting, deleting, searching, and balancing via left, right, left-right, and right-left rotations.

Learn to implement a linked list with nodes and next pointers, insert at the head in constant time, search by traversing and comparing values, and delete by updating pointers.

Explore how a trie uses a root and child nodes to store words by prefixes, with a map of characters and a word indicator to mark complete words.

Explore trie structures in C++: insert, search, and delete words by traversing character paths, using node records and a word indicator to mark complete words.

Learn how hash tables map keys to values using a hash function to compute indices. Explore collisions and linked-list chaining, and see Jenkin's hash function in action.

Explore a hash table built from an array of linked lists with Jenkins variants. A constructor initializes lists; insert, search, and delete use an absolute-value hash modulo the size.

Divide and conquer algorithms recursively break a problem into subproblems and merge their solutions to form the final result, as shown by the sorting algorithm and Fibonacci example.

Learn how greedy algorithms make a series of local, price-based choices in graph problems such as the traveling salesman problem, trading optimality for simplicity and lower computation.

Explore backtracking, a brute-force approach that incrementally builds candidates row by row until a valid solution is found or proven impossible, illustrated by the queens problem on a chessboard.

Kruskal's algorithm finds the minimum spanning tree by greedily adding the smallest edges that connect different components, using a disjoint-set structure to avoid cycles until n-1 edges exist.

Dijkstra's algorithm finds the shortest path in a graph by using a priority queue to explore nodes by increasing distance and update paths, with a practical example.