Learn Data Structures using C in Arabic - for beginners

Explore core data structures in c, including arrays, linked lists, stacks, queues, trees, and hashing, along with time and space complexity, abstract data types, and encapsulation in c/c++.

Learn how to reverse a string using a stack in C, pushing characters onto an array, and printing the result, while understanding user level and main functions.

Explore data structures in C by building and manipulating queues and stacks, including push, pop, display, and size operations, with front and rear indexing and is full or empty checks.

Explore implementing and using linked lists and arrays in C, with insert and delete operations, dynamic memory and pointers, and queue, stack, and sorted/doubly linked list concepts.

Learn to implement a linked list and a stack in C with pointers and typedefs, and build a queue with front and rear pointers, including push, pop, and destroy operations.

Explore stacks, queues, and linked lists in C, including circular queues and memory concepts. Practice insertion and deletion, and understand overflow and underflow conditions.

Learn data structures by building trees, exploring roots, leaves, parents and children, subtrees and degree, using binary trees and binary search trees with in-order, pre-order, and post-order traversals.

Explore data structures in C, including dictionaries and hash tables with collision handling, insertion and search operations, and graph fundamentals with DFS and BFS for shortest paths.

Explore time complexity concepts, including big-O, theta, and Omega notations, and compare worst, average, and best cases across search and sort algorithms, with growth orders from linear to factorial.

Explore abstract data types and encapsulation, and learn how interfaces separate contracts from implementation in stack data structures, with push and pop operations demonstrated in C.

Design and implement data structures in C using header and implementation files. Apply encapsulation and type abstraction to create a two-level user and implementation workflow.

Examine the stack data structure, its last-in, first-out behavior, and applications such as evaluating arithmetic expressions, backtracking, delimiter checking, and reversing data using push and pop operations in C.

Explore the concept of an array-based stack, learn push and pop operations, track the top element and size, and understand index handling and element management.

Define and implement an array-based stack in c, including the stack structure, entry type, and core operations such as push, pop, top, and destroy.

Explore the queue as a linear data structure with front and rear, applying first in, first out, and compare it to a stack's last in, first out.

Explore queue concepts and first come, first served scheduling with semaphores, device buffers, and CPU scheduling shaping memory management and shared resources.

Explore variations of queues in data structures, including simple queues, circular queues, priority queues, and a doubly ended priority queue, with focus on length, time, and insertion.

Explore the array-based queue concept and its circular implementation in C, covering front and rear indices, memory layout, and queue operations.

Learn to implement an array-based queue in C, including front and rear handling, queue creation, display, size, check full, and destruction.

Learn how to implement a circular queue using an array in C, manage the front and rear indices, and apply modulus with the maximum size to control element insertion.

Explore array-based queue implementation in C, focusing on front and rear handling, displaying elements, tracking size, and providing destroy and empty/full checks.

Learn how to implement an array-based queue with front and rear indices, support circular buffering, and a function to return the maximum element in the queue.

Implement an array-based queue in C with size-tracking and front and rear indices. Create a function that returns the maximum (and minimum) integer currently in the queue.

Explore dictionaries as a data structure that maps keys to values, highlighting elements, possible implementations, and concepts like sorted lists, binary search trees, and hash tables.

Explore the AVL tree concept within binary search trees, explaining balanced height where left and right subtrees differ by at most one and how this yields an ideal balanced structure.

Learn hashing concepts and hash functions, mapping keys into positions in a hash table, handling collisions with modulus-based placement, and using hash functions as map keys.

Explore hash tables as an effective way to implement a dictionary, using a hash function to map keys to indices for insert, delete, and search operations.

Learn how a hash table handles insertion by using a hash function to derive an index, apply modulus with the table size, and place data at the computed slot.

Learn how hash tables handle collisions using open addressing and chaining with linked lists, covering insertion, deletion, and hash function behavior.

Explore hash tables with open addressing, perform search and deletion using a hash function to locate indices, handle collisions, and support insert operations.

Explore graph data structures in C, including grid graphs, and learn how graphs model connections and networks, with examples like maps.

Explore graph components by identifying vertices, nodes, and edges within a graph, and understand how components define the graph structure.

Explore directed versus undirected graphs, showing how directed graphs have a direction for traversal, while undirected graphs allow two-way traversal between nodes; discuss cycles and paths.

Explore weighted versus unweighted graphs in data structures, comparing edge costs, nodes, and shortest paths from A to C, and learn how weights influence path selection.

Explore successor and predecessor vertices in both directed and undirected graphs, focusing on how adjacent nodes and neighborhoods relate to edges, sources, and targets.

Compare cyclic and acyclic graphs, examine how traversal detects cycles, and understand why a graph is described as cyclic or acyclic.

Learn how to determine adjacent vertices from an initial vertex in both directed and undirected graphs, including nodes, edges, and adjacency sets.

Learn about simple paths and simple cycles in directed graphs, with nodes and edges, sample paths, and a lemma for a vertex.

Explore types of graphs, including complete, sparse, and dense graphs. Learn how edges connect nodes and determine the maximum number of edges.

Examine graph theory basics: directed or undirected graphs, cyclic structures, and graph data elements, then explore time graphs and core algorithms for these structures.