
In order to write and run C programs you will need to install an IDE (interactive development environment).
In this video will will install an IDE , Write our very first program, Break it down and explain the meaning of every keyword. We will cover Fundamentals of building your project as well as an introduction to all of the notions you need to know to get started.
Variables are one of the most idea in programming , in face every programming language has the notion of variables. They (Variables) are basically a way to store data temporarily to serve more sophisticated job.
Explore non-integer data types in C, including double and float, printing with %f, and operations on real numbers. Learn chars, strings, integer ranges, and signed versus unsigned types.
Explore constants and macros in C, including decimal, octal (prefix 0), hex (prefix 0x), macro replacement with #define, and preprocessing, plus string continuation with backslash.
Explore C language operators, including pre- and post-increment and decrement, relational comparisons (>, <, ==, !=, >=, <=), and logical operators (&&, ||, !), with practical examples.
Explore conditional programming basics with if statements, else and else if chains, and braces to group code, plus the conditional expression using the question mark and colon and switch statements.
Explore loops by demonstrating for, while, and do-while constructs that repeat code, such as printing hello, and see how initialization, condition, and increment control execution.
Explore arrays as a fundamental data structure in C, declare and initialize a 10-element container, access elements by zero-based indexes, and print or traverse them with for loops.
Functions take input and produce output, like math functions, with parameters. Learn about return types, including void functions, and modular design that simplifies code, using the Pandora's box metaphor.
Explains how to implement a factorial function using a for loop, tests factorial values such as 4 and 7, and demonstrates comments, operators, and value-based parameter passing.
Define a C struct to group related data into a single variable, access its members with dot notation, and optionally use typedef to simplify typing for later data structures.
Learn how to read user input in C using scanf, passing variable addresses with the ampersand, and handling integers, characters, and strings stored in character arrays.
Learn how pointers store addresses of variables, dereference to access values, and use malloc for dynamic memory, including arrays and structs.
Implement a function that takes an integer array and its size, returns the sum, then test it in main by filling the array from user input and printing the result.
Learn how variable scopes separate same name variables across local and global contexts, how braces create new scopes in functions and loops, and how local variables take precedence over globals.
Demonstrate two-dimensional arrays as matrices with rows and columns, showing how to declare and index with [row][col], fill via loops, print row by row, and transpose.
Use breakpoints and watches to step through code, observing variable changes as the matrix is filled from top-left to bottom-right, revealing how nested loops and debugging illuminate program execution.
Learn how break quits a loop and how continue skips to the next iteration, with examples in for, while, and do-while loops.
Define an enumerator to create a month type with predefined values, store them in a variable, compare order-based values, and typedef the enum for reuse.
Learn how to pass pointers as function arguments to modify the original variable by sending its address and using dereferencing to change the content.
Understand that in C, strings are arrays of characters ending with the null terminator, with characters treated as numbers and compared using strcmp for accurate results.
Learn to concatenate strings in C with strcat, copy with strcpy, read input with gets and getchar, and compare strings; note that C lacks the + operator.
Compile C programs manually on Windows using gcc from the code blocks toolchain. Configure PATH to access gcc, create a hello world file, and run it from the command line.
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 solve problem 3 in C by reading an array size, filling it with integers, printing all elements, and identifying the maximum with a loop.
Compute the number of combinations (n choose p) in C by implementing a factorial function, applying the formula, and reading inputs from standard input to print the result.
Implement a real-number exponential function by summing x^i / i! from i = 0 until the term falls below 0.001, using a factorial helper and an expo 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.
Declare a stack node in C with a value and a next pointer. Typedef the stack as Stack and implement it with a head pointer to top and a size.
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 singly linked lists by examining nodes, next pointers, and the role of the head and size metadata. Implement and manipulate lists with create, is_empty, and traversal operations.
Explain how to implement singly linked lists with front insertion, including creating nodes, updating head and size, and testing by popping elements to confirm stack-like behavior.
Learn to add and remove nodes in a singly linked list by implementing push back and pop back operations, iterating to the last node and handling empty lists.
Learn how doubly linked lists differ from singly linked lists with head and tail pointers, and implement push front and push back operations.
Explore doubly linked list pop operations, including pop front and pop back, with careful handling of empty and single-element lists and updates to head, tail, and size, plus memory cleanup.
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.
Represent a graph in C using an adjacency list, with edge nodes containing destination, weight, and next pointer, and a graph struct tracking nodes, edges, and directed flag.
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.
Explain heap theory with max and min heaps using a simple array; root at index 1, left and right children at 2i and 2i+1, insert bubbles up, extract bubbles down.
This video comes with the downloadable source code (The source code has a slight change, so please check it out)
Learn heap extraction for max-heap and min-heap: check emptiness, remove root, replace with last, and percolate down by swapping with the larger (or smaller) child.
Explore how algorithms are sets of instructions to reach a goal and the heart of every program you use. Apply sorting, searching, graph algorithms, and optimization to understand solving problems.
Learn to detect palindromic sequences by comparing characters from the start and end of a string, advancing inward with two indices, like radar, and returning true when all pairs match.
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.
Explore complexity theory by relating input size to time and space using Big O notation. Compare worst, best, and average cases with examples such as linear search and sorting.
Explore complexity theory, from log time to factorial, with divide-and-conquer ideas and examples like binary search, merge sort, quicksort, and heapsort.
Learn to count occurrences of each number in an array by comparing the O(n^2) approach to a linear-time method using an occurrences array, and discuss space trade-offs and hash tables.
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.
Apply the master theorem to divide-and-conquer recurrences to determine a recursive algorithm’s complexity. Analyze subproblem count a, subproblem size b, and merge cost n^k using merge sort examples.
Explore the brute force solving paradigm by testing all possibilities to satisfy a condition, with examples like finding dividers and counting graph paths, noting it is often the worst solution.
Learn bubble sort, a simple sorting algorithm that compares adjacent elements and swaps them to sort an array of numbers. It uses a boolean flag to detect completion.
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.
Implement the selection sort algorithm by finding the minimum in the unsorted portion, swapping it with the current target, and repeating until the array is sorted, with O(n^2) complexity.
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).
Implement merge sort in C by building a merge function, merging two subarrays into a temporary array, and applying the recursive sort for an O(n log n) performance.
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.
Learn how breadth-first search traverses a graph in level order using a queue. Start from a node, visit its unvisited neighbors by level, and continue until all nodes are explored.
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.
This lecture demonstrates customizing a heap to store edges with vertex and weight for Dijkstra's shortest path, and tests by inserting edges and extracting by increasing weight.
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.
Implement a recursive C function f(n) that prints 0 when n equals 0, or a left parenthesis, two f(n-1) calls separated by a plus, and a right parenthesis.
This lecture presents a C program that prints the Sierpinski triangle on a grid via recursion, using a base-case hash and three recursive calls for top-left, top-right, and bottom-left.
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.
Explore the recursive solution to towers of Hanoi with three rods, moving one disk at a time under size constraints, and printing the optimal move sequence.
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.
In this course I will be teaching you everything you need to learn in order to become a professional C programmer , Algorithm designer and a problem solver. Whether you are a beginner or an experienced programmer , this course will fill all the gaps and give you a strong foundation and prepare you for an expert professional coding life.
If you chose computer sciences then Learning C is mandatory , Every kind of software was made with C, Operating systems such as Linux (The Most popular OS on earth), Version control systems such as Git (The most used Version control system on earth), Web servers such as Apache (The most popular web server on earth), Video game engines such as Unity3d (The most popular game engine on earth), Video encoders such as H.264 (The most popular and widely used video encoder on earth) , even most popular programming language were originally written in c such as c++ , c# , java , javascript, objective c... All of them was written with C. For that reason , any giant high tech company such as google , Microsoft ,IBM... will happily hire any programmer who masters C , Algorithms and Data Structure. So what are you waiting for ? Enroll now and let the journey begins.
This course will cover the following topics:
Course 101:
Algorithms:
Data Structures:
Problem set: