Java Data Structures & Algorithms + LEETCODE Exercises

Explore the first big O notation, O(n), by running a for loop that executes n times and prints items from 0 to n-1, illustrating a proportional line on a graph.

In this lecture on big o, learn how to drop constants and simplify o(2n) to o(n) when two n-time loops run, clarifying the role of constants in algorithm analysis.

Illustrate how nested for loops yield O(n^2) time complexity and compare it to O(n), highlighting how restructuring code can reduce run time and improve efficiency.

Apply drop non-dominants to simplify big O by showing that O(n^2) plus n reduces to O(n^2) as n grows, using nested loops and a separate for loop.

Compare linked lists to array lists, highlighting dynamic length and noncontiguous memory; define head and tail pointers, and nodes with next pointers ending in null, to illustrate basic structure.

Code the remove last method for a linked list, handling empty and single-node edge cases, updating head, tail, and length, and returning the removed node.

Learn how to remove the first item from a linked list by updating head, using a temp node, and handling empty, one-item, and multi-item edge cases.

Implement the set method for a linked list by using the get method to locate a node at an index, update its value, and return true or false.

Implement the remove method for a linked list, deleting the node at a given index and returning the removed node, with bounds checks for out-of-range indices and updating the links.

Reverse a linked list in place by flipping arrows with head, tail, and a temp pointer, using after and before to traverse and a for loop across its length.

Explore the has loop exercise by using slow and fast pointers to detect a cycle in a linked list, distinguishing end-of-list cases from loops and understanding the no-code strategy.

Learn to convert a binary linked list to decimal by a doubling accumulator: start with the first node, then double the total and add the next node value.

Implement remove last method for a doubly linked list by moving tail to tail.previous, breaking tail.next connection, and returning the removed node, while handling empty and single-item edge cases.

Implement the remove first method for a doubly linked list, handle empty and single-item edge cases, update head and links, return the removed node, and test the method.

Create a set method for a doubly linked list that updates a node's value at an index using get, returning true on success or false if out of range.

Implement a doubly linked list insert method that places a new node at a given index, handling edges with prepend and append, updating pointers and length, and returning a boolean.

Implement a remove method for a doubly linked list that validates the index, uses existing remove first/last for ends, unlinks middle nodes, updates length, and returns the removed node.

Explore partitioning a doubly linked list for values less than five and those greater than or equal to five, and address the edge case when the second list is empty.

Explore stacks with the tennis ball analogy, learn LIFO behavior, and implement stacks using array lists or linked lists by push and pop, focusing on top operations and Big-O performance.

Build a stack constructor by creating a node with a value (and next), set top to that node, and height to one, removing the bottom pointer.

Create a push method for a stack in Java, handling an empty stack by setting top to a new node and linking to the top when items exist, increase height.

Build queue by creating node class with value and next, and queue class with first, last, length. Initialize with a node and expose get first, get last, get length.

Implement the dequeue operation for a queue, handling empty, one-item, and multi-item cases, returning the dequeued node and updating first, last, and length accordingly.