Data Structures in C++

Explore linked lists by building a node class with data and a next pointer, and a linked list class with header, tail, and size, plus a getter for size.

Learn to append to a linked list by creating a new node and updating header, tail, and size for empty and non-empty lists.

Prepend a node to a linked list in C++, handling empty and non-empty cases. Use a temporary pointer to preserve the first node, update header and tail, and increment size.

Learn to print a linked list by using a temporary pointer to traverse from the header to each node, printing data and advancing until null without altering the header.

Remove the first node from a linked list in C++, handling empty and non-empty cases. Use a temporary pointer to advance the header, delete the old node, and decrement size.

Learn to remove the last node from a linked list in C++, handling empty and single-node edge cases and using a two-pointer traversal to update tail and delete the node.

Remove at a certain position from a linked list demonstrates handling valid positions, removing the first or last node, and traversing to delete middle nodes while updating pointers and size.

Learn to insert a node at a specific position in a linked list, using prev and current pointers and updating size; support front with prepend and end with append.

Write a linked list destructor that safely frees every node by using a temporary next pointer, traversing from the header, deleting each node, and advancing the header until the end.

Introduce the difference between singly and doubly linked lists by adding a prev pointer to each node. Demonstrate converting a singly to a doubly linked list with minimal code changes.

Prepend to a doubly linked list inserts a new node at the beginning, handling empty and nonempty cases by updating header, tail, and size.

Append a node to a doubly linked list, handling empty and nonempty cases. Create the node, update header and tail, set next and prev, and increment size.

Validate insertion position, then insert at front, end, or middle in a doubly linked list using pre or pen methods, updating pointers and size.

Learn how to print a doubly linked list in reverse by using a temporary pointer to traverse from tail via the prev links, with code examples in C++.

Remove the first node from a doubly linked list by handling empty, single-node, and multi-node cases; update the header to the next node, delete the first node, and decrement size.

Remove a node at a position in a doubly linked list by validating position, removing the first or last node when needed, and unlinking a middle node while updating pointers.

Remove the last node from a doubly linked list by handling single-node and multi-node cases, updating header and tail, deleting the target node, and adjusting size.

Learn to insert a node at a chosen position in a doubly linked list in C++, handling invalid positions, front and end insertions, and updating pointers and size.

Explore the stack data structure, an abstract data type with push and pop operations illustrating last in, first out behavior, and learn array and linked list implementations.

Explore implementing a stack with an array in C++, including push and pop operations, a dynamic resize when full, and proper destructor memory management.

Learn to implement a stack with a linked list in C++. Create a node with data and next, manage a top pointer, and implement push and pop with empty checks.

Explore how a queue, as an abstract data type, uses enqueue and dequeue with front and rear pointers, follows first-in, first-out order, and is implemented with array or linked list.

Learn how to implement a queue with a circular array in C++, using front and rear indices, dynamic resizing, and enqueue/dequeue operations with proper empty handling.

Create a node with data and a next pointer to build a linked queue. Implement a queue with front and rear, and provide NQ and DQ operations, plus a destructor.

Understand how to insert nodes into a binary search tree in c++, starting at the root and moving left or right by comparisons.

Learn to implement the insert method for a binary search tree in C++. Build a Node class, manage a root, and use a private recursive insert to place new data.

learn how to delete nodes in a binary search tree, covering leaf, one-child, and two-child cases with min from right or max from left to keep the tree intact.

Learn to implement a binary search tree remove method in C++ by handling leaf, single child, and two children deletions, including finding the right subtree minimum.

Explore what a heap is as a binary tree with at most two children, and learn min and max heap properties, the complete-tree condition, and array representation for implementation.

Insert data into a min-heap or max-heap by placing it at the last position and percolating up with swaps to the root.

Delete a node in binary heaps by removing the root, replacing it with the last level's rightmost node to preserve completeness, then swap down for min or max heaps.

Implement the delete operation for a binary min-heap in an array, replacing the root with the rightmost node and heapifying down; the same pattern applies to a max-heap.