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. Each subtree is itself a valid BST.
Postfix notation (also called Reverse Polish Notation or RPN) is a mathematical notation where every operator follows all of its operands. For example, the infix expression 3 + 4 becomes 3 4 + in postfix. This eliminates the need for parentheses and operator precedence rules, making it ideal for stack-based evaluation. In this post, we implement a Java program that evaluates a postfix expression using a stack. The program reads the expression as a string and produces the integer result.