Postfix notation (also called Reverse Polish Notation or RPN) places every operator after its operands. For example, the infix expression (6 - (2 + 3)) * (3 + 8/2) becomes the postfix expression 623+-382/+*. Evaluating postfix expressions is straightforward using a stack — no parentheses or precedence rules are needed.
This post implements a postfix evaluator in Java using an integer stack. The program accepts a postfix string as input and prints the computed result.
Java’s String class provides a rich set of built-in methods for manipulating text. In this post, we demonstrate the most commonly used string functions — including case conversion, length, concatenation, trimming, character access, equality checks, and index searching — through a simple interactive Java program.
A stack is a LIFO (Last In, First Out) data structure where elements are inserted and removed from the same end, called the top. While a stack is commonly implemented using a fixed-size array, it can also be backed by a linked list — which removes the size constraint entirely and allocates memory only as elements are pushed.
In this post, we implement a stack using a singly linked list in Java. Each push operation adds a new node at the head of the list, and each pop removes the head node — making both operations O(1).
A circular queue is a fixed-size queue where the storage array is treated as a ring. When elements are dequeued from the front, those positions become available again for future insertions — eliminating the wasted space problem of linear array queues. The queue follows the FIFO (First In, First Out) principle: elements are added at the rear and removed from the front.
This post presents a circular queue implementation in Java using a static array-backed design, demonstrating enqueue, dequeue, peek, and display operations through a menu-driven console program.
A Doubly Linked List (DLL) is a linked data structure where each node holds a value and two pointers: one pointing to the next node and one pointing to the previous node. This bidirectional linkage enables forward and reverse traversal — something a singly linked list cannot do without extra memory.
A doubly-linked list: each node stores a value, a link to the next node, and a link to the previous node.
In this post, we implement a DLL in Java that supports insertion at the first position, last position, after a given position, and before a given position — as well as deletion, search, and both forward and reverse display.
A Circular Queue (also called a Ring Buffer) is a queue data structure that treats its underlying array as if it were connected end-to-end in a circle. Unlike a linear queue, once the rear pointer reaches the end of the array, it wraps back to index 0 — allowing reuse of freed slots without shifting elements.
This post implements a true circular queue in Java using an array, with proper wraparound logic for both the front and rear pointers.
How a Circular Queue Works
Both front and rear start at -1 (empty state).
Enqueue: Advance rear with wraparound: rear = (rear + 1) % size. The queue is full when (rear + 1) % size == front.
Dequeue: Advance front with wraparound: front = (front + 1) % size. Reset both to -1 when the last element is removed.
Circular property: Elements can be added to index 0 again after front has moved past it.
A Binary Search Tree (BST) is a node-based binary tree data structure where each node stores a key, and every node in the left subtree holds a key strictly smaller than the parent, while every node in the right subtree holds a key strictly greater. This ordering property makes BSTs excellent for fast lookup, insertion, and deletion — all in O(log n) time on average.
In this post, we implement a BST in Java that supports insertion, search, and three traversal orders: inorder, preorder, and postorder.
BST Properties
One node is designated the root of the tree.
Each internal node contains a key and has at most two child subtrees.
The left subtree of a node contains only keys strictly less than the node’s key.
The right subtree of a node contains only keys strictly greater than the node’s key.
