Problem of the day
Browse Category
Last updated: Oct 28, 2021
Data Structures and Algorithms
Share: 
Strings
Strings is one of the commonly used data types in all programs. It is technically defined as an array of characters which are enclosed within quotes in most of the languages. In some languages, it's a primitive data-type, and in others, it's defined as a complex data-type.
Arrays
An array is the most primitive and frequently used data structure in the field of computer science. It has become the inspiration for several data structures such as lists and strings. An array is basically a collection of similar types of data items stored at contiguous memory locations. It helps us to store multiple items of the same data type together. They are also used to implement other data structures like Heaps, Stacks, Queues, etc. This category contains all of the information you need to know about arrays.
Stack
When talking about Data Structures and algorithms associated with them, we need to talk about Stacks. A stack is a linear data structure, which follows a particular order in which operations can be performed. These operations may be FILO (First In Last Out) or LIFO(Last In First Out). Stacks can be implemented using arrays and linked lists manually, while languages like C++, Java, and Python have built-in classes, STLs, and libraries to implement them. In this category, we will look into all operations and problems related to Stacks.
Binary Tree
A binary tree is another example of a data structure similar to a linked list, but instead of each node pointing to the very next node linearly, each node points to the two nodes, hence making this an example of a non-linear data structure. The tree structure is a way of representing the hierarchical nature of a structure in a graphical form. In the Abstract data type of trees, the order of the elements is not essential. If we need ordering information, linear data structures like a linked list, stacks, queues, etc., can be used.
Binary Search Tree
A binary search tree is a specific type of binary tree that is either empty, or each node in the tree contains a key, and all keys in the left subtree are less (numerically or alphabetically) than the identifier in the root node; all keys in the right subtree are greater than the identifier in the root node and the left and right subtrees are also binary search trees.
Heap and Priority Queue
They are the built-in form of a tree, which stores all the elements in a particular order. There are majorly two types of Heaps or priority queues that came into action: Min-Heap: Elements are stored in such a way that the minimum element will always be on the top. Max-Heap: Elements are stored in such a way that the maximum element will always be on the top. The time complexity of push and pop operations in heaps and priority queues is O(log(N)) and it requires O(N) space.
HashMap
A HashMap is a data structure that can map specific keys to certain values. The keys and values could be anything. Hashmaps can retrieve data faster than arrays and linked lists. A hashmap can check the presence of a particular key in O(1) time.
Graph
A graph is a type of non-linear data structure. A graph is defined as a group of vertices, and edges are used to connect these vertices. There are many different types of graphs, such as directed, undirected, weighted, unweighted, cyclic, acyclic, etc. There are many real-life applications of the graph. They are used in maps, social media, path optimization algorithms, etc.
Searching and Sorting Algorithms
Searching and Sorting Algorithms are one of the most important topics that a programmer covers in his journey, Searching algorithms are used to retrieve elements from any data structure, and Sorting algorithms are used to rearrange and reorganize elements in a data structure as per specified order. Various algorithms are covered in this section and have different uses as the need arises, this section will teach you the best searching and sorting algorithms and how they'll be used as the need arises.
Dynamic Programming
Dynamic Programming is a technique of doing an optimization over recursion. We store the answer for the overlapping subproblems and use that result if we need the answer for the same problem in the future. Hence, we save the time of re-computing the answer for the same problem. It is a great technique that helps us to reduce the exponential time complexity to polynomial time complexity.
