Post Order Traversal of Binary Tree in O(N) using O(1) space
Last Updated :
12 Jul, 2025
Prerequisites:- Morris Inorder Traversal, Tree Traversals (Inorder, Preorder and Postorder)
Given a Binary Tree, the task is to print the elements in post order using O(N) time complexity and constant space.
Input: 1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
Output: 8 9 4 5 2 6 7 3 1
Input: 5
/ \
7 3
/ \ / \
4 11 13 9
/ \
8 4
Output: 8 4 4 11 7 13 9 3 5
Method 1: Using Morris Inorder Traversal
- Create a dummy node and make the root as it's left child.
- Initialize current with dummy node.
- While current is not NULL
- If the current does not have a left child traverse the right child, current = current->right
- Otherwise,
- Find the rightmost child in the left subtree.
- If rightmost child's right child is NULL
- Make current as the right child of the rightmost node.
- Traverse the left child, current = current->left
- Otherwise,
- Set the rightmost child's right pointer to NULL.
- From current's left child, traverse along with the right children until the rightmost child and reverse the pointers.
- Traverse back from rightmost child to current's left child node by reversing the pointers and printing the elements.
- Traverse the right child, current = current->right
Below is the diagram showing the rightmost child in the left subtree, pointing to its inorder successor.
Below is the diagram which highlights the path 1->2->5->9 and the way the nodes are processed and printed as per the above algorithm.
Below is the implementation of the above approach:
C++
// C++ program to implement
// Post Order traversal
// of Binary Tree in O(N)
// time and O(1) space
#include <bits/stdc++.h>
using namespace std;
class node
{
public:
int data;
node *left, *right;
};
// Helper function that allocates a
// new node with the given data and
// NULL left and right pointers.
node* newNode(int data)
{
node* temp = new node();
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// Postorder traversal without recursion
// and without stack
void postOrderConstSpace(node* root)
{
if (root == NULL)
return;
node* current = newNode(-1);
node* pre = NULL;
node* prev = NULL;
node* succ = NULL;
node* temp = NULL;
current->left = root;
while (current)
{
// If left child is null.
// Move to right child.
if (current->left == NULL)
{
current = current->right;
}
else
{
pre = current->left;
// Inorder predecessor
while (pre->right &&
pre->right != current)
pre = pre->right;
// The connection between current and
// predecessor is made
if (pre->right == NULL)
{
// Make current as the right
// child of the right most node
pre->right = current;
// Traverse the left child
current = current->left;
}
else
{
pre->right = NULL;
succ = current;
current = current->left;
prev = NULL;
// Traverse along the right
// subtree to the
// right-most child
while (current != NULL)
{
temp = current->right;
current->right = prev;
prev = current;
current = temp;
}
// Traverse back
// to current's left child
// node
while (prev != NULL)
{
cout << prev->data << " ";
temp = prev->right;
prev->right = current;
current = prev;
prev = temp;
}
current = succ;
current = current->right;
}
}
}
}
// Driver code
int main()
{
/* Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
*/
node* root = NULL;
root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->right->left = newNode(6);
root->right->right = newNode(7);
root->left->right->left = newNode(8);
root->left->right->right = newNode(9);
postOrderConstSpace(root);
return 0;
}
// This code is contributed by Saurav Chaudhary
// Java program to implement
// Post Order traversal
// of Binary Tree in O(N)
// time and O(1) space
// Definition of the
// binary tree
class TreeNode {
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
this.data = data;
}
public String toString()
{
return data + " ";
}
}
public class PostOrder {
TreeNode root;
// Function to find Post Order
// Traversal Using Constant space
void postOrderConstantspace(TreeNode
root)
{
if (root == null)
return;
TreeNode current
= new TreeNode(-1),
pre = null;
TreeNode prev = null,
succ = null,
temp = null;
current.left = root;
while (current != null) {
// Go to the right child
// if current does not
// have a left child
if (current.left == null) {
current = current.right;
}
else {
// Traverse left child
pre = current.left;
// Find the right most child
// in the left subtree
while (pre.right != null
&& pre.right != current)
pre = pre.right;
if (pre.right == null) {
// Make current as the right
// child of the right most node
pre.right = current;
// Traverse the left child
current = current.left;
}
else {
pre.right = null;
succ = current;
current = current.left;
prev = null;
// Traverse along the right
// subtree to the
// right-most child
while (current != null) {
temp = current.right;
current.right = prev;
prev = current;
current = temp;
}
// Traverse back from
// right most child to
// current's left child node
while (prev != null) {
System.out.print(prev);
temp = prev.right;
prev.right = current;
current = prev;
prev = temp;
}
current = succ;
current = current.right;
}
}
}
}
// Driver Code
public static void main(String[] args)
{
/* Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
*/
PostOrder tree = new PostOrder();
tree.root = new TreeNode(1);
tree.root.left = new TreeNode(2);
tree.root.right = new TreeNode(3);
tree.root.left.left = new TreeNode(4);
tree.root.left.right
= new TreeNode(5);
tree.root.right.left
= new TreeNode(6);
tree.root.right.right
= new TreeNode(7);
tree.root.left.right.left
= new TreeNode(8);
tree.root.left.right.right
= new TreeNode(9);
tree.postOrderConstantspace(
tree.root);
}
}
# Python3 program to implement
# Post Order traversal
# of Binary Tree in O(N)
# time and O(1) space
class node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# Helper function that allocates a
# new node with the given data and
# None left and right pointers.
def newNode(data):
temp = node(data)
return temp
# Postorder traversal without recursion
# and without stack
def postOrderConstSpace(root):
if (root == None):
return
current = newNode(-1)
pre = None
prev = None
succ = None
temp = None
current.left = root
while (current):
# If left child is None.
# Move to right child.
if (current.left == None):
current = current.right
else:
pre = current.left
# Inorder predecessor
while (pre.right and
pre.right != current):
pre = pre.right
# The connection between current
# and predecessor is made
if (pre.right == None):
# Make current as the right
# child of the right most node
pre.right = current
# Traverse the left child
current = current.left
else:
pre.right = None
succ = current
current = current.left
prev = None
# Traverse along the right
# subtree to the
# right-most child
while (current != None):
temp = current.right
current.right = prev
prev = current
current = temp
# Traverse back
# to current's left child
# node
while (prev != None):
print(prev.data, end = ' ')
temp = prev.right
prev.right = current
current = prev
prev = temp
current = succ
current = current.right
# Driver code
if __name__=='__main__':
''' Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
'''
root = None
root = newNode(1)
root.left = newNode(2)
root.right = newNode(3)
root.left.left = newNode(4)
root.left.right = newNode(5)
root.right.left = newNode(6)
root.right.right = newNode(7)
root.left.right.left = newNode(8)
root.left.right.right = newNode(9)
postOrderConstSpace(root)
# This code is contributed by pratham76
// C# program to implement
// Post Order traversal
// of Binary Tree in O(N)
// time and O(1) space
using System;
// Definition of the
// binary tree
public class TreeNode
{
public int data;
public TreeNode left, right;
public TreeNode(int item)
{
data = item;
left = right = null;
}
}
class PostOrder{
public TreeNode root;
// Function to find Post Order
// Traversal Using Constant space
void postOrderConstantspace(TreeNode root)
{
if (root == null)
return;
TreeNode current = new TreeNode(-1), pre = null;
TreeNode prev = null,
succ = null,
temp = null;
current.left = root;
while (current != null)
{
// Go to the right child
// if current does not
// have a left child
if (current.left == null)
{
current = current.right;
}
else
{
// Traverse left child
pre = current.left;
// Find the right most child
// in the left subtree
while (pre.right != null &&
pre.right != current)
pre = pre.right;
if (pre.right == null)
{
// Make current as the right
// child of the right most node
pre.right = current;
// Traverse the left child
current = current.left;
}
else
{
pre.right = null;
succ = current;
current = current.left;
prev = null;
// Traverse along the right
// subtree to the
// right-most child
while (current != null)
{
temp = current.right;
current.right = prev;
prev = current;
current = temp;
}
// Traverse back from
// right most child to
// current's left child node
while (prev != null)
{
Console.Write(prev.data + " ");
temp = prev.right;
prev.right = current;
current = prev;
prev = temp;
}
current = succ;
current = current.right;
}
}
}
}
// Driver code
static public void Main ()
{
/* Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
*/
PostOrder tree = new PostOrder();
tree.root = new TreeNode(1);
tree.root.left = new TreeNode(2);
tree.root.right = new TreeNode(3);
tree.root.left.left = new TreeNode(4);
tree.root.left.right = new TreeNode(5);
tree.root.right.left = new TreeNode(6);
tree.root.right.right = new TreeNode(7);
tree.root.left.right.left = new TreeNode(8);
tree.root.left.right.right = new TreeNode(9);
tree.postOrderConstantspace(tree.root);
}
}
// This code is contributed by offbeat
<script>
// Javascript program to implement
// Post Order traversal
// of Binary Tree in O(N)
// time and O(1) space
// Definition of the
// binary tree
class TreeNode
{
constructor(item)
{
this.data = item;
this.left = null;
this.right = null;
}
}
var root;
// Function to find Post Order
// Traversal Using Constant space
function postOrderConstantspace(root)
{
if (root == null)
return;
var current = new TreeNode(-1), pre = null;
var prev = null,
succ = null,
temp = null;
current.left = root;
while (current != null)
{
// Go to the right child
// if current does not
// have a left child
if (current.left == null)
{
current = current.right;
}
else
{
// Traverse left child
pre = current.left;
// Find the right most child
// in the left subtree
while (pre.right != null &&
pre.right != current)
pre = pre.right;
if (pre.right == null)
{
// Make current as the right
// child of the right most node
pre.right = current;
// Traverse the left child
current = current.left;
}
else
{
pre.right = null;
succ = current;
current = current.left;
prev = null;
// Traverse along the right
// subtree to the
// right-most child
while (current != null)
{
temp = current.right;
current.right = prev;
prev = current;
current = temp;
}
// Traverse back from
// right most child to
// current's left child node
while (prev != null)
{
document.write(prev.data + " ");
temp = prev.right;
prev.right = current;
current = prev;
prev = temp;
}
current = succ;
current = current.right;
}
}
}
}
// Driver code
/* Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
*/
var tree = new TreeNode();
tree.root = new TreeNode(1);
tree.root.left = new TreeNode(2);
tree.root.right = new TreeNode(3);
tree.root.left.left = new TreeNode(4);
tree.root.left.right = new TreeNode(5);
tree.root.right.left = new TreeNode(6);
tree.root.right.right = new TreeNode(7);
tree.root.left.right.left = new TreeNode(8);
tree.root.left.right.right = new TreeNode(9);
postOrderConstantspace(tree.root);
</script>
Time Complexity: O(N)
Auxiliary Space: O(1)
Method 2: In method 1, we traverse a path, reverse references, print nodes as we restore the references by reversing them again. In method 2, instead of reversing paths and restoring the structure, we traverse to the parent node from the current node using the current node's left subtree. This could be faster depending on the tree structure, for example in a right-skewed tree.
The following algorithm and diagrams provide the details of the approach.
Below is the conceptual diagram showing how the left and right child references are used to traverse back and forth.
Below is the diagram which highlights the path 1->2->5->9 and the way the nodes are processed and printed as per the above algorithm.
Below is the implementation of the above approach:
C++
// C++ Program to implement the above approach
#include <bits/stdc++.h>
using namespace std;
struct TreeNode {
TreeNode* left;
TreeNode* right;
int data;
TreeNode(int data)
{
this->data = data;
this->left = nullptr;
this->right = nullptr;
}
};
TreeNode* root;
// Function to Calculate Post
// Order Traversal Using
// Constant Space
static void postOrderConstantspace(TreeNode* root)
{
if (root == nullptr)
return;
TreeNode* current = nullptr;
TreeNode* prevNode = nullptr;
TreeNode* pre = nullptr;
TreeNode* ptr = nullptr;
TreeNode* netChild = nullptr;
TreeNode* prevPtr = nullptr;
current = root;
while (current != nullptr)
{
if (current->left == nullptr)
{
current->left = prevNode;
// Set prevNode to current
prevNode = current;
current = current->right;
}
else
{
pre = current->left;
// Find the right most child
// in the left subtree
while (pre->right != nullptr &&
pre->right != current)
pre = pre->right;
if (pre->right == nullptr)
{
pre->right = current;
current = current->left;
}
else
{
// Set the right most
// child's right pointer
// to NULL
pre->right = nullptr;
cout << pre->data << " ";
ptr = pre;
netChild = pre;
prevPtr = pre;
while (ptr != nullptr)
{
if (ptr->right == netChild)
{
cout << ptr->data << " ";
netChild = ptr;
prevPtr->left = nullptr;
}
if (ptr == current->left)
break;
// Break the loop
// all the left subtree
// nodes of current
// processed
prevPtr = ptr;
ptr = ptr->left;
}
prevNode = current;
current = current->right;
}
}
}
cout << prevNode->data << " ";
// Last path traversal
// that includes the root.
ptr = prevNode;
netChild = prevNode;
prevPtr = prevNode;
while (ptr != nullptr)
{
if (ptr->right == netChild)
{
cout << ptr->data << " ";
netChild = ptr;
prevPtr->left = nullptr;
}
if (ptr == root)
break;
prevPtr = ptr;
ptr = ptr->left;
}
}
int main()
{
/* Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
*/
root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
root->right->left = new TreeNode(6);
root->right->right = new TreeNode(7);
root->left->right->left = new TreeNode(8);
root->left->right->right = new TreeNode(9);
postOrderConstantspace(root);
return 0;
}
// This code is contributed by mukesh07.
// Java Program to implement
// the above approach
class TreeNode {
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
this.data = data;
}
public String toString()
{
return data + " ";
}
}
public class PostOrder {
TreeNode root;
// Function to Calculate Post
// Order Traversal
// Using Constant Space
void postOrderConstantspace(TreeNode root)
{
if (root == null)
return;
TreeNode current = null;
TreeNode prevNode = null;
TreeNode pre = null;
TreeNode ptr = null;
TreeNode netChild = null;
TreeNode prevPtr = null;
current = root;
while (current != null) {
if (current.left == null) {
current.left = prevNode;
// Set prevNode to current
prevNode = current;
current = current.right;
}
else {
pre = current.left;
// Find the right most child
// in the left subtree
while (pre.right != null
&& pre.right != current)
pre = pre.right;
if (pre.right == null) {
pre.right = current;
current = current.left;
}
else {
// Set the right most
// child's right pointer
// to NULL
pre.right = null;
System.out.print(pre);
ptr = pre;
netChild = pre;
prevPtr = pre;
while (ptr != null) {
if (ptr.right == netChild) {
System.out.print(ptr);
netChild = ptr;
prevPtr.left = null;
}
if (ptr == current.left)
break;
// Break the loop
// all the left subtree
// nodes of current
// processed
prevPtr = ptr;
ptr = ptr.left;
}
prevNode = current;
current = current.right;
}
}
}
System.out.print(prevNode);
// Last path traversal
// that includes the root.
ptr = prevNode;
netChild = prevNode;
prevPtr = prevNode;
while (ptr != null) {
if (ptr.right == netChild) {
System.out.print(ptr);
netChild = ptr;
prevPtr.left = null;
}
if (ptr == root)
break;
prevPtr = ptr;
ptr = ptr.left;
}
}
// Main Function
public static void main(String[] args)
{
/* Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
*/
PostOrder tree = new PostOrder();
tree.root = new TreeNode(1);
tree.root.left = new TreeNode(2);
tree.root.right = new TreeNode(3);
tree.root.left.left
= new TreeNode(4);
tree.root.left.right
= new TreeNode(5);
tree.root.right.left
= new TreeNode(6);
tree.root.right.right
= new TreeNode(7);
tree.root.left.right.left
= new TreeNode(8);
tree.root.left.right.right
= new TreeNode(9);
tree.postOrderConstantspace(
tree.root);
}
}
# Python3 Program to implement the above approach
class TreeNode:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# Function to Calculate Post
# Order Traversal Using
# Constant Space
def postOrderConstantspace(root):
if root == None:
return
current = None
prevNode = None
pre = None
ptr = None
netChild = None
prevPtr = None
current = root
while current != None:
if current.left == None:
current.left = prevNode
# Set prevNode to current
prevNode = current
current = current.right
else:
pre = current.left
# Find the right most child
# in the left subtree
while pre.right != None and pre.right != current:
pre = pre.right
if pre.right == None:
pre.right = current
current = current.left
else:
# Set the right most
# child's right pointer
# to NULL
pre.right = None
print(pre.data, end = " ")
ptr = pre
netChild = pre
prevPtr = pre
while ptr != None:
if ptr.right == netChild:
print(ptr.data, end = " ")
netChild = ptr
prevPtr.left = None
if ptr == current.left:
break
# Break the loop
# all the left subtree
# nodes of current
# processed
prevPtr = ptr
ptr = ptr.left
prevNode = current
current = current.right
print(prevNode.data, end = " ")
# Last path traversal
# that includes the root.
ptr = prevNode
netChild = prevNode
prevPtr = prevNode
while ptr != None:
if ptr.right == netChild:
print(ptr.data, end = " ")
netChild = ptr
prevPtr.left = None
if (ptr == root):
break
prevPtr = ptr
ptr = ptr.left
""" Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
"""
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
root.left.right.left = TreeNode(8)
root.left.right.right = TreeNode(9)
postOrderConstantspace(root)
# This code is contributed by divyeshrabadiya07.
// C# Program to implement
// the above approach
using System;
class TreeNode{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
this.data = data;
}
public string toString()
{
return data + " ";
}
}
class PostOrder{
TreeNode root;
// Function to Calculate Post
// Order Traversal Using
// Constant Space
void postOrderConstantspace(TreeNode root)
{
if (root == null)
return;
TreeNode current = null;
TreeNode prevNode = null;
TreeNode pre = null;
TreeNode ptr = null;
TreeNode netChild = null;
TreeNode prevPtr = null;
current = root;
while (current != null)
{
if (current.left == null)
{
current.left = prevNode;
// Set prevNode to current
prevNode = current;
current = current.right;
}
else
{
pre = current.left;
// Find the right most child
// in the left subtree
while (pre.right != null &&
pre.right != current)
pre = pre.right;
if (pre.right == null)
{
pre.right = current;
current = current.left;
}
else
{
// Set the right most
// child's right pointer
// to NULL
pre.right = null;
Console.Write(pre.data + " ");
ptr = pre;
netChild = pre;
prevPtr = pre;
while (ptr != null)
{
if (ptr.right == netChild)
{
Console.Write(ptr.data + " ");
netChild = ptr;
prevPtr.left = null;
}
if (ptr == current.left)
break;
// Break the loop
// all the left subtree
// nodes of current
// processed
prevPtr = ptr;
ptr = ptr.left;
}
prevNode = current;
current = current.right;
}
}
}
Console.Write(prevNode.data + " ");
// Last path traversal
// that includes the root.
ptr = prevNode;
netChild = prevNode;
prevPtr = prevNode;
while (ptr != null)
{
if (ptr.right == netChild)
{
Console.Write(ptr.data + " ");
netChild = ptr;
prevPtr.left = null;
}
if (ptr == root)
break;
prevPtr = ptr;
ptr = ptr.left;
}
}
// Driver code
public static void Main(string[] args)
{
/* Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
*/
PostOrder tree = new PostOrder();
tree.root = new TreeNode(1);
tree.root.left = new TreeNode(2);
tree.root.right = new TreeNode(3);
tree.root.left.left = new TreeNode(4);
tree.root.left.right = new TreeNode(5);
tree.root.right.left = new TreeNode(6);
tree.root.right.right = new TreeNode(7);
tree.root.left.right.left = new TreeNode(8);
tree.root.left.right.right = new TreeNode(9);
tree.postOrderConstantspace(tree.root);
}
}
// This code is contributed by Rutvik_56
<script>
// Javascript Program to implement the above approach
class TreeNode
{
constructor(data) {
this.left = null;
this.right = null;
this.data = data;
}
}
let root;
// Function to Calculate Post
// Order Traversal Using
// Constant Space
function postOrderConstantspace(root)
{
if (root == null)
return;
let current = null;
let prevNode = null;
let pre = null;
let ptr = null;
let netChild = null;
let prevPtr = null;
current = root;
while (current != null)
{
if (current.left == null)
{
current.left = prevNode;
// Set prevNode to current
prevNode = current;
current = current.right;
}
else
{
pre = current.left;
// Find the right most child
// in the left subtree
while (pre.right != null &&
pre.right != current)
pre = pre.right;
if (pre.right == null)
{
pre.right = current;
current = current.left;
}
else
{
// Set the right most
// child's right pointer
// to NULL
pre.right = null;
document.write(pre.data + " ");
ptr = pre;
netChild = pre;
prevPtr = pre;
while (ptr != null)
{
if (ptr.right == netChild)
{
document.write(ptr.data + " ");
netChild = ptr;
prevPtr.left = null;
}
if (ptr == current.left)
break;
// Break the loop
// all the left subtree
// nodes of current
// processed
prevPtr = ptr;
ptr = ptr.left;
}
prevNode = current;
current = current.right;
}
}
}
document.write(prevNode.data + " ");
// Last path traversal
// that includes the root.
ptr = prevNode;
netChild = prevNode;
prevPtr = prevNode;
while (ptr != null)
{
if (ptr.right == netChild)
{
document.write(ptr.data + " ");
netChild = ptr;
prevPtr.left = null;
}
if (ptr == root)
break;
prevPtr = ptr;
ptr = ptr.left;
}
}
/* Constructed tree is as follows:-
1
/ \
2 3
/ \ / \
4 5 6 7
/ \
8 9
*/
root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);
root.right.left = new TreeNode(6);
root.right.right = new TreeNode(7);
root.left.right.left = new TreeNode(8);
root.left.right.right = new TreeNode(9);
postOrderConstantspace(root);
// This code is contributed by divyesh072019.
</script>
Time Complexity: O(N)
Auxiliary Space: O(1)
Similar Reads
Basics & Prerequisites
Data Structures
Array Data StructureIn this article, we introduce array, implementation in different popular languages, its basic operations and commonly seen problems / interview questions. An array stores items (in case of C/C++ and Java Primitive Arrays) or their references (in case of Python, JS, Java Non-Primitive) at contiguous
3 min read
String in Data StructureA string is a sequence of characters. The following facts make string an interesting data structure.Small set of elements. Unlike normal array, strings typically have smaller set of items. For example, lowercase English alphabet has only 26 characters. ASCII has only 256 characters.Strings are immut
2 min read
Hashing in Data StructureHashing is a technique used in data structures that efficiently stores and retrieves data in a way that allows for quick access. Hashing involves mapping data to a specific index in a hash table (an array of items) using a hash function. It enables fast retrieval of information based on its key. The
2 min read
Linked List Data StructureA linked list is a fundamental data structure in computer science. It mainly allows efficient insertion and deletion operations compared to arrays. Like arrays, it is also used to implement other data structures like stack, queue and deque. Here’s the comparison of Linked List vs Arrays Linked List:
2 min read
Stack Data StructureA 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
2 min read
Queue Data StructureA 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. It is used as a buffer in computer systems
2 min read
Tree Data StructureTree Data Structure is a non-linear data structure in which a collection of elements known as nodes are connected to each other via edges such that there exists exactly one path between any two nodes. Types of TreeBinary Tree : Every node has at most two childrenTernary Tree : Every node has at most
4 min read
Graph Data StructureGraph Data Structure is a collection of nodes connected by edges. It's used to represent relationships between different entities. If you are looking for topic-wise list of problems on different topics like DFS, BFS, Topological Sort, Shortest Path, etc., please refer to Graph Algorithms. Basics of
3 min read
Trie Data StructureThe Trie data structure is a tree-like structure used for storing a dynamic set of strings. It allows for efficient retrieval and storage of keys, making it highly effective in handling large datasets. Trie supports operations such as insertion, search, deletion of keys, and prefix searches. In this
15+ min read
Algorithms
Searching AlgorithmsSearching algorithms are essential tools in computer science used to locate specific items within a collection of data. In this tutorial, we are mainly going to focus upon searching in an array. When we search an item in an array, there are two most common algorithms used based on the type of input
2 min read
Sorting AlgorithmsA Sorting Algorithm is used to rearrange a given array or list of elements in an order. For example, a given array [10, 20, 5, 2] becomes [2, 5, 10, 20] after sorting in increasing order and becomes [20, 10, 5, 2] after sorting in decreasing order. There exist different sorting algorithms for differ
3 min read
Introduction to RecursionThe process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called a recursive function. A recursive algorithm takes one step toward solution and then recursively call itself to further move. The algorithm stops once we reach the solution
14 min read
Greedy AlgorithmsGreedy algorithms are a class of algorithms that make locally optimal choices at each step with the hope of finding a global optimum solution. At every step of the algorithm, we make a choice that looks the best at the moment. To make the choice, we sometimes sort the array so that we can always get
3 min read
Graph AlgorithmsGraph is a non-linear data structure like tree data structure. The limitation of tree is, it can only represent hierarchical data. For situations where nodes or vertices are randomly connected with each other other, we use Graph. Example situations where we use graph data structure are, a social net
3 min read
Dynamic Programming or DPDynamic Programming is an algorithmic technique with the following properties.It is mainly an optimization over plain recursion. Wherever we see a recursive solution that has repeated calls for the same inputs, we can optimize it using Dynamic Programming. The idea is to simply store the results of
3 min read
Bitwise AlgorithmsBitwise algorithms in Data Structures and Algorithms (DSA) involve manipulating individual bits of binary representations of numbers to perform operations efficiently. These algorithms utilize bitwise operators like AND, OR, XOR, NOT, Left Shift, and Right Shift.BasicsIntroduction to Bitwise Algorit
4 min read
Advanced
Segment TreeSegment Tree is a data structure that allows efficient querying and updating of intervals or segments of an array. It is particularly useful for problems involving range queries, such as finding the sum, minimum, maximum, or any other operation over a specific range of elements in an array. The tree
3 min read
Pattern SearchingPattern searching algorithms are essential tools in computer science and data processing. These algorithms are designed to efficiently find a particular pattern within a larger set of data. Patten SearchingImportant Pattern Searching Algorithms:Naive String Matching : A Simple Algorithm that works i
2 min read
GeometryGeometry is a branch of mathematics that studies the properties, measurements, and relationships of points, lines, angles, surfaces, and solids. From basic lines and angles to complex structures, it helps us understand the world around us.Geometry for Students and BeginnersThis section covers key br
2 min read
Interview Preparation
Practice Problem