DSA Roadmap for Complete Learning

Basic Steps to Learn DSA

• The first and foremost step for DSA roadmap is to first choose a programming language in which we want to learn and implement all the Data Structures and Algorithms.
• Choose the language of either C++ or Java. Although Python can also be chosen, it is a good programming language, but it is not good for Data Structures and Algorithms. Many companies do not allow candidates to use Python because of its high time complexity. It is slower than both C++ and Java.
• Learn about Time Complexity and Space complexities, how they vary from one program to another, and how they are calculated.
• Learn all the basic syntax of the programming language. After that, learn the following
  • Data types
  • Basic Input/Output
  • Operators
  • Loops
  • Conditional Statements
  • Switch Statements
  • Functions
  • Libraries
  • Pointers (if available)
• Start learning the basics of Data Structures and Algorithms.
• Practice a lot, at least 20 questions of every Data Structure and every Algorithm.

Algorithms and Data Structures

Array

An array is a linear Data Structure that is the collection of similar types of objects(integer, character, string, etc.) that are stored in contiguous and adjacent memory locations. An array is based on the index system, which makes easy access to the elements of the array. The value of the index starts from '0' and goes till 'n-1', where n is the number of elements present in the array.

String

A String is a special type of array, it is known as an array of characters. It is implemented similarly to an array. It also follows the index system. The difference between an array of characters and a string is that the string is terminated by a special character known as the null character '\0'.

Linked List

A linked list is a linear data structure that is a collection of nodes. Each node consists of two fields i.e. one is the data field, and another is the pointer to the next node of the linked list. The address of the nodes in the linked list are not continuous which makes it easier to insert or delete a node, but the searching becomes costlier.

Searching Algorithm

Searching algorithms are one of the most important algorithms which are applied to data structures for solving the problem. Searching is defined as the process of finding or accessing the required data from the collection of items stored as elements inside a data structure. There are mainly two types of searching algorithms used.

• Linear Search: Linear search is a sequential search algorithm in which we start searching for an element from the start of the list and go till the end of the list or until the required element is not found. It is the easiest and simplest searching algorithm. The time complexity of the linear search algorithm is O(N) in the worst case, O(1) in the best case, and O(N) in the average case, where N is the number of elements in the array.
• Binary Search: Binary Search is a searching algorithm that is used to find the data or an element inside a sorted list (or array) by dividing the search space in half every time we failed to find the element. The main motive for using the binary search is to reduce the time complexity of searching an element inside a sorted array because the time complexity of the Binary search algorithm is O(logN) in the worst case.

Divide and Conquer Algorithm

This divide-and-conquer is an approach that breaks a bigger problem into smaller subproblems that are similar to the original problem and it recursively solves the subproblems to finally combine the solutions of the subproblems and solve the original bigger problem. There are mainly two most important algorithms which are based on the divide-and-conquer approach, i.e. Merge Sort and Quick Sort.

Sorting Algorithm

Sorting is a technique to arrange the data inside a list in a preferred order. The order is generally either increasing or decreasing order. Many different algorithms are used to sort an array, the most used algorithms are mentioned below

• Bubble Sort
• Insertion Sort
• Selection Sort
• Merge Sort
• Quick Sort
• Heap Sort

Queue

A queue is a linear data structure that follows the principle of First in First out (FIFO principle). It means that the element which goes inside the queue first will be the first one to be taken out of the queue. As the name also suggests, it is like the queue in the real life where the person standing at the front of the queue will the first one to be entertained. The queue consists of two operations i.e. 'enqueue' which means to push an element at the end of the queue and 'dequeue' which means taking out the element from the front of the queue.

Stack

A stack is a linear data structure that follows the principle of Last in First out (LIFO principle). It means that the element that goes inside the stack in the last will be the first to be removed from the stack. The stack consists of two operations i.e. 'push' which means to push an element on the top of the stack and 'pop' which means taking out the element from the top of the stack.

Tree Data Structures

A Tree is a non-linear Data Structure that consists of a collection of many nodes. The node consists of the data field and the pointers to the children of the node. The Tree Data Structure is used to represent the hierarchy. The Binary Tree is a mostly used Tree in which each node consists of three fields, the first one is the data field, the second is the pointer to the left child of the node, and the third is the pointer to the right child of the node. If any of the children are not available, then the pointers will be assigned a NULL value.

Graph Data Structures

A graph is a non-linear data structure. It is represented in the form of vertices and edges. The vertices are also known as nodes and the edges are also known as lines or arcs. The edges are responsible for connecting one node with another. The graph is one of the most important as it has many real-life applications, which we can encounter in our daily life. The graph is mainly used to describe the relationship between two nodes, and these nodes can represent any real-life object.

Recursion

In simple words, we can define Recursion as “A function calling itself directly or indirectly”, and the function which calls itself (which performs recursion) is called a recursive function. In the world of Computer Science, there are many problems where iteration fails or the complexity of iterative solutions increases so these types of issues are best suited to be solved by recursion. Examples of some famous problems are Merge Sort, Tower of Hanoi, DFS traversal, etc.

Greedy Methodology

A greedy Algorithm is an approach that is used to solve problems optimally and efficiently. At every step, the choice with the lowest cost and most profit is selected, as the name suggests itself, the choice that offers immediate benefit is considered.

Backtracking Algorithm

In simple words, we can define Backtracking as 'An algorithm which uses brute force technique to try out all possible solutions and ultimately selects the best solution'. In some problems, we have multiple choices but we don’t know the best solution, so in these cases, we prefer to use Backtracking by which we can find every possible solution and ultimately select the best possible solution.

Dynamic Programming

Dynamic Programming is an approach that solves problems that have overlapping substructures optimally and efficiently. It is also known as 'optimization over plain recursion' because in recursion we have many overlapping problems which can be solved easily by using the concept of Dynamic Programming. The recursion finds every possible solution and Dynamic Programming stores this solution so that the already solved problems should not be solved, again and again, instead, we must use the stored solution which will reduce the time complexity from exponential to linear or quadratic.

Tips to Boost Your DSA Concepts and Learning

• Understand the basics of every concept, because basics are important to understand advanced concepts.
• Focus on building the logic instead of learning or memorizing the code.
• Stick to one single resource in the initial phase of learning, but after that practice as much as you can from different resources.
• Master each Data Structure one by one.
• Practice easy-medium level problems in the initial phase, and after that start practicing medium-hard level problems of each Data Structure and each Algorithm.
• After building the logic of a problem, try to first dry run the code on different test cases including the edge cases, this will help in the minimization of errors in further problems.
• Doing competitive programming and giving contests will boost your problem-solving skills.
• Try solving the problems after the contest which you couldn't solve during the contest.

Ignite Data Structures Brilliance! Enroll in Scaler Academy's DSA Certification Course to Hone Your Coding Skills.

Learn More

• Difference Between Linear Search and Binary Search