#linked-list

Linked Lists are a fundamental data structure that are widely used in computer science and software engineering. In this article, we will take a closer look at what Linked Lists are, how they are used, and how to implement them in Python. We will also dis

# Introduction to Linked List A Linked List is a linear collection of data elements, called nodes, which are connected together via links. Each node contains two parts: the data and a reference (or pointer) to the next node in the list. The last node in the list has a reference to null, indicating the end of the list. Linked Lists offer several advantages over other data structures such as…

Reverse a Linked List in Java by Recursion

Overview

In this example we will see how to reverse a LinkedList in Java using recursion. In computer science, a linked list is a linear collection of data elements whose order is not given by their physical placement in memory. Instead, each element points to the next. It is a data structure consisting of a collection of nodes which together represent a sequence.

Figure 1. Linked List…

Reverse a Linked List in Java by Iteration

Overview

In this example we will see how to reverse a LinkedList in Java using iteration. In computer science, a linked list is a linear collection of data elements whose order is not given by their physical placement in memory. Instead, each element points to the next. It is a data structure consisting of a collection of nodes which together represent a sequence.

Figure 1. Linked ListCode

Yes I was also doubtful. 

Usually deletion of a node from a singly-linked-list is thought to be O(n) time. 

Let’s say you use a function called delete that takes a node to be deleted as an argument, and the head of the list as the other. 

Even though you have a direct reference to the node to be deleted, you cannot simply set it’s .next to null. That would break the chain. 

You also need to connect the your node’s previous with your node’s next. 

Think of singly-linked lists like a conga line, where you face another person’s back, and you place your hands squarely upon their shoulders. If you decide to leave the conga line, not only do you have to remove your hands from the shoulders of the person in front of you, you also need to help the person behind you replace you by placing his hands on the shoulders of the person in front of you. 

In a doubly linked list, this would be very easy, because every node would have a reference to the previous and next nodes. However, in a singly-linked-list, a node only has a reference to the next node. 

This is why it is necessary to start again from the beginning to search for the previous node, to form the new connection. 

Because you are going through the list again, it has a time complexity of O(n), which is why deletion is thought of as a linear time operation. 

However, while watching Skiena’s lectures on Dictionaries, a student brought to his attention a different approach, an approach that would allow deletion become a constant time operation. Yes, for singly-linked-lists.

Let’s bring back the conga line. You need to be removed. Instead of actually removing you, because we always have easy access to information about the HEAD of the list, you are simply going to rewrite yourself to look exactly like the HEAD. Of course, the person after you will still have their hands on your shoulders, and your hands will still be on the shoulders of the person in front of you. 

Okay, so I guess I’m not really there anymore, but that’s so weird... Aren’t there mysteriously two of the same people on the conga line now? Yes, we’ll address that now. 

What you must also do, is re-set the HEAD of the list, to the following person. In our metaphor, the HEAD would be the first person in the conga line. But we change that so the new HEAD will be the second person. 

Now there are no clones, and you have essentially been deleted from the conga line. 

But John, you crazy dog, you’ve messed up the order...

I know. I was pretty upset by this as well at first. So that brings a caveat. If it is required that the list remain stable, as in the nodes are not switched around, then this would not work. But if it does not matter, then this is a perfectly reasonable way to delete a node quickly. 

Example:

1 <== 2 <== 3 <== 4

We want to delete 3.

1 <== 2 <== 1 <== 4

We change 3 to look exactly like our HEAD, 1.

2 <== 1 <== 4

Fixed How to detect a loop in a linked list? #dev #it #asnwer

How to detect a loop in a linked list?

Say you have a linked list structure in Java. It’s made up of Nodes:

class Node { Node next; // some user data }

and each Node points to the next node, except for the last Node, which has null for next. Say there is a possibility that the list can contain a loop – i.e. the final Node, instead of having a null, has a reference to one of the nodes in the…

Fixed When should I use a List vs a LinkedList #dev #it #asnwer

When should I use a List vs a LinkedList

When is it better to use a List(Of T) vs a LinkedList(Of T)?

Answer: When should I use a List vs a LinkedList

When you need built-in indexed access, sorting (and after this binary searching), and “ToArray()” method, you should use List.

Answer: When should I use a List vs a LinkedList

In most cases, List<T> is more useful. LinkedList<T>will have less…

Fixed When to use LinkedList over ArrayList? #dev #it #asnwer

When to use LinkedList<> over ArrayList<>?

I’ve always been one to simply use List<String> names = new ArrayList<String>(); I use the interface as the type name for portability, so that when I ask questions such as these I can rework my code.

When should LinkedList be used over ArrayList and vice-versa?

Answer: When to use LinkedList<> over ArrayList<>?

1) Search:ArrayList search operation is…