algorithms data structures and problem solving with c

DSA_Using_C

Data structures and algorithms (dsa) using c.

Welcome to the DSA using C repository! 🌐

This repository is your comprehensive guide to mastering Data Structures and Algorithms using the C programming language. Dive into a well-organized collection of C code, meticulously arranged by topics, covering fundamental and advanced concepts in DSA.

Links For Notes

Searching and sorting, linked lists.

• Towers of Hanoi
• Binary Search
• Searching: Linear and Binary search algorithms.
• Sorting: Bubble, Insertion, Selection, Merge, Quick sort algorithms.
• Single linked list
• Double linked list
• Circular linked list
• Operations on linked lists.
• Operations: array implementation, linked list implementation
• Applications.
• Applications
• Circular Queue.
• Binary Tree Traversals: In-order, Preorder, Postorder
• Binary Search Trees: Searching BST, Insert into BST, Delete from BST, Height of a BST.
• Minimum Spanning Tree : Prim’s and Kruskal’s MST.

Key Features

Topic-wise Learning: Delve into Data Structures and Algorithms systematically, with each folder dedicated to a specific topic. Navigate easily to focus on the DSA area of interest.

C Code Examples: Explore practical code snippets that illustrate the implementation of DSA concepts in the C language. The examples are designed for clarity and accompanied by comments for easy comprehension.

• 📂 Browse by Topic: Explore folders to find C code snippets and explanations for specific DSA topics.

Whether you’re a beginner venturing into the world of DSA or an experienced coder honing your skills, this repository aims to be your go-to resource. Happy coding! 🚀💻

Ace your Coding Interview

• DSA Problems
• Binary Tree
• Binary Search Tree
• Dynamic Programming
• Divide and Conquer
• Linked List
• Backtracking

Data Structures and Algorithms Problems

• TopClassic, TopLiked ↗ Easy
• TopLiked ↗ Medium
• TopLiked ↗ Easy
• TopClassic, TopLiked ↗ Medium
• ↗ Medium
• ↗ Hard
• ↗ Easy
• TopAlgo ↗ Easy
• TopClassic ↗ Medium
• TopAlgo, TopClassic, TopAlgo ↗ Easy
• TopLiked ↗ Hard
• TopClassic, TopLiked ↗ Hard
• TopClassic ↗ Hard
• TopClassic ↗ Easy
• TopAlgo ↗ Medium
• TopClassic Hard
• ↗ Beginner
• TopAlgo ↗ Hard
• TopLiked Medium
• TopClassic, TopLiked, TopDP ↗ Medium
• TopLiked, TopDP ↗ Hard
• TopClassic, TopLiked, TopDP ↗ Hard
• TopDP ↗ Medium
• TopAlgo Medium
• TopClassic Medium
• TopAlgo Hard

Rate this post

Average rating 4.88 /5. Vote count: 5936

No votes so far! Be the first to rate this post.

We are sorry that this post was not useful for you!

Tell us how we can improve this post?

Thanks for reading.

To share your code in the comments, please use our online compiler that supports C, C++, Java, Python, JavaScript, C#, PHP, and many more popular programming languages.

Like us? Refer us to your friends and support our growth. Happy coding :)

• DSA Tutorial
• Data Structures
• Linked List
• Dynamic Programming
• Binary Tree
• Binary Search Tree
• Divide & Conquer
• Mathematical
• Backtracking
• Branch and Bound
• Pattern Searching

Learn Data Structures and Algorithms | DSA Tutorial

Data Structures and Algorithms (DSA) refer to the study of methods for organizing and storing data and the design of procedures (algorithms) for solving problems, which operate on these data structures. DSA is one of the most important skills that every computer science student must have. It is often seen that people with good knowledge of these technologies are better programmers than others and thus, crack the interviews of almost every tech giant, including companies like Google, Microsoft, Amazon, and Facebook (now Meta). This DSA tutorial aims to help you learn Data Structures and Algorithms (DSA) quickly and easily.

Data Structure & Algorithm Tutorial

Table of Content

Introduction to DSA

• Learn about Complexities
• Matrix/Grid
• Backtracking Algorithm
• Divide and Conquer Algorithm
• Searching and Sorting Algorithms
• Linked Lists
• Greedy Algorithms
• Graph Algorithms
• Branch and Bound Algorithm
• Geometric Algorithms
• Randomized Algorithm

Practice Problem Cheat Sheets

Data Structures and Algorithms (DSA) are fundamental in computer science that help us to organize and process data efficiently. They are used in solving common software challenges, from managing large data sets to optimizing the speed of tasks. Here’s why DSA is essential:

• DSA helps in storing and managing data efficiently, making it easier to retrieve and use when needed.
• Whether it’s finding the shortest path in a GPS system or optimizing search results in a search engine, DSA play an important role to solve such problems.
• By understanding DSA, you can design systems more efficiently, which is very important in areas like web applications, databases, and machine learning etc.

Mastering DSA is not only important for developing high-quality software but also for career growth. Top Companies like Google, Microsoft, Amazon, Apple, Meta and many other companies heavily focus on data structures and algorithms during interviews. Learning DSA will boost your problem-solving abilities and make you a stronger programmer in today’s competitive tech world.

How to learn DSA?

The first and foremost thing is dividing the total procedure into little pieces which need to be done sequentially. The complete process to learn DSA from scratch can be broken into 5 parts:

• Learn atleast one programming language (We leave this to your choice.)
• Learn Data Structures
• Learn Algorithms
• Learn about Time and Space complexities
• Practice Problems on DSA

Hoping you have learned a programming language of your choice, let us move forward with the next step to learn DSA in this DSA tutorial.

Here comes the most important and the most awaited stage of the roadmap for learning data structure and algorithm – the stage where you start learning about DSA.

The topic of DSA consists of two parts:

• Algorithms 

Though they are two different things, they are highly interrelated, and it is very important to follow the right track to learn them most efficiently. If you are confused about which one to learn first, we recommend you to go through our detailed analysis on the topic: What should I learn first- Data Structures or Algorithms?

1. Learn about Complexities

In Data Structures and Algorithms (DSA), the main goal is to solve problems effectively and efficiently. To determine the efficiency of a program, we look at two types of complexities:

• Time Complexity : This tells us how much time our code takes to run.
• Space Complexity : This tells us how much memory our code uses.

Asymptotic Notation

To compare efficiencies of algorithms, we use asymptotic notation, a mathematical tool that estimates time based on input size without running the code. It focuses on the number of basic operations in the program.

The most commonly used notation for code analysis is Big O Notation, providing an upper limit on the running time or memory usage concerning the input size.

Related Topics:

• Understanding Time Complexity with Simple Examples
• Time complexities of different data structures
• How to Analyse Loops for Complexity Analysis of Algorithms
• Practice Questions on Time Complexity Analysis

2. Mathematical and Bitwise Algorithms

1 . mathematical algorithms.

Mathematical algorithms are a class of algorithms that solve problems related to mathematical concepts. They are widely used in various fields, including Computer graphics, Numerical analysis, Optimization and Cryptography.

• Practice Problem on Mathmatical Algorithm

2. Bitwise Algorithms

Bitwise algorithms are algorithms that operate on individual bits of numbers. These algorithms manipulate the binary representation of numbers to perform tasks such as bit manipulation, bitwise logical operations (AND, OR, XOR), shifting bits , and setting or clearing specific bits within a number. Bitwise algorithms are commonly used in low-level programming, cryptography, and optimization tasks where efficient manipulation of individual bits is required.

• Bitwise Algorithms Tutorial
• Practice Problem on Bitwise Algorithms

Array is a linear data structure that stores a collection of elements of the same data type. Elements are allocated contiguous memory, allowing for constant-time access. Each element has a unique index number.

• Traversal : Iterating through the elements of an array.
• Insertion : Adding an element to the array at a specific index.
• Deletion : Removing an element from the array at a specific index.
• Searching : Finding an element in the array by its value or index.
• One-dimensional array : A simple array with a single dimension.
• Multidimensional array : An array with multiple dimensions, such as a matrix.
• Storing data in a sequential manner
• Implementing queues, stacks, and other data structures
• Representing matrices and tables
• Arrays Tutorial
• Top 50 Array Coding Problems for Interviews
• Practice problems on Arrays

4. Matrix/Grid

A matrix is a two-dimensional array of elements, arranged in rows and columns. It is represented as a rectangular grid, with each element at the intersection of a row and column.

• Rows : Horizontal lines of elements in a matrix.
• Columns : Vertical lines of elements in a matrix.
• Dimensions : The number of rows and columns in a matrix (e.g., a 3×4 matrix has 3 rows and 4 columns).
• Element Access : Elements can be accessed using row and column indices (e.g., M[2][3] refers to the element in row 2, column 3).
• Image processing
• Data analysis
• Optimization problems
• Matrix/Grid Tutorial
• Top 50 Problems on Matrix/Grid for Interviews
• Practice Problems on Matrix/Grid

A string is a sequence of characters, typically used to represent text. It is considered a data type that allows for the manipulation and processing of textual data in computer programs.

• Concatenation : Joining two strings together.
• Comparison : Comparing two strings lexicographically.
• Substring extraction : Extracting a substring from a string.
• Search : Searching for a substring within a string.
• Modification : Changing or replacing characters within a string.
• Text processing
• Pattern matching
• Data validation
• Database management
• String Tutorial
• Top 50 String Coding Problems for Interviews
• Practice Problems on String

Stack is a linear data structure that follows a particular order in which the operations are performed. The order may be LIFO(Last In First Out) or FILO(First In Last Out) . LIFO implies that the element that is inserted last, comes out first and FILO implies that the element that is inserted first, comes out last.

• Push : Adds an element to the top of the stack
• Pop : Removes and returns the element at the top of the stack
• Peek : Returns the element at the top of the stack without removing it
• Size : Returns the number of elements in the stack
• IsEmpty : Checks if the stack is empty
• Function calls
• Expression evaluation
• Undo/redo operations
• Stack Tutorial
• Top 50 Problems on Stack for Interviews
• Practice problems on Stack

A Queue Data Structure is a fundamental concept in computer science used for storing and managing data in a specific order. It follows the principle of “ First in, First out ” ( FIFO ), where the first element added to the queue is the first one to be removed

• Enqueue : Adds an element to the rear of the queue
• Dequeue : Removes an element from the front of the queue
• Peek : Retrieves the front element without removing it
• IsEmpty : Checks if the queue is empty
• IsFull : Checks if the queue is full
• Circular Queue : Last element connects to the first element
• Double-Ended Queue (Deque) : Operations can be performed from both ends
• Priority Queue : Elements are arranged based on priority
• Job scheduling
• Message queuing
• Simulation modeling
• Data buffering
• Queue Tutorial
• Top 50 Problems on Queue for Interviews
• Practice problems on Queue

8. Recursion

Recursion is a programming technique where a function calls itself within its own definition. It is usually used to solve problems that can be broken down into smaller instances of the same problem. For Example: Towers of Hanoi (TOH) , Factorial Calculation and Fibonacci Sequence etc.

• Base Case : Define a condition that stops the recursive calls and provides a solution.
• Recursive Case : Define the steps to break down the problem into smaller instances and make recursive calls.
• Return : Return the solution from the recursive calls and combine them to solve the original problem.

The point which makes Recursion one of the most used algorithms is that it forms the base for many other algorithms such as Tree traversals, Graph traversals, Divide and Conquers Algorithms and Backtracking algorithms.

• Recursion Tutorial
• Recursive Functions
• Tail Recursion
• Top 50 Problems on Recursion Algorithm for Interview
• Practice problems on Recursion algorithm

9. Backtracking Algorithm

As mentioned earlier, the Backtracking algorithm is derived from the Recursion algorithm, with the option to revert if a recursive solution fails, i.e. in case a solution fails, the program traces back to the moment where it failed and builds on another solution. So basically it tries out all the possible solutions and finds the correct one.

Some important and most common problems of backtracking algorithms, that you must solve before moving ahead, are:

Related Article:

• Backtracking Tutorial
• Practice problems on Backtracking algorithm

10. Divide and Conquer Algorithm

Divide and conquer algorithms follow a recursive strategy to solve problems by dividing them into smaller subproblems, solving those subproblems, and combining the solutions to obtain the final solution.

• Divide : Partition the problem into smaller, independent subproblems.
• Conquer : Recursively solve each subproblem.
• Combine : Merge the solutions of the subproblems to obtain the final solution.
• Merge Sort: Divides the array into two halves, sorts each half recursively, and merges the sorted halves.
• Quick Sort: Selects a pivot element, partitions the array into two subarrays based on the pivot, and recursively sorts each subarray.

Related Articles:

• Divide and Conquer Tutorial
• Practice problems on Divide And Conquer algorithm

11. Searching and Sorting Algorithms

1 . sorting algorithm.

Sorting algorithms are used to arranging the elements of a list in a specific order, such as numerical or alphabetical. It organizes the items in a systematic way, making it easier to search for and access specific elements.

There are a lot of different types of sorting algorithms. Some widely used algorithms are:

• Sorting Algorithm Tutorial
• Top Sorting Interview Questions and Problems
• Practice problems on Sorting algorithm

2 . Searching Algorithm

Searching algorithms are used to locate specific data within a larger set of data. It helps find the presence of a target value within the data. There are various types of searching algorithms, each with its own approach and efficiency.

• Linear Search : Iterative search from one end to the other.
• Binary Search : Divide-and-conquer search on a sorted array, halving the search space at each iteration.
• Ternary Search : Divide-and-conquer search on a sorted array, dividing the search space into three parts at each iteration.
• Jump Search
• Interpolation Search  
• Exponential Search  
• Practice problems on Searching algorithm

12. Linked Lists

A linked list is a linear data structure that stores data in nodes, which are connected by pointers. Unlike arrays, linked lists are not stored in contiguous memory locations.

• Dynamic : Linked lists can be easily resized by adding or removing nodes.
• Non-contiguous : Nodes are stored in random memory locations and connected by pointers.
• Sequential access : Nodes can only be accessed sequentially, starting from the head of the list.
• Creation : Creating a new linked list or adding a new node to an existing list.
• Traversal : Iterating through the list and accessing each node.
• Insertion : Adding a new node at a specific position in the list.
• Deletion : Removing a node from the list.
• Search : Finding a node with a specific value in the list.
• Singly Linked List : Each node points to the next node in the list.
• Doubly Linked List : Each node points to both the next and previous nodes in the list.
• Circular Linked List : The last node points back to the first node, forming a circular loop.
• Linked lists are used in various applications, including:
• Implementing queues and stacks
• Representing graphs and trees
• Maintaining ordered data
• Memory management
• Linked List Tutorial
• Top 50 Problems on Linked List for Interviews
• Practice problems on Linked Lists

Hashing is a technique that generates a fixed-size output (hash value) from an input of variable size using mathematical formulas called hash functions . Hashing is used to determine an index or location for storing an item in a data structure, allowing for efficient retrieval and insertion.

• Hash Function : A mathematical function that maps an input to a hash value.
• Hash Table : A data structure that stores key-value pairs, where the key is a hash value and the value is the actual data.
• Collision : When two different keys produce the same hash value.
• Division Method : Divides the input by a constant and uses the remainder as the hash value.
• Mid Square Method: Squares the input and takes the middle digits as the hash value.
• Folding Method : Divides the input into equal-sized blocks and adds them together to get the hash value.
• Multiplication Method : Multiplies the input by a constant and takes the fractional part as the hash value.
• Separate Chaining (Open Hashing) : Stores colliding elements in a linked list at the corresponding hash value.
• Open Addressing (Closed Hashing) : Uses various strategies to find an alternative location for colliding elements within the hash table.
• Efficiently storing and retrieving data in databases and file systems.
• Verifying passwords and digital signatures.
• Distributing requests across multiple servers.
• Generating secure hashes for data integrity and authentication.
• Hash Tutorial
• Practice Problems on Hashing

A tree is a non-linear hierarchical data structure consisting of nodes connected by edges, with a top node called the root and nodes having child nodes. It is used in computer science for organizing data efficiently.

• In-Order : Visit left subtree, current node, then right subtree.
• Pre-Order : Visit current node, left subtree, then right subtree.
• Post-Order : Visit left subtree, right subtree, then current node.
• Classifications of Trees refer to grouping trees based on certain characteristics or criteria. This can involve categorizing trees based on their balance factor, degree of nodes, ordering properties, etc. Below are some important classification of Tree.
• File systems
• XML documents
• Artificial intelligence
• Tree Tutorial
• Top 50 Tree Coding Problems
• Practice problems on Tree

A Heap is a complete binary tree data structure that satisfies the heap property: for every node, the value of its children is less than or equal to its own value. Heaps are usually used to implement priority queues , where the smallest (or largest) element is always at the root of the tree.

• Insert : Adds a new element to the heap while maintaining heap properties.
• Extract-Max/Extract-Min : Removes the root element and restructures the heap.
• Increase/Decrease-Key : Updates the value of a node and restructures the heap.
• Max-Heap : Root node has the maximum value among its children.
• Min-Heap : Root node has the minimum value among its children.
• Priority queues
• Graph algorithms (e.g., Dijkstra’s algorithm)
• Heap Tutorial
• Top 50 Problems on Heap for Interviews
• Practice Problems on Heap

A Graph is a non-linear data structure consisting of a finite set of vertices(or nodes) and a set of edges that connect a pair of nodes.

• Breadth-First Search (BFS) : Visits nodes level by level.
• Depth-First Search (DFS) : Visits nodes recursively, exploring one branch at a time.
• Social networks
• Maps and navigation
• Data mining
• Graph Representation
• Types of graphs
• Graph Tutorial
• Practice problems on Graph

19. Greedy Algorithms

As the name suggests, this algorithm builds up the solution one piece at a time and chooses the next piece which gives the most obvious and immediate benefit i.e., which is the most optimal choice at that moment. So the problems where choosing locally optimal also leads to the global solutions are best fit for Greedy.

Some Important Problem of Greedy Algorithms are:

• Greedy Algorithm Tutorial
• Practice problems on Greedy algorithm

17. Dynamic Programming

Dynamic Programming is a method used in mathematics and computer science to solve complex problems by breaking them down into simpler subproblems. By solving each subproblem only once and storing the results, it avoids redundant computations, leading to more efficient solutions for a wide range of problems.

Key Concepts:

• Optimal Substructure : The optimal solution to a problem can be constructed from the optimal solutions to its subproblems.
• Overlapping Subproblems : Subproblems are often repeated in the larger problem, leading to redundant computations.
• Memoization / Tabulation : Storing the solutions to subproblems to avoid recomputation.

Some important and most common problems of dynamic programming algorithms, that you must solve before moving ahead, are:

• Tabulation vs Memoization
• How to solve a Dynamic Programming Problem?
• Dynamic Programming Tutorial
• Top 50 Dynamic Programming Coding Problems for Interviews
• Practice problems on Dynamic Programming algorithm

18. Graph Algorithms

Graph algorithms in data structures and algorithms (DSA) are a set of techniques and methods used to solve problems related to graphs, which are a collection of nodes and edges. These algorithms are designed to perform various operations on graphs, such as searching, traversing, finding the shortest path , and determining connectivity . They are essential for solving a wide range of real-world problems, including network routing, social network analysis, and resource allocation.

• Top 50 Graph Coding Problems for Interviews
• Practice Problem on Graph Algorithms

19 . Pattern Searching

Pattern searching is a fundamental technique in DSA used to find occurrences of a specific pattern within a given text.

Below are some some standard pattern searching algorithms:

• Pattern Searching Tutorial
• Practice Problem on Pattern Searching

20. Branch and Bound Algorithm

The Branch and Bound Algorithm is a method used in combinatorial optimization problems to systematically search for the best solution. It works by dividing the problem into smaller subproblems, or branches, and then eliminating certain branches based on bounds on the optimal solution. This process continues until the best solution is found or all branches have been explored.

Standard Problems on Branch and Bound Algorithm:

• Branch and Bound Algorithm Tutorial

21. Geometric Algorithms

Geometric algorithms are a class of algorithms that solve problems related to geometry. Geometric algorithms are essential for solving a wide range of problems in computer science, such as:

• Practice Problem on Geometric Algorithms

22. Randomized Algorithms

Randomized algorithms are algorithms that use randomness to solve problems. They make use of random input to achieve their goals, often leading to simpler or more efficient solutions.

Types of Randomized Algorithms:

• Las Vegas : Always produces a correct result, but the running time is random.
• Monte Carlo : May produce an incorrect result with a small probability, but the running time is usually faster.

Important Algorithms that uses Randomization Algorithms:

Curated lists of problems from below articles:

• DSA Roadmap by Sandeep Jain
• SDE SHEET – A Complete Guide for SDE Preparation
• GeeksforGeeks Master Sheet – List of all Cheat Sheets

Similar Reads

• DSA Tutorials

Please Login to comment...

Improve your coding skills with practice.

What kind of Experience do you want to share?

DSA Tutorial

Linked lists, stacks & queues, hash tables, shortest path, minimum spanning tree, maximum flow, time complexity, dsa reference, dsa examples, introduction to data structures and algorithms.

Data Structures is about how data can be stored in different structures.

Algorithms is about how to solve different problems, often by searching through and manipulating data structures.

Theory about Data Structures and Algorithms (DSA) helps us to use large amounts of data to solve problems efficiently.

What are Data Structures?

A data structure is a way to store data.

We structure data in different ways depending on what data we have, and what we want to do with it.

First, let's consider an example without computers in mind, just to get the idea.

If we want to store data about people we are related to, we use a family tree as the data structure. We choose a family tree as the data structure because we have information about people we are related to and how they are related, and we want an overview so that we can easily find a specific family member, several generations back.

With such a family tree data structure visually in front of you, it is easy to see, for example, who my mother's mother is—it is 'Emma,' right? But without the links from child to parents that this data structure provides, it would be difficult to determine how the individuals are related.

Data structures give us the possibility to manage large amounts of data efficiently for uses such as large databases and internet indexing services.

Data structures are essential ingredients in creating fast and powerful algorithms. They help in managing and organizing data, reduce complexity, and increase efficiency.

In Computer Science there are two different kinds of data structures.

Primitive Data Structures are basic data structures provided by programming languages to represent single values, such as integers, floating-point numbers, characters, and booleans.

Abstract Data Structures are higher-level data structures that are built using primitive data types and provide more complex and specialized operations. Some common examples of abstract data structures include arrays, linked lists, stacks, queues, trees, and graphs.

What are Algorithms?

An algorithm is a set of step-by-step instructions to solve a given problem or achieve a specific goal.

A cooking recipe written on a piece of paper is an example of an algorithm, where the goal is to make a certain dinner. The steps needed to make a specific dinner are described exactly.

When we talk about algorithms in Computer Science, the step-by-step instructions are written in a programming language, and instead of food ingredients, an algorithm uses data structures.

Algorithms are fundamental to computer programming as they provide step-by-step instructions for executing tasks. An efficient algorithm can help us to find the solution we are looking for, and to transform a slow program into a faster one.

By studying algorithms, developers can write better programs.

Algorithm examples:

• Finding the fastest route in a GPS navigation system
• Navigating an airplane or a car (cruise control)
• Finding what users search for (search engine)
• Sorting, for example sorting movies by rating

The algorithms we will look at in this tutorial are designed to solve specific problems, and are often made to work on specific data structures. For example, the 'Bubble Sort' algorithm is designed to sort values, and is made to work on arrays.

Data Structures together with Algorithms

Data structures and algorithms (DSA) go hand in hand. A data structure is not worth much if you cannot search through it or manipulate it efficiently using algorithms, and the algorithms in this tutorial are not worth much without a data structure to work on.

DSA is about finding efficient ways to store and retrieve data, to perform operations on data, and to solve specific problems.

By understanding DSA, you can:

• Decide which data structure or algorithm is best for a given situation.
• Make programs that run faster or use less memory.
• Understand how to approach complex problems and solve them in a systematic way.

Where is Data Structures and Algorithms Needed?

Data Structures and Algorithms (DSA) are used in virtually every software system, from operating systems to web applications:

• For managing large amounts of data, such as in a social network or a search engine.
• For scheduling tasks, to decide which task a computer should do first.
• For planning routes, like in a GPS system to find the shortest path from A to B.
• For optimizing processes, such as arranging tasks so they can be completed as quickly as possible.
• For solving complex problems: From finding the best way to pack a truck to making a computer 'learn' from data.

DSA is fundamental in nearly every part of the software world:

• Operating Systems
• Database Systems
• Web Applications
• Machine Learning
• Video Games
• Cryptographic Systems
• Data Analysis
• Search Engines

Theory and Terminology

As we go along in this tutorial, new theoretical concepts and terminology (new words) will be needed so that we can better understand the data structures and algorithms we will be working on.

These new words and concepts will be introduced and explained properly when they are needed, but here is a list of some key terms, just to get an overview of what is coming:

Where to Start?

In this tutorial, you will first learn about a data structure with matching algorithms, before moving on to the next data structure.

Further into the tutorial the concepts become more complex, and it is therefore a good idea to learn DSA by doing the tutorial step-by-step from the start.

And as mentioned on the previous page, you should be comfortable in at least one of the most common programming languages, like for example JavaScript , C or Python , before doing this tutorial.

On the next page we will look at two different algorithms that prints out the first 100 Fibonacci numbers using only primitive data structures (two integer variables). One algorithm uses a loop, and one algorithm uses something called recursion.

Click the 'Next' button to continue.

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

Learn Python practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn python interactively, learn data structures and algorithms.

Recommended Course:

Learn DSA with Python

Perfect for beginners serious about building a career in DSA.

Created by the Programiz team with over a decade of experience.

• Enrollment: 7.4k
• Practice Problems: 101+
• Quizzes: 141+
• Certifications

Data Structures and Algorithms (DSA) is an essential skill for any programmer looking to solve problems efficiently.

Understanding and utilizing DSA is especially important when optimization is crucial, like in game development, live video apps, and other areas where even a one-second delay can impact performance.

Big companies tend to focus on DSA in coding interviews, so if you're good at it, you're more likely to land those higher-paying jobs.

In this guide, we will cover:

• Beginner's Guide to DSA
• Is DSA for You? (Hint: If you like breaking down problems and finding smart solutions, definitely yes!)
• Best Way to Learn DSA (Your way!)

How to Practice DSA?

If you are simply looking to learn DSA step-by-step, you can follow our free tutorials in the next section.

Beginner's Guide to Data Structures and Algorithms

These tutorials will provide you with a solid foundation in Data Structures and Algorithms and prepare you for your career goals.

What is an algorithm?

Data Structure and Types

Why learn DSA?

Asymptotic Notations

Master Theorem

Divide and Conquer Algorithm

Types of Queue

Circular Queue

Priority Queue

Linked List

Linked List Operations

Types of Linked List

Heap Data Structure

Fibonacci Heap

Decrease Key and Delete Node Operations on a Fibonacci Heap

Tree Data Structure

Tree Traversal

Binary Tree

Full Binary Tree

Perfect Binary Tree

Complete Binary Tree

Balanced Binary Tree

Binary Search Tree

Insertion in a B-tree

Deletion from a B-tree

Insertion on a B+ Tree

Deletion from a B+ Tree

Red-Black Tree

Red-Black Tree Insertion

Deletion From a Red-Black Tree

Graph Data Structure

Spanning Tree

Strongly Connected Components

Adjacency Matrix

Adjacency List

DFS Algorithm

Breadth-first Search

Bellman Ford's Algorithm

Bubble Sort

Selection Sort

Insertion Sort

Counting Sort

Bucket Sort

Linear Search

Binary Search

Greedy Algorithm

Ford-Fulkerson Algorithm

Dijkstra's Algorithm

Kruskal's Algorithm

Prim's Algorithm

Huffman Coding

Dynamic Programming

Floyd-Warshall Algorithm

Longest Common Sequence

Backtracking Algorithm

Rabin-Karp Algorithm

Is DSA for you?

Whether DSA is the right choice depends on what you want to achieve in programming and your career goals.

DSA from Learning Perspective

If you're preparing for coding interviews, mastering Data Structures and Algorithms (DSA) is crucial. Most companies use DSA to test your problem-solving skills.

So learning DSA will boost your chances of landing a job.

Furthermore, if you're interested in performance-sensitive areas like game development, real-time data processing, or navigation apps (like Google Maps), learning DSA is crucial.

For example, the efficiency of a map application relies on the proper use of data structures and algorithms to quickly find the best routes.

Even if you're not focused on performance-sensitive fields, a basic knowledge of DSA is still important. It helps you write cleaner, more efficient code and lays the foundation for building scalable applications.

DSA is essential for anyone who wants to excel in programming.

DSA as a Career Choice

Data Structures and Algorithms (DSA) are fundamental for creating efficient and optimized software solutions. It's used in:

• Software Development
• System Design
• Data Engineering
• Algorithmic Trading
• Competitive Programming and more

However, there are certain fields where focusing heavily on DSA might not be as essential. For example, if you are primarily interested in frontend design, UX/UI development, or simple scripting tasks, then deep DSA knowledge might not be your top priority.

In these cases, skills such as design principles, creativity, or proficiency in specific tools like HTML/CSS for frontend design or Python for scripting might be more relevant.

Ultimately, your career goals will help determine how important DSA is for you.

Best Way to Learn DSA

There is no right or wrong way to learn DSA. It all depends on your learning style and pace.

In this section, we have included the best DSA learning resources tailored to your learning preferences, be it text-based, video-based, or interactive courses.

Text-based Tutorial

Best: if you are committed to learning DSA but do not want to spend on it.

If you want to learn DSA for free with a well-organized, step-by-step tutorial, you can use our free DSA tutorials .

Our tutorials will guide you through DSA one step at a time, using practical examples to strengthen your foundation.

Interactive Course

Best: if you want hands-on learning, get your progress tracked, and maintain a learning streak.

Learning to code is tough. It requires dedication and consistency, and you need to write tons of code yourself.

While videos and tutorials provide you with a step-by-step guide, they lack hands-on experience and structure.

Recognizing all these challenges, Programiz offers a premium DSA Interactive Course that allows you to gain hands-on learning experience by solving problems, building real-world projects, and tracking your progress.

Best: if you want to have in-depth understanding at your own pace.

Books are a great way to learn. They give you a comprehensive view of programming concepts that you might not get elsewhere.

Here are some books we personally recommend:

• Introduction to Algorithms, Thomas H. Cormen
• Algorithms, Robert Sedgewick
• The Art of Computer Programming, Donald E. Knuth

Visualization

Best: if you're a visual learner who grasps concepts better by seeing them in action.

Once you have some idea about data structure and algorithms, there is a great resource at Data Structure Visualizations that lets you learn through animation. There are many visualizer tools, however you can use Data Structure Visualization (usfca.edu) .

Important: You cannot learn DSA without developing the habit of practicing it yourself. Therefore, whatever method you choose, always work on DSA problems.

While solving problems, you will encounter challenges. Don't worry about them; try to understand them and find solutions. Remember, mastering DSA is all about solving problems, and difficulties are part of the process.

1. Use an IDE or Code Editor

The best way to practice DSA is to learn a concept and implement it from scratch. You can write and run your DSA code directly in online compilers or IDE like VS Code or any text editor.

2. Try Online Platforms:

Practice on sites like LeetCode or HackerRank for instant feedback and a variety of problems.