Scribd
Upload
43 views

Linked List Data Structure For BTech

Node structure contains a link to the next node and data variables. There are several ways to implement common linked list operations - to insert at the end iterate to the last node and add the new node; to print iterate through the list until reaching the end; to insert at the head make the new node head and point the old head to the new node. To search linearly iterate through the list comparing the node data to the target value. To delete a node either update head if deleting head or search for the target node and delete by updating its previous node's next pointer. There are iterative and recursive methods to reverse a linked list - iterative uses three pointers for previous, current, next while recursive makes

Uploaded by

Riya Kumari
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
43 views

Linked List Data Structure For BTech

Node structure contains a link to the next node and data variables. There are several ways to implement common linked list operations - to insert at the end iterate to the last node and add the new node; to print iterate through the list until reaching the end; to insert at the head make the new node head and point the old head to the new node. To search linearly iterate through the list comparing the node data to the target value. To delete a node either update head if deleting head or search for the target node and delete by updating its previous node's next pointer. There are iterative and recursive methods to reverse a linked list - iterative uses three pointers for previous, current, next while recursive makes

Uploaded by

Riya Kumari
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

Linked List [IMP QUESTIONS]

Node structure
Each node contains the link to the next node and some data variables.

Implementation
1. Make a node named head. This will act as the start of the linked
list.

To INSERT at the end of the Linked List, iterate to the last node. In the
below code temp is the last node. So temp -> next = new node(val).

PRINTING a Linked List


We pass the head of the node, and then keep on iterating till we do not
reach the end of the node.
INSERTING at the head
The next of the new node should be the old linked list (head). So the
head will now point to the new node because it now becomes the new
head.

Try yourself:
Do a Linear Search in the Linked List.

Code for Linear Search:


DELETION OF A NODE
To delete a node having node->data=
val There are two cases:
1. We have to delete the node. In that case, we simply increment
head.
2. Else, we search for the node having node->next->data == val. And
then delete it.

REVERSE a Linked List [Both methods are very


important] There are two methods:
1. Iterative
2. Idea: We will keep three-pointers, for the previous, current, and
next node. Hint: We have to connect current->next to the
previous node, and then move to the next node.

3. Recursive
Idea: We are at the head, recursively reverse the remaining list.
The (head->next) is the next node, this node should be the
second last node in the reversed list. head would be the last node
in the reversed list, so its next should be NULL. And then we will
return the reversed list.

K REVERSE [IMP]
Given a linked list and an integer K. Reverse the nodes of a linked list k
at a time and return its modified list. If the number of nodes is not a
multiple of K then left-out nodes, in the end, should remain as it is.
Idea: There are 2 cases:
1. The size of the linked list is less than K. In this case, return the list
as it is.
2. The size of the linked list is more than K. Reverse the first K nodes
and recurse for the remaining list.

FollowUp: Try to do it iteratively as well.

CYCLE DETECTION[IMP][without map] Floyd’s cycle


detection
Also know as hare and tortoise method, and slow and fast pointer
method. Idea: Slow and pointers are initially at the start. Slow takes
one step. Fast takes two-step at a time.
Time Complexity: O(n)
MIDDLE OF LINKED LIST

ListNode* middleNode(ListNode* head) {


ListNode* slow=head;
ListNode* fast=head;

while(fast->next!=NULL && fast->next->next!=NULL){


slow=slow->next;
fast=fast->next->next;
}

if(fast->next!=NULL){
slow=slow->next;
}
return slow;
}
REMOVE LOOP IN LINKED LIST
void removeLoop(Node* head)
{
// code here
// just remove the loop without losing any nodes
Node* dummy=new Node(0);
dummy->next=head;
Node* slow=dummy;
Node* fast=dummy;
Node*temp = dummy;

while(fast != NULL && fast->next != NULL) {


slow = slow->next;
fast = fast->next->next;
if(fast == slow) break;
}

if(slow!=fast) return;
while(temp->next != fast->next)
{
temp = temp ->next;
fast = fast->next;
}
fast ->next = NULL;
head = dummy->next;
}

Doubly linked list


The structure of the linked list gets modified. In a doubly linked list,
each node will also store the link to the previous node.
Implementation

Circular Linked List


In a circular linked list, the last node is connected to the first node in the
linked list.
Implementation

Additional Important Questions:

1. Delete a Node in Linked List


2. Palindrome Linked List
3. Swap nodes in pair
4. N’th node from the last
5. Add 2 numbers
6. Merge Sort in Linked List

You might also like