C Language + Algorithms + Data Structures = Power

Learn to write a C program that reads a base and an exponent, then computes and prints the power using the pow function and a custom loop-based power function.

learn to write a C program that reads text from standard input and prints the second five characters (indices 5-9) if length exceeds ten, using pointer arithmetic.

Write a C program that reads a date in mm/dd/yyyy and computes total days as year*360 plus month*30 plus day, using string-to-long conversion or a format-based input function.

Create a case-insensitive program that reads text, converts it to lowercase, counts each character’s occurrences, and prints the results using a compute function with a seen array.

Count character occurrences with a 256-element array in a one-pass greedy approach, converting to lowercase and printing nonzero counts for each character.

Explains the stack data structure, a last-in-first-out abstract data type and container, introducing push and pop operations and comparing static array implementations with dynamic, pointer-based stacks.

Learn to implement a stack in C by creating a stack, using a stack node, a top pointer, and size, with push, pop, and empty checks and malloc memory.

Learn the queue data structure, a first in, first out container built with nodes and pointers, featuring front and back, dynamic implementation with structs and typedefs, push and pop operations.

Implement queue primitives in C by creating a queue with front and back pointers and a size, then push and pop elements, showing a constant number of operations.

Explore the tree data structure, nodes with left and right children, and binary search trees, as you insert distinct elements from root to leaves.

Learn to implement binary search tree insertion: create a tree, test emptiness, and insert elements by traversing left or right, handling duplicates, updating size.

Demonstrates a recursive print tree function that traverses left, prints the node, then right to produce in-order output; discusses pre/post/infix printing variants and tree balancing with AVL and red-black trees.

Explore how graphs model networks, from nodes and weighted edges to adjacency lists and matrices, and distinguish directed versus undirected and weighted versus unweighted graphs.

Create and initialize a graph in C, allocating memory for nodes and edges with directed or undirected modes. Print the adjacency and add edges to enable graph traversals and algorithms.

Explore recursion, where a function calls itself to solve a problem by breaking it into subproblems, illustrated by the factorial example and its recurrence relation in a simple fact program.

Examine recursion in C with level 1 order factorial and level 2 order Fibonacci. Learn how recurrence relations drive merge sort and graph traversal in data structures.

Print a multiplication table using two nested loops, with an outer loop for rows and an inner loop for columns, and analyze the complexity as order n squared.

Explore bubble sort implementation in C, comparing adjacent elements, performing swaps with a temporary variable, and validating the sorted array with a test print.

Explore bubble sort and its o(n^2) time complexity by analyzing constant operations, inner and outer loops, and how the algorithm repeatedly moves the largest elements to the right.

Master insertion sort by taking each unsorted element, copying it to a temporary variable, shifting larger elements right, and inserting it in its correct position, with O(n^2) worst-case time.

Explore merge sort, a recursive divide-and-conquer algorithm that splits an array into halves, sorts subarrays of size one, then merges them into a fully sorted array, achieving O(n log n).

Explain how merge sort recursively divides an array into two halves using the middle index, merges sorted subarrays with a temporary array, and copies result back, achieving O(n log n).

Learn how depth first search traverses a graph by marking nodes as visited, exploring each neighbor recursively, backtracking when needed, and deriving a simple dfs pseudocode with a visited array.

Implement a depth-first search on a 13-node graph by initializing a visited array, traversing adjacency lists, and printing each node when visited, while invoking DFS across all components.

Implement breadth-first search in C using a queue, a boolean visited array, and adjacency neighbors to print reachable nodes from a start vertex, with a loop to cover all components.

Count the number of paths between two nodes in a graph using depth-first search with backtracking and a visited array; the example from 0 to 6 yields six paths.

Implement a recursive depth-first search to count paths between two graph nodes, using a visited array and neighbor traversal; base case returns one, showing six paths from 0 to 6.

Learn how the Dijkstra's shortest path algorithm computes the minimum distances from a start node to all vertices, builds a shortest-path tree, and uses relaxation with a priority queue.

Implement the Dijkstra shortest path algorithm in C, using a heap-backed graph, distance and parent arrays, and path reconstruction from source to destination.

implement a c program that uses a recursive function f(n, b) to print a number in nested square brackets, with base case b = 0 and bracket management.

Define a max size and initialize a char matrix, then implement a recursive function af to process submatrices, print the matrix, and demonstrate the Sierpinski triangle.

C program takes two integers and prints numbers from the first up to the second using recursion; for example 4 to 11 prints 4 through 11.

Recursively prints a string by using a char pointer in reverse, printing the current char, recursing to the next, then backtracking to the null terminator.