This presentations gives an introduction to the data structure linked-lists. I discuss the implementation of header-based linked-lists in C. The presentation runs through the code and provides the visualization of the code w.r.t pointers.
Linked List Static and Dynamic Memory AllocationProf Ansari
Static variables are declared and named while writing the program. (Space for them exists as long as the program, in which they are declared, is running.) Static variables cannot be created or destroyed during execution of the program in which they are declared.
Dynamic variables are created (and may be destroyed) during program execution since dynamic variables do not exist while the program is compiled, but only when it is run, they cannot be assigned names while it is being written. The only way to access dynamic variables is by using pointers. Once it is created, however, a dynamic variable does contain data and must have a type like any other variable. If a dynamic variable is created in a function, then it can continue to exist even after the function terminates.
Linked Linear List
We saw in previous chapters how static representation of linear ordered list through Array leads to wastage of memory and in some cases overflows. Now we don't want to assign memory to any linear list in advance instead we want to allocate memory to elements as they are inserted in list. This requires Dynamic Allocation of memory and it can be achieved by using malloc() or calloc() function.
But memory assigned to elements will not be contiguous, which is a requirement for linear ordered list, and was provided by array representation. How we could achieve this?
Doubly Linked List || Operations || AlgorithmsShubham Sharma
Doubly linked list and operations on it. Insertion, Deletion, Traversing at all locations- First, Last, Middle.
Basic definitions and structured example.
Algorithms for all the operations.
This presentations gives an introduction to the data structure linked-lists. I discuss the implementation of header-based linked-lists in C. The presentation runs through the code and provides the visualization of the code w.r.t pointers.
Linked List Static and Dynamic Memory AllocationProf Ansari
Static variables are declared and named while writing the program. (Space for them exists as long as the program, in which they are declared, is running.) Static variables cannot be created or destroyed during execution of the program in which they are declared.
Dynamic variables are created (and may be destroyed) during program execution since dynamic variables do not exist while the program is compiled, but only when it is run, they cannot be assigned names while it is being written. The only way to access dynamic variables is by using pointers. Once it is created, however, a dynamic variable does contain data and must have a type like any other variable. If a dynamic variable is created in a function, then it can continue to exist even after the function terminates.
Linked Linear List
We saw in previous chapters how static representation of linear ordered list through Array leads to wastage of memory and in some cases overflows. Now we don't want to assign memory to any linear list in advance instead we want to allocate memory to elements as they are inserted in list. This requires Dynamic Allocation of memory and it can be achieved by using malloc() or calloc() function.
But memory assigned to elements will not be contiguous, which is a requirement for linear ordered list, and was provided by array representation. How we could achieve this?
Doubly Linked List || Operations || AlgorithmsShubham Sharma
Doubly linked list and operations on it. Insertion, Deletion, Traversing at all locations- First, Last, Middle.
Basic definitions and structured example.
Algorithms for all the operations.
Data Structures in C++I am really new to C++, so links are really .pdfrohit219406
Data Structures in C++
I am really new to C++, so links are really hard topic for me. It would be nice if you can provide
explanations of what doubly linked lists are and of some of you steps... Thank you
In this assignment, you will implement a doubly-linked list class, together with some list
operations. To make things easier, you’ll implement a list of int, rather than a template class.
Solution
A variable helps us to identify the data. For ex: int a = 5; Here 5 is identified through variable a.
Now, if we have collection of integers, we need some representation to identify them. We call it
array. For ex: int arr[5]
This array is nothing but a Data Structure.
So, a Data Structure is a way to group the data.
There are many Data Structures available like Arrays, Linked List, Doubly-Linked list, Stack,
Queue, etc.
Doubly-Linked list are the ones where you can traverse from the current node both in left and
right directions.
Why so many different types of Data Structures are required ?
Answer is very simple, grouping of data, storage of data and accessing the data is different.
For example, in case of Arrays we store all the data in contiguous locations.
What if we are not able to store the data in contiguous locations because we have huge data.
Answer is go for Linked List/Doubly-Linked list.
Here we can store the data anywhere and link the data through pointers.
I will try to provide comments for the code you have given. May be this can help you.
#pragma once
/*
dlist.h
Doubly-linked lists of ints
*/
#include
class dlist {
public:
dlist() { }
// Here we are creating a NODE, it has a integer value and two pointers.
// One pointer is to move to next node and other to go back to previous node.
struct node {
int value;
node* next;
node* prev;
};
// To return head pointer, i.e. start of the Doubly-Linked list.
node* head() const { return _head; }
// To return Tail pointer, i.e. end of the Doubly-Linked list.
node* tail() const { return _tail; }
// **** Implement ALL the following methods ****
// Returns the node at a particular index (0 is the head).
node* at(int index){
int cnt = 0;
struct node* tmp = head();
while(tmp!=NULL)
{
if (cnt+1 == index)
return tmp;
tmp = tmp->next;
}
}
// Insert a new value, after an existing one
void insert(node *previous, int value){
// check if the given previous is NULL
if (previous == NULL)
{
printf(\"the given previous node cannot be NULL\");
return;
}
// allocate new node
struct node* new_node =(struct node*) malloc(sizeof(struct node));
// put in the data
new_node->data = new_data;
// Make next of new node as next of previous
new_node->next = previous->next;
// Make the next of previous as new_node
previous->next = new_node;
// Make previous as previous of new_node
new_node->prev = previous;
// Change previous of new_node\'s next node
if (new_node->next != NULL)
new_node->next->prev = new_node;
}
// Delete the given node
void del(node* which){
struct node* head_ref = head();
/* base case */
if(*head_ref == NUL.
In computer science, a linked list is a linear collection of data elements, in which linear order is not given by their physical placement in memory. Instead, each element points to the next
in Java (ignore the last line thats hidden) Create a doubly linked l.pdfsauravmanwanicp
in Java (ignore the last line thats hidden) Create a doubly linked list whose nodes contain Strings.
Your list should include the following methods: Insert a node in the list in alphabetical order
Find a node that matches a String Traverse the list forwards and print Traverse the list backwards
and print Delete a node from the list Delete/destroy the list In addition to creating the class(es)
for your linked list, you\'ll need to create a main method that thoroughly tests each function you
build to show that it works. You should do these things in
Solution
/ Java program to create , insert , traverse and delete a node from doubly linked list
class LinkedList {
static Node head = null;
class Node {
int data;
Node next, prev;
Node(int d) {
data = d;
next = prev = null;
}
}
/* Let us create the doubly linked list 10<->8<->4<->2 */
list.push(head, 2);
list.push(head, 4);
list.push(head, 8);
list.push(head, 10);
System.out.println(\"Original Linked list \");
list.printList(head);
/*Function to delete a node in a Doubly Linked List.
head_ref --> pointer to head node pointer.
del --> pointer to node to be deleted. */
void deleteNode(Node head_ref, Node del) {
/* base case */
if (head == null || del == null) {
return;
}
/* If node to be deleted is head node */
if (head == del) {
head = del.next;
}
/* Change next only if node to be deleted is NOT the last node */
if (del.next != null) {
del.next.prev = del.prev;
}
/* Change prev only if node to be deleted is NOT the first node */
if (del.prev != null) {
del.prev.next = del.next;
}
/* Finally, free the memory occupied by del*/
return;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the Doubly Linked List */
void push(Node head_ref, int new_data) {
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the begining,
prev is always NULL */
new_node.prev = null;
/* link the old list off the new node */
new_node.next = (head);
/* change prev of head node to new node */
if ((head) != null) {
(head).prev = new_node;
}
/* move the head to point to the new node */
(head) = new_node;
}
/*Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(Node node) {
while (node != null) {
System.out.print(node.data + \" \");
node = node.next;
}
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
/* delete nodes from the doubly linked list */
list.deleteNode(head, head); /*delete first node*/
list.deleteNode(head, head.next); /*delete middle node*/
list.deleteNode(head, head.next); /*delete last node*/
System.out.println(\"\");
/* Modified linked list will be NULL<-8->NULL */
System.out.println(\"Modified Linked List\");
list.printList(head);
}
}.
A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.
The LinkedList1 class implements a Linked list. class.pdfmalavshah9013
/**
The LinkedList1 class implements a Linked list.
*/
class LinkedList1
{
/**
The Node class stores a list element
and a reference to the next node.
*/
private class Node
{
String value;
Node next;
/**
Constructor.
@param val The element to store in the node.
@param n The reference to the successor node.
*/
Node(String val, Node n)
{
value = val;
next = n;
}
/**
Constructor.
@param val The element to store in the node.
*/
Node(String val)
{
// Call the other (sister) constructor.
this(val, null);
}
}
private Node first; // list head
private Node last; // last element in list
/**
Constructor.
*/
public LinkedList1()
{
first = null;
last = null;
}
/**
The isEmpty method checks to see
if the list is empty.
@return true if list is empty,
false otherwise.
*/
public boolean isEmpty()
{
return first == null;
}
/**
The size method returns the length of the list.
@return The number of elements in the list.
*/
public int size()
{
int count = 0;
Node p = first;
while (p != null)
{
// There is an element at p
count ++;
p = p.next;
}
return count;
}
/**
The add method adds an element to
the end of the list.
@param e The value to add to the
end of the list.
*/
public void add(String e)
{
if (isEmpty())
{
first = new Node(e);
last = first;
}
else
{
// Add to end of existing list
last.next = new Node(e);
last = last.next;
}
}
/**
The add method adds an element at a position.
@param e The element to add to the list.
@param index The position at which to add
the element.
@exception IndexOutOfBoundsException When
index is out of bounds.
*/
public void add(int index, String e)
{
if (index < 0 || index > size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}
// Index is at least 0
if (index == 0)
{
// New element goes at beginning
first = new Node(e, first);
if (last == null)
last = first;
return;
}
// Set a reference pred to point to the node that
// will be the predecessor of the new node
Node pred = first;
for (int k = 1; k <= index - 1; k++)
{
pred = pred.next;
}
// Splice in a node containing the new element
pred.next = new Node(e, pred.next);
// Is there a new last element ?
if (pred.next.next == null)
last = pred.next;
}
/**
The toString method computes the string
representation of the list.
@return The string form of the list.
*/
public String toString()
{
StringBuilder strBuilder = new StringBuilder();
// Use p to walk down the linked list
Node p = first;
while (p != null)
{
strBuilder.append(p.value + \"\ \");
p = p.next;
}
return strBuilder.toString();
}
/**
The remove method removes the element at an index.
@param index The index of the element to remove.
@return The element removed.
@exception IndexOutOfBoundsException When index is
out of bounds.
*/
public String remove(int index)
{
if (index < 0 || index >= size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}
String element; // The element to return
if (index == 0)
{
// Removal of first item in the list
element.
ccvcvbcbvcbvcbvcbvcb vngfg hgjhg gj jgjhgjhgjhg jhgh jhgjhgj gjhgjhgjhgjhgjhgjhgjhg jghgjhgjhgjhgjhg jjghjhgjhgjhgjhgjh hgjhgjhgjhgjhgjhgjhgjgjhgjhgjhg hgfgfhdfhtftfj jgyjyyyugyugyug yjgghgjhgjhf drdfhgfgfgfgj jgjhgjhgjhgjhgjhg jhgghjfgf fxdx gfd hdhfd tftyf yytfy ytftyf ytf ytfty fytftykgh kghjg jhghgh fgfghfgh fgfghfgf gfgfgfgfytf hgfggf ghfgfg gjhghjg cfffgh jgfgfhgffhg hghh yuy ygyyuyutyutyu jgfghfhgfghfh fghfhgfhgf fthfhfhf hfhfhgf hfhgfghf fghfghfghfhhgfghf jgjhgjhgjhgjhgjhgj jgjhgjh jgjhg jgjhgjhgjhg jhgjhgjhg jhgjhg jhgjhgollowing the announcement of Google+ API deprecation scheduled for March 2019, a number of changes will be made to Blogger’s Google+ integration on 4 February 2019. *Google+ widgets:* Support for the “+1 Button”, “Google+ Followers” and “Google+ Badge” widgets in Layout will no longer be available. All instances of these widgets will be removed from all blogs. *+1 buttons:* The +1/G+ buttons and Google+ share links below blog posts and in the navigation bar will be removed. Please note that if you have a custom template that includes Google+ features, you may need to update ... read more ollowing the announcement of Google+ API deprecation scheduled for March 2019, a number of changes will be made to Blogger’s Google+ integration on 4 February 2019. *Google+ widgets:* Support for the “+1 Button”, “Google+ Followers” and “Google+ Badge” widgets in Layout will no longer be available. All instances of these widgets will be removed from all blogs. *+1 buttons:* The +1/G+ buttons and Google+ share links below blog posts and in the navigation bar will be removed. Please note that if you have a custom template that includes Google+ features, you may need to update ... read moreollowing the announcement of Google+ API deprecation scheduled for March 2019, a number of changes will be made to Blogger’s Google+ integration on 4 February 2019. *Google+ widgets:* Support for the “+1 Button”, “Google+ Followers” and “Google+ Badge” widgets in Layout will no longer be available. All instances of these widgets will be removed from all blogs. *+1 buttons:* The +1/G+ buttons and Google+ share links below blog posts and in the navigation bar will be removed. Please note that if you have a custom template that includes Google+ features, you may need to update ... read moreollowing the announcement of Google+ API deprecation scheduled for March 2019, a number of changes will be made to Blogger’s Google+ integration on 4 February 2019. *Google+ widgets:* Support for the “+1 Button”, “Google+ Followers” and “Google+ Badge” widgets in Layout will no longer be available. All instances of these widgets will be removed from all blogs. *+1 buttons:* The +1/G+ buttons and Google+ share links below blog posts and in the navigation bar will be removed. Please note that if you have a custom template that includes Google+ features, you may need to update ... read moreollowing the announcement of Google+ API deprecation scheduled for March 2019, a nu
Introduction to AI for Nonprofits with Tapp NetworkTechSoup
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
A review of the growth of the Israel Genealogy Research Association Database Collection for the last 12 months. Our collection is now passed the 3 million mark and still growing. See which archives have contributed the most. See the different types of records we have, and which years have had records added. You can also see what we have for the future.
Strategies for Effective Upskilling is a presentation by Chinwendu Peace in a Your Skill Boost Masterclass organisation by the Excellence Foundation for South Sudan on 08th and 09th June 2024 from 1 PM to 3 PM on each day.
This presentation was provided by Steph Pollock of The American Psychological Association’s Journals Program, and Damita Snow, of The American Society of Civil Engineers (ASCE), for the initial session of NISO's 2024 Training Series "DEIA in the Scholarly Landscape." Session One: 'Setting Expectations: a DEIA Primer,' was held June 6, 2024.
Macroeconomics- Movie Location
This will be used as part of your Personal Professional Portfolio once graded.
Objective:
Prepare a presentation or a paper using research, basic comparative analysis, data organization and application of economic information. You will make an informed assessment of an economic climate outside of the United States to accomplish an entertainment industry objective.
Executive Directors Chat Leveraging AI for Diversity, Equity, and InclusionTechSoup
Let’s explore the intersection of technology and equity in the final session of our DEI series. Discover how AI tools, like ChatGPT, can be used to support and enhance your nonprofit's DEI initiatives. Participants will gain insights into practical AI applications and get tips for leveraging technology to advance their DEI goals.
Biological screening of herbal drugs: Introduction and Need for
Phyto-Pharmacological Screening, New Strategies for evaluating
Natural Products, In vitro evaluation techniques for Antioxidants, Antimicrobial and Anticancer drugs. In vivo evaluation techniques
for Anti-inflammatory, Antiulcer, Anticancer, Wound healing, Antidiabetic, Hepatoprotective, Cardio protective, Diuretics and
Antifertility, Toxicity studies as per OECD guidelines
How to Fix the Import Error in the Odoo 17Celine George
An import error occurs when a program fails to import a module or library, disrupting its execution. In languages like Python, this issue arises when the specified module cannot be found or accessed, hindering the program's functionality. Resolving import errors is crucial for maintaining smooth software operation and uninterrupted development processes.
How to Manage Your Lost Opportunities in Odoo 17 CRMCeline George
Odoo 17 CRM allows us to track why we lose sales opportunities with "Lost Reasons." This helps analyze our sales process and identify areas for improvement. Here's how to configure lost reasons in Odoo 17 CRM
How to Manage Your Lost Opportunities in Odoo 17 CRM
Linked list
1. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Linked Lists
5 7 3 1 NULL
2. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Linked List
A linked list is a linear collection of data elements (called nodes),
where the linear order is given by means of pointers.
Each node is divided into 2 parts:
1st
part contains the information of the element.
2nd
part is called the link field or next pointer field which
contains the address of the next node in the list.
struct node {
int value;
struct node *next;
}
5 7 3 1
3. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Basic Operations
Insert: Add a new node in the first, last or interior of
the list.
Delete: Delete a node from the first, last or interior of
the list.
Search: Search a node containing particular value in
the linked list.
4. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insertion to a Linear Linked list
Add a new node at the first, last or interior of a linked list.
5. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert First
To add a new node to the head of the linear linked list, we need to
construct a new node that is pointed by pointer newitem.
Assume there is a global variable head which points to the first
node in the list.
The new node points to the first node in the list. The head is then
set to point to the new node.
6. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert First (Cont.)
Step 1. Create a new node that is pointed by pointer newItem.
Step 2. Link the new node to the first node of the linked list.
Step 3. Set the pointer head to the new node.
NULL
HEADnewItem
NULL
HEADnewItem
NULL
HEAD
newItem
7. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert First (Cont.)
struct node{
int value;
struct node *next;
};
struct node *head;
void insertHead(){
//create a new node
struct node *newItem = new node();
newItem->value = 10;
newItem->next = NULL;
//insert the new node at the head
newItem->next = head;
head = newItem;
}
NULL
HEADnewItem
NULL
HEADnewItem
NULL
HEAD
newItem
8. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert Last
To add a new node to the tail of the linear linked list, we
need to construct a new node and set it's link field to
"null".
Assume the list is not empty, locate the last node and
change it's link field to point to the new node.
9. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert Last (Cont.)
Step1. Create the new node.
Step2. Set a temporary pointer prev to point to the last node.
Step3. Set prev to point to the new node and new node as last node.
NULL
HEAD newItem
NULL
HEAD prev
newItem
HEAD prev
newItem
NULL
10. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert Last (Cont.)
struct node{
int value;
struct node *next;
};
struct node *head;
void insertTail(){
//create a new node to be inserted
struct node *newItem = new node();
newItem->value = 10;
newItem->next = NULL;
// set prev to point to the last node of the list
struct node *prev = head;
while (prev->next != NULL){
prev = prev->next;
}
newItem->next = prev->next;
prev->next = newItem;
}
NULL
HEAD
NULL
HEAD prev
newItemHEAD prev
NULL
11. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert Middle (after a desired node)
struct node{
int value;
struct node *next;
};
struct node *head;
void insertMiddle(int num){
//create a new node to be inserted
struct node *newItem = new node();
newItem->value = 10;
newItem->next = NULL;
// set prev to point to the desired node of the list
struct node *prev = head;
while (prev->value != num){
prev = prev->next;
}
newItem->next = prev->next;
prev->next = newItem;
}
HEAD
HEAD prev
newItemHEAD prev
12. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Printing List
void printList()
{
if (head == NULL) // no list at all
return;
struct node *cur = head;
while (cur != NULL)
{
printf("%d t", cur->value);
cur = cur->next;
}
}
13. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Deletion from a Linear Linked list
Deletion can be done
At the first node of linked list.
At the end of a linked list.
Within the linked list.
14. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Delete First
To delete the first node of the linked list, we not only want to
advance the pointer head to the second node, but we also want
to release the memory occupied by the abandoned node.
15. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Delete First (Cont.)
Step1. Initialize the pointer cur point to the first node of the list.
Step2. Move the pointer head to the second node of the list.
Step3. Remove the node that is pointed by the pointer cur.
Step 1
Step 2 Step 3
16. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Delete First (Cont.)
void deleteHead()
{
struct node *cur;
if (head = = NULL) //list empty
return;
cur = head; // save head pointer
head = head->next; //advance head
delete cur;
}
17. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Delete Last
To delete the last node in a linked list, we use a local variable,
cur, to point to the last node. We also use another variable,
prev, to point to the second last node in the linked list.
18. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Delete Last (Cont.)
Step1. Initialize pointer cur to point to the first node of the list, while the
pointer prev has a value of null.
Step2. Traverse the entire list until the pointer cur points to the last node of
the list.
Step3. Set NULL to next field of the node pointed by the pointer prev.
Step4. Remove the last node that is pointed by the pointer cur.
Step1
Step3
Step2
Step4
19. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Delete Last (Cont.)
void deleteTail(){
if (head = = NULL) //list empty
return;
struct node *cur = head;
struct node *prev = NULL;
while (cur->next != NULL){
prev = cur;
cur=cur->next;
}
if (prev != NULL)
prev->next = cur->next; //NULL;
delete cur;
}
20. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Delete Any
To delete a node that contains a particular value x in a linked
list, we use a local variable, cur, to point to this node, and
another variable, prev, to hold the previous node.
21. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Delete Any (Cont.)
Step1. Initialize pointer cur to point to the first node of the list, while the
pointer prev has a value of null.
Step2. Traverse the entire list until the pointer cur points to the node that
contains value of x, and prev points to the previous node.
……..
Step 1
Step 2
22. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Delete Any (Cont.)
…….
Step3. Link the node pointed by pointer prev to the node after the
cur’s node.
Step4. Remove the node pointed by cur.
Step 3
Step 4
23. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
void deleteAny(int x){
if (head = = NULL) //list empty
return;
struct node *cur = head;
struct node *prev = NULL;
while (cur->value != x){
prev = cur;
cur=cur->next;
}
prev->next = cur->next;
delete cur;
}
Delete Any (Cont.)
24. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Introduction to Doubly Linked List
We have discussed the details of linear linked list. In the linear linked
list, we can only traverse the linked list in one direction.
But sometimes, it is very desirable to traverse a linked list in either a
forward or reverse manner.
This property of a linked list implies that each node must contain two
link fields instead of one. The links are used to denote the predecessor
and successor of a node. The link denoting the predecessor of a node
is called the left link, and that denoting its successor its right link
25. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Basic Operation of Doubly Linked List
Insert: Add a new node in the first, last or interior of the
list.
Delete: Delete a node from the first, last or interior of the
list.
Search: Search a node containing particular value in the
linked list.
26. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert First or Insert Last into a Doubly Linked List
Insertion is to add a new node into a linked list. It can take
place anywhere -- the first, last, or interior of the linked list.
To add a new node to the head and tail of a double linked list is
similar to the linear linked list.
First, we need to construct a new node that is pointed by pointer
newItem.
Then the newItem is linked to the left-most node (or right-most
node) in the list. Finally, the Left (or Right) is set to point to the
new node.
27. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert Interior of Doubly Linked List
Step1. Create a new node that is pointed by newItem
Step2. Set the pointer prev to point to the left node of the node pointed by cur.
Step3. Set the left link of the new node to point to the node pointed by prev, and the
right link of the new node to point to the node pointed by cur.
Step4. Set the right link of the node pointed by prev and the left link of the node
pointed by cur to point to the new node.
Step1
Step3
Step2
Step4
28. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert into a Doubly Linked List
struct node
{
struct node *prev;
int value;
struct node *next;
}*head, *last;
void insert_begning(int data){
struct node *newItem,*temp;
newItem=(struct node *)malloc(sizeof(struct node));
newItem->value=data;
if(head==NULL){
head=newItem; head->prev=NULL;
head->next=NULL; last=head;
}
else{
temp=newItem;
temp->prev=NULL; temp->next=head;
head->prev=temp; head=temp;
}
}
29. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert into a Doubly Linked List
void insert_end(int data){
struct node *newItem,*temp;
newItem=(struct node *)malloc(sizeof(struct node));
newItem->value=data;
if(head==NULL){
head=newItem; head->prev=NULL;
head->next=NULL; last=head;
}
else{
last=head;
while(last!=NULL){
temp=last;
last=last->next;
}
last=newItem; temp->next=last;
last->prev=temp; last->next=NULL;
}
}
30. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Insert into a Doubly Linked List
int insert_after(int data, int loc){
struct node *temp,*newItem,*temp1;
newItem=(struct node *)malloc(sizeof(struct node));
newItem->value=data;
if(head==NULL){
head=newItem; head->prev=NULL; head->next=NULL; }
else{
temp=head;
while(temp!=NULL && temp->value!=loc)
temp=temp->next;
if (temp==NULL)
printf("n%d is not present in list ",loc);
else{
temp1=temp->next; temp->next=newItem; newItem->prev=temp;
newItem->next=temp1; temp1->prev=newItem; }
}
last=head;
while(last->next!=NULL)
last=last->next;
}
31. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Deletion of Doubly Linked List
Deletion is to remove a node from a list. It can also take place
anywhere -- the first, last, or interior of a linked list.
To delete a node from a double linked list is easier than to delete
a node from a linear linked list.
For deletion of a node in a single linked list, we have to search
and find the predecessor of the discarded node. But in the double
linked list, no such search is required.
Given the address of the node that is to be deleted, the
predecessor and successor nodes are immediately known.
32. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Deletion of Doubly Linked List (Cont.)
Step1. Set pointer prev to point to the left node of old and pointer cur to
point to the node on the right of old.
Step2. Set the right link of prev to cur, and the left link of cur to prev.
Step3. Discard the node pointed by old.
step1
step3
step2
33. Dr. Md. Abul Kashem Mia, Professor, CSE Dept, BUET
Deletion of Doubly Linked List (Cont.)
struct dnode {
struct dnode *prev;
int value;
struct dnode *next;
};
void deleteNode (struct dnode *old) {
if(head == old) /* If node to be deleted is head node */
head = old->next;
/* Change next only if node to be deleted is NOT the last node */
if(old->next != NULL)
old->next->prev = old->prev;
/* Change prev only if node to be deleted is NOT the first node */
if(old->prev != NULL)
old->prev->next = old->next;
free(old); /* Finally, free the memory occupied by old*/
return;
}