Software Engineering : Master Software Engineering in C#

Learn sorting algorithms using an array of numbers to produce an increasing order, and see how sorting applies to prices, orders, and other data in algorithmic problem solving.

Split the array into sorted and unsorted parts, then repeatedly find the smallest number in the unsorted portion and swap it with the first unsorted element.

Explore selection sort: identify the smallest element in the unsorted portion, swap it with the first unsorted position, and repeat until the list is sorted.

Learn how bubble sort moves the largest element to the end by repeatedly comparing adjacent numbers and swapping when out of order, then repeating passes until the array is sorted.

Learn bubble sort by swapping adjacent elements in an array, moving the largest to its correct place each pass, and using a boolean swapped flag to stop early when sorted.

Explore recursion as a central idea in computer science, where a function calls itself with smaller arguments under a terminating condition to prevent cycles.

Explore recursion and recursive algorithms by implementing factorial, highlighting base case and recursive calls, and contrast functional languages with iterative approaches in Java, C, and JavaScript.

Learn how merge sort uses recursion to split an array into halves, then merge sorted subarrays with two pointers to produce a fully sorted array.

Split the array into left and right parts using a middle index, then sort each part recursively and merge them after both calls complete.

Learn how quicksort uses the last element as pivot to partition arrays into smaller and bigger sides, swap elements, and recursively sort subarrays until base cases.

Explore a quicksort implementation that partitions with a pivot using from and to indexes, a wall, and swaps, then recurses on left and right.

Compare sorting algorithms by time and space complexity using Big O notation; understand stability and in-place requirements, with quicksort often offering the best overall performance.

Compare sorting algorithms by testing random integer arrays and timing results. The lecture covers selection sort and quicksort with a middle pivot, plus validation of sorted output.

Learn how data structures organize and store data for fast access and modification, compare arrays' inefficiency in searching, and prepare to improve its time complexity.

Explore the binary search tree, with a root and left and right subtrees of smaller and larger values. Learn insertion, search, and deletion, including leaf, one-child, and two-child cases.

Explore the binary search tree with a root and left and right children, and implement insert, search, and delete; handle leaves, single-child nodes, and two-child deletions via left-subtree maximum.

Learn how a binary search tree balances itself using balance factors and rotations, including left, right, left-right, and right-left rotations to maintain balance.

Learn how AVL tree insertion mirrors binary tree steps, then rebalance by recomputing balance factors and applying left-right or right rotations as needed.

Explore an avl tree implementation that maintains balance through insert, delete, and rebalance operations, using parent references, height calculations, and rotations (left, right, left-right, right-left).

Learn to implement a singly linked list with insert, search, and delete operations using a head and next pointers.

Master a trie by examining its root, nodes with maps, and a word indicator to store character prefixes, supporting insertion, prefix matching, search, and deletion.

Explore implementing a trie with node and trie classes, using insert, search, and delete to traverse characters, manage word indicators, and prune unused nodes along the path from root.

Explore how a hash table maps keys to indices with a hash function, enables constant-time insert, search, and delete, and resolves collisions with linked lists and Jenkin's hash function.

Create a hash table with an array of linked lists and empty index lists. Compute index via absolute value modulo size, using simple or Jenkins binary hash.

Divide and conquer breaks a problem into subproblems until they are solvable. Then it merges subproblem solutions, as in merge sort and Fibonacci examples.

Apply dynamic programming to break problems into smaller subproblems, solve each once, and reuse results to efficiently compute sequences like Fibonacci with a bottom-up approach.

Explore the greedy approach, making locally optimal choices based on the prize rather than consequences, and apply it to the Traveling Salesman Problem. See how it yields near-optimal solutions.

Explore backtracking as a brute-force search that builds candidates. The lecture demonstrates the n queens problem by placing one queen per row and backtracking at dead ends.

Explore the 0-1 knapsack problem and solve it with dynamic programming by filling a table of subproblems, deciding to include or exclude items to maximize value under weight constraints.

Kruskal's algorithm greedily builds a minimum spanning tree by adding smallest edges that don't form a cycle, using a disjoint-set to merge components until n minus one edges.