Linked List

-
A linked list is a linear data structure and stores it at the non-contiguous memory location. Non-contiguous memory location means that it doesn't guarantee that each data element will reside next to each other in the memory. There are chances that one memory location address is 1000 and another one is 1200; then the immediate question comes into our mind. How do they actually know which data will be next? Are they using some kind of magic behind the scene?
Let's understand the linked list with the carousel/slider example which we used many times on many websites. You have analyzed the carousel and are working on the number of images that put it into some sequence and rotate one by one. They have one common characteristic, that is, if we want to look for the last image in the carousel then we have to go one by one till the last. There is one start point, which we usually call head and one termination point which we usually call a tail. Each Image can be considered as a node in a linked list term. Each node contains data and the address of the next node.
NOTE:- X represents null means that there is no more node that exists after it.
Singly Linked List

A singly linked list traverses only in a forward direction. Each node consists of the value and the address of the next node. We can traverse only from the start to the end node but not vice versa. If we lose the start node then the complete list will be lost.

Circular Singly Linked List
A Circular singly linked list is almost the same as a singly linked list but the last node is pointing to the start node of a linked list. We have to be very careful, while writing a traversing logic into the circular linked list. If we make a mistake and miss the base condition that the node's next address must not equal the start node's address then traversing will run infinite times.
Doubly Linked List
A Doubly linked list is more powerful than the singly linked list in terms of traversing a linked list backward and forward. Each node contains two references of the next and previous node with the value of itself. Still, we can't directly traverse to the last node.
Circular Doubly Linked List

A Circular doubly linked list is more powerful than any other linked list but it stores previous and next node reference on it. We can transverse in any of the directions. We can traverse reverse also.

If and only if you have such a scenario then only you should use a Doubly Linked List otherwise we should avoid using it.

Location: Delhi, India

Comments

Post a Comment

Popular posts from this blog

Recursion

-
Image
The process in which a function calls itself and only works where we call the same operation multiple times with different inputs. In every call, we try to make the problem smaller. There must be a base case where the system will stop the recursion and give you a result back. It internally stores the recursion state in the method call stack. If there is no base condition in the recursion method then it will go into an infinite loop and you might face the StackOverflow Exception . There are several types of recursion:- Head Recursion Tail Recursion Tree Recursion Nested Recursion Head Recursion It will call recursively first then at the end do all the computation. private static int factorial( int number) { return (number== 1 )? number : number* factorial (number- 1 ) ; } factorial(5) (5* factorial(5-1)) (5* (4* factorial(4-1)) (5* (4* (3*factorial(3-1))) (5* (4* (3* (2*factorial(2-1)))) (5* (4* (3* (2* (1*1))))) output = 120 Tail Recur...
Read more

Stack

-
Image
The Stack  looks more like a container which holds the element, will insert element from the top and remove from the top only. It follows the Last in First out(LIFO)  or First In Last out (FILO)  approach. Java uses the method stack area to hold the state of the method if some method calls another method inside it.   public class Demo { public static void main(String[] args) { new Demo().firstCall(); System. out .println( "Main" ); } public void firstCall() { secondCall(); System. out .println( "First" ); } private void secondCall() { thirdCall(); System. out .println( "Second" ); } private void thirdCall() { System. out .println( "Third" ); } } This is how it maintains the method call in the method stack area. It will remove from the top every time and complete its method execution and remove next's top from the stack. This process will continue until th...
Read more

Data Structure & Algorithm

-
Image
I am going to start the complete data structure and algorithm blog series to help the developer community understand the basics and help them become more productive in their work environment. As we all are under lockdown until the next update from the government, I have decided to support my friends and colleague to understand the data structure and algorithm. Let's begin by separating the data structure and algorithm in two terms. When you hear about data structure,  what comes first to your mind. I believe most of you thought of storing any form of data in an efficient way. Yes, You are correct 👍. Now, Second and the most important term is an algorithm , It is a set of rules to be followed to solve a problem. To gain more understanding of the data structure and algorithm, let us take an example:- E.g., We are all going to attend the google conference and they have a single registration desk. If we all reach the registration counter together, to register ourselves. Such a ...
Read more