Data Structure
Fundamentals of Data Structures and Algorithms
What you'll learn
- Understand the types of basic and non-basic data structures
- Understand how data structures relate to algorithm design
- Distinguish between linear and non-linear structures
- Understand how arithmetic expressions are represented
- Use a stack to convert between expression forms
- Distinguish between static and dynamic structures
- Implement stack algorithms in the C language
- Understand the queue and implement its basic operations
About this course
This course explains data structures and how they relate to algorithm design and programming. Data structures are the ways information is organized inside a program so that it is easy to store and access. The course starts with an introduction, then the relationship between data structures and algorithm design, and the types of data structures: basic and non-basic, linear and non-linear. After that you learn how to represent expressions in infix, prefix and postfix forms and how to use a stack to convert from infix to postfix, then static and dynamic data structures in two parts. You go deeper into the stack and the algorithms of its basic operations, with a complete example in the C language and a practical code implementation, then you meet the queue, how its pointers work and the algorithms of its basic operations. The course includes a downloadable workbook. It suits computer science students and beginner programmers. It is best to know programming basics before starting so you can follow the examples easily. By the end, you will understand how to choose the right structure for a problem and implement a stack and a queue yourself.
Expected outcomes
- Master the fundamental concepts of data structures.
- Implement algorithms using various data structures.
- Understand how to optimize program performance using appropriate data structures.
- Use the C programming language to apply the acquired concepts and algorithms.
Learner reviews
Course content
1Data Structure
15 lectures
- IntroductionIntroduces the Data Structures course: their role in organizing data and efficient programming, and the topics from arrays, linked lists, stacks and queues to trees and graphs, with algorithms implemented in C.5:05
- Data Structures Relationship with Algorithm Design and ProgrammingShows how data structures relate to algorithms and why both matter in building programs, and defines core terms such as building blocks, variable, record and field, with examples to be implemented in C++.22:41
- Types of Data StructuresExplains why data structures are needed, covering data organization, speed, memory use, real-time needs and reusability, then data types such as numbers and characters, and the split into primitive and non-primitive.23:44
- Non-Primitive Data Structures (Linear and Non-Linear)Explains linear and non-linear non-primitive data structures, covering arrays, their declaration in C++ and insertion and deletion limits, linked lists with their nodes and advantages, and the circular queue.24:36
- Infix/Prefix/Postfix Expression Representation ConceptsExplains the stack and insertion and deletion at the top, with uses such as recursive functions, then expression notations infix, prefix and postfix and why computers prefer the latter two.23:53
- How to Use Stack to Convert from Infix to PostfixExplains the algorithm for converting an infix expression to postfix using a stack based on operator priority, then introduces the queue with its first-in first-out principle and examples.24:26
- Non-Linear Data StructuresExplains non-linear data structures: trees and their terms such as node, root, leaf, depth, height, siblings and ancestors, uses like encoding and game decisions, then graphs and path finding.19:02
- Static and Dynamic Data Structures (Part One)Explains graphs with their vertices, edges and weights, finding the shortest path between two nodes, how they differ from trees, directed and undirected graphs, and uses in maps, social networks and e-commerce.10:48
- Static and Dynamic Data Structures (Part Two)Compares static and dynamic data structures in memory allocation, flexibility and ease of access, covers operations like sorting and merging, then abstract data types (ADT) and their benefits.21:15
- Deep Dive into the Stack ConceptGoes deeper into the stack: the top pointer and checking whether it is empty or full, operations such as count, change and display, then the push algorithm in pseudocode and its conversion into a C function.27:46
- Basic Operations Algorithms for the StackExplains the pop algorithm for a stack in pseudocode with the empty check, its conversion to C code with a return value, the difference between top-- and --top, and previews a full stack program.16:44
- Comprehensive Example in C on the StackWalks through a full C program for stack operations: including libraries, representing the stack with an array, declaring variables, built-in versus user-defined functions, reading input with scanf and printing the operations menu.13:58
- Practical Implementation of Comprehensive Stack Code for Different CasesExplains the rest of the C stack program: the while loop, the switch statement choosing between push, pop, show and exit, the default case, the push function, and format specifiers.13:34
- Understanding the Queue and How Its Indicators WorkRuns the C stack program and tests its options, then moves to the queue and its uses such as handling calls and buffering in multimedia, the enqueue and dequeue operations, and types like circular and priority queues.25:20
- Basic Operations Algorithms for the QueueExplains representing a queue with arrays using front and rear pointers and the empty and full states, plus the insertion and deletion algorithms in pseudocode and how the pointers change in each case.23:24
2Add-ons
1 attachments
- Download the Workbook
Instructor
Dr. Eng. Mohamed Al-Khodour
