The document discusses lists and linked lists. It begins by defining a list as a homogeneous collection of elements with a linear relationship between elements that can be ordered or unordered. Lists can be implemented using arrays or linked lists. The document then discusses implementing lists using arrays and linked lists. It covers linked list definitions, representations, and common operations like traversing, searching, inserting and deleting elements. It also discusses different types of linked lists like linear linked lists, doubly linked lists, and their implementations.
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 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 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.
a. Concept and Definition✓
b. Inserting and Deleting nodes ✓
c. Linked implementation of a stack (PUSH/POP) ✓
d. Linked implementation of a queue (Insert/Remove) ✓
e. Circular List
• Stack as a circular list (PUSH/POP) ✓
• Queue as a circular list (Insert/Remove) ✓
f. Doubly Linked List (Insert/Remove) ✓
For more course related material:
https://github.com/ashim888/dataStructureAndAlgorithm/
Personal blog
www.ashimlamichhane.com.np
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.
a. Concept and Definition✓
b. Inserting and Deleting nodes ✓
c. Linked implementation of a stack (PUSH/POP) ✓
d. Linked implementation of a queue (Insert/Remove) ✓
e. Circular List
• Stack as a circular list (PUSH/POP) ✓
• Queue as a circular list (Insert/Remove) ✓
f. Doubly Linked List (Insert/Remove) ✓
For more course related material:
https://github.com/ashim888/dataStructureAndAlgorithm/
Personal blog
www.ashimlamichhane.com.np
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
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
Elevating Tactical DDD Patterns Through Object CalisthenicsDorra BARTAGUIZ
After immersing yourself in the blue book and its red counterpart, attending DDD-focused conferences, and applying tactical patterns, you're left with a crucial question: How do I ensure my design is effective? Tactical patterns within Domain-Driven Design (DDD) serve as guiding principles for creating clear and manageable domain models. However, achieving success with these patterns requires additional guidance. Interestingly, we've observed that a set of constraints initially designed for training purposes remarkably aligns with effective pattern implementation, offering a more ‘mechanical’ approach. Let's explore together how Object Calisthenics can elevate the design of your tactical DDD patterns, offering concrete help for those venturing into DDD for the first time!
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
A tale of scale & speed: How the US Navy is enabling software delivery from l...sonjaschweigert1
Rapid and secure feature delivery is a goal across every application team and every branch of the DoD. The Navy’s DevSecOps platform, Party Barge, has achieved:
- Reduction in onboarding time from 5 weeks to 1 day
- Improved developer experience and productivity through actionable findings and reduction of false positives
- Maintenance of superior security standards and inherent policy enforcement with Authorization to Operate (ATO)
Development teams can ship efficiently and ensure applications are cyber ready for Navy Authorizing Officials (AOs). In this webinar, Sigma Defense and Anchore will give attendees a look behind the scenes and demo secure pipeline automation and security artifacts that speed up application ATO and time to production.
We will cover:
- How to remove silos in DevSecOps
- How to build efficient development pipeline roles and component templates
- How to deliver security artifacts that matter for ATO’s (SBOMs, vulnerability reports, and policy evidence)
- How to streamline operations with automated policy checks on container images
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
Climate Impact of Software Testing at Nordic Testing DaysKari Kakkonen
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
GridMate - End to end testing is a critical piece to ensure quality and avoid...ThomasParaiso2
End to end testing is a critical piece to ensure quality and avoid regressions. In this session, we share our journey building an E2E testing pipeline for GridMate components (LWC and Aura) using Cypress, JSForce, FakerJS…
GridMate - End to end testing is a critical piece to ensure quality and avoid...
Linked list
1. List
Objectives
• Describe a list
• How a list can be implemented by linked
structure
• Implement the various operations on
linked list
2. List
• List is homogeneous collection of
elements, with linear relationship
between the elements, the list can be
ordered or unordered.
• Implementing list
List can be implemented using
1. Linear array
2. Linked list
3. Array implementation of lists
• The linear array can be created at the compilation time by
using type declaration statement of type
int a[100];
• Which create linear array with 100 elements
• Since each elements takes two bytes of memory, the
compiler allocates 200 bytes for the array.
• The above array can be created at run time with the
following declaration statement
int *a;
a=(int*)malloc(100*sizeof(int));
In the above declaration, the malloc() function allocates 200
bytes of memory and assign the address of the first byte to
the pointer variable a.
4. Limitations of an array
• Insertion and deletion operations are
expensive.
• Inserting at first position requires first
pushing the entire array down by one
position to make room.
• Deleting the first element requires shifting
all the elements in the list one position up.
• So worst case of these operation is O(n).
• Size of the list must be known in advance.
5. Linked implementation of list
• To avoid the linear cost of insertion and deletion
operations, we need to ensure that the elements
of the list are not stored contiguously.
• Linked list basically consists of series of
structures, which are not necessarily adjacent in
memory
• Each structure contains an element of the list
and a pointer to structure containing its
successor.
• Linked implementation allow traverse and
search operations to be carried out in linear
time.
• Insertion and deletion operations can be
implemented efficiently as it requires only
rearrangement of pointers.
6. Linked list defined
A linked list is a linear collection of data
elements, called nodes, the linear order is
given by pointers. Each node is divided
into two or more parts. Linked list can be
of following types:
• Linear linked list or one way list
• Doubly linked list or two way list
• Circular linked list
• Header linked list
7. Linear linked list
In a linear linked list, also called singly linked list or one
way linked list, each node is divided into two parts.
• First parts contain the information of the element
• Second part called the linked field or next pointer field,
contains the address of the next node in the list.
head
1200 1201 1202 1203 X
Next pointer field of 2nd
node
Information field of second node
•head is used to hold the address of first element of the list.
•Last element of the linked list have NULL value in the next pointer field to mark the
end of the list
8. Representation of Linear linked
list
Suppose we want to store the list of integer numbers, then
the linear linked list can be represented in memory with
the following declarations.
typedef struct nodetype
{
int info;
struct nodetype *next;
}node;
node *head;
The above declaration define a new data type, whose each
element is of type nodetype and gives it a name node.
9. Operation on Linear linked lists
• Creating an empty list
• Traversing a list
• Searching an element
• Inserting an element
• Deleting an element
10. Creating an empty list
• In the previous declaration, the variable head is declared
as pointer to node data type.
• Variable head is not yet given a value.
• This variable is used to point to the first element of the
list
• Since the list will be empty in the beginning, the variable
head is assigned a sentinel value to indicate the list is
empty.
void createemptylist(node **head)
{
*head=NULL;
}
11. Traversing a list
Linear list can be traversed in two ways
• In order traversal
• Reverse order traversal
In order traversal:
To traverse the linear linked list, we move along the pointer, and
process each element till we reach the last element.
void traverseinorder(node *head)
{
while(head!=NULL)
{
printf(“%dn”,head->info);
head=head->next;
}
}
12. Traversing a list
Reverse order traversal:
To traverse the linear linked list in reverse order, we move along the
pointer till we reach the last element. The last element is processed
first, then the second last and so on and finally the first element of
the list
To implement this we use either stack (LIFO) or recursion.
Void traversereverseorder(node *head)
{
if(head->next!=NULL)
{
traversereverseorder(head->next);
printf(“%dn”,head->info);
}
}
13. Searching an element
• In linear linked list, only linear searching
is possible.
• This is one of the limitation of the linked
list as there is no way to find the location
of the middle element of the list
List can be
1. Sorted
2. Unsorted
14. Searching an element
List is unsorted:
We traverse the list from the beginning, and compare
each element of the list with the given element say
item to be searched.
node *searchunsortedlist(node *head, int item)
{
while((head!=NULL) &&(head->info!=item))
head=head->next;
return head;
}
15. Searching an element
List is sorted:
If the list is sorted say in ascending order then we traverse the list from
beginning and compare each element of list with item to be
searched. If the match occurs, the location of the element is
returned. If we reach the element that is greater than item or end of
the list NULL value is returned.
node *searchinsortedlist(node *head, int item)
{
while(head!=NULL)
{
if(head->info==item)
return head;
else if (item<head->info)
return NULL;
else
head=head->next;
}
return NULL;
}
16. Inserting an element
To insert an element in the list, the first task is to
get a free node, assign the element to be
inserted to the info field of the node, and then
new node is placed at the appropriate position
by adjusting the appropriate pointer. The
insertion in the list can take place at the
following positions:
• At the beginning of the list
• At the end of the list
• After a given element
17. Inserting an element
Insert at the beginning of the list:
First test whether the linked list is initially empty, if yes,
then the element is inserted as the first and only one
element by performing the following steps:
• Assign NULL value to the next pointer field of the new
node
• Assign address of new node to head
If the list is not empty, then the element is inserted as the
first element of the list by performing the following steps:
• Assign value of head variable to the next pointer field of
the new node.
• Assign address of the new node to the head.
18. Inserting an element
Insert at the beginning of the list:
Void insertatbegining(node **head,int item)
{
node *ptr;
ptr=(node*)malloc(sizeof(node));
ptr->info=item;
if(*head==NULL)
ptr->next=NULL;
else
ptr->next=*head;
*head=ptr;
}
19. Inserting an element
Inserting at the end of the list:
First test whether the linked list is initially empty, if yes,
then the element is inserted as the first and only one
element by performing the following steps:
• Assign NULL value to the next pointer field of the new
node
• Assign address of new node to head
If the list is not empty, then the list is traversed to reach the
last element, and then element is inserted as the last
element of the list by performing the following steps:
• Assign NULL value to the next pointer field of the new
node
• Assign address of the new node to the next pointer field
of the last node.
20. Inserting an element
Void insertatend(node **head, int item)
{
node *ptr, *loc;
ptr=(node*)malloc(sizeof(node));
ptr->info=item;
ptr->next=NULL;
if(*head==NULL)
*head=ptr;
else
{
loc=*head;
while (loc->next!=NULL)
loc=loc->next;
loc->next=ptr;
}
}
21. Inserting an element
Inserting after given element:
To insert the new element after the given element,
first we find the location, say loc, of the given
element in the list, and then the element is
inserted in the list by performing following steps:
• Assign the next pointer field of the node pointed
by loc to the next pointer field of the new node.
• Assign address of the new node to the next
pointer field of the node pointed by loc.
22. Inserting an element
Void insertafterelement(node *head, int item,int after)
{
node *ptr, *loc;
loc=search(head,after);
if(loc==(node*)NULL) /*element after not found*/
return;
ptr=(node*)malloc(sizeof(node));
ptr->info=item;
ptr->next=loc->next;
loc->next=ptr;
}
23. Deleting an element
• To delete an element from the list, first
the pointer are set properly and then the
memory occupied by the node to be
deleted is deallocated(free).
• The deletion in the list can take place at
the following positions.
1. At the beginning of the list
2. At the end of the list
3. After a given element
24. Deleting from the beginning of the
list
An element from the beginning of the lists can be
deleted by performing following steps:
• Assign the value of head ( address of the first
element of the list) to a temporary variable (say
ptr)
• Assign the value of the next pointer field of the
first node to head.
• Deallocate the memory occupied by the node
pointed to by ptr.
25. Deleting from the beginning of the
list
Void deletefrombegining( node **head)
{
node *ptr;
if(*head==NULL)
return;
else
{
ptr=*head;
*head=(*head)->next;
free(ptr);
}
}
26. Deleting from the end of the list
To delete from the end of the list, we first traverse
to the second last element of the list. Then the
last element can be deleted by performing
following steps:
• Assign the next pointer field of the second last
node to a temporary variable ( say ptr).
• Assign value NULL to the next pointer field of
the second last node of the list.
• Deallocate the memory occupied by the node
pointed to by ptr.
27. Deleting from the end of the listVoid deletefromend( node **head)
{
node *ptr,*loc;
if (*head==NULL)
return;
else if ((*head)->next==(node*) NULL)
{
ptr=*head;
*head=NULL;
free(ptr);
}
else
{
loc=*head;
ptr=(*head)->next;
while(ptr->next!=NULL)
{
loc=ptr;
ptr=ptr->next;
}
loc->next=NULL;
free(ptr);
}
}
28. Deleting after a given element
To delete an element after a given element, first
we find the location say (loc) of the element after
which the element can be deleted by performing
the following steps:
• Assign next pointer field of the node pointed by
the loc to temporary variable (say ptr).
• Assign the next pointer field of the node to be
deleted to the node pointed to by loc
• Deallocate the memory occupied by the node
pointed to by ptr.
29. Deleting after a given element
Void deleteafterelement( node*head, int after)
{
node *ptr, *loc;
loc=search(head,after);
if(loc==(node*)NULL) /*element ‘after’ not found*/
return;
ptr=loc->next;
loc->next=ptr->next;
free(ptr);
}
30. Deleting Entire list
Before the program terminates, the entire list must
be deletedso that the memory occupied by the
nodes of the list can be used for other purposes.
This task can be accomplished by performing
the following steps:
• Assign the head pointer to a temporary variable,
say ptr.
• Advance the head pointer to the next node.
• Deallocate the memory occupied by the node
pointed to by ptr.
The above steps are repeated till the entire list is
deleted.
32. Doubly Linked List
In doubly linked list, also called the two way list,
each node is divided into three parts:
• The first part called, previous pointer field,
contains the address of preceding element in the
list.
• The second part contains the information of the
list.
• The third part, called next pointer field, contains
the address of the succeeding element in the
list.
In addition, two pointer variables, e.g. head and
tail, are used that contains the address of first
element and the address of last element of the
list.
33. Doubly Linked List
head
X 1200 1201 1203 X
Next pointer field of 2nd
node
Information field of second node
tail
Previous pointer field of 2nd
node
34. Representation of doubly linked list
• Suppose we want to store list of integer.
typedef struct nodetype
{
struct nodetype *prev;
int info;
struct nodetype *next;
}node;
node *head,*tail;
The above declaration defines a new data type, whose
each element is of type nodetype and gives it name
node.
35. Operation on Doubly linked lists
• Creating an empty list
• Traversing a list
• Searching an element
• Inserting an element
• Deleting an element
36. Creating an Empty list
• In the previous declaration, the variable head and tail are
declared as pointer to a node data type.
• These Variables are not yet given a value.
• The head is used to point to the first element of the list
and tail is used to point to the last element of the list.
• Since the list will be empty in the beginning, the variable
head and tail are assigned a sentinel value to indicate
the list is empty.
void createemptylist(node **head, node **tail)
{
*head=*tail=NULL;
}
37. Traversing a list
Doubly linked list can be traversed in both way and that too very
conveniently.
• In order traversal
• Reverse order traversal
In order traversal:
To traverse the doubly linked list, we move along the pointer, and
process each element till we reach the last element.
void traverseinorder(node *head)
{
while(head!=NULL)
{
printf(“%dn”,head->info);
head=head->next;
}
}
38. Traversing a list
Reverse order traversal:
The following listing shows the various steps required for
traversing a doubly linked list in the backward direction.
Void traversereverseorder(node *tail)
{
if(tail!=NULL)
{
printf(“%dn”,tail->info);
tail=tail->prev;
}
}
39. Searching an element
The doubly linked list can be traversed in any order to
reach the given element. The following listing shows the
various steps required for searching an element from the
beginning.
node *search (node *head, int item)
{
while(head!=NULL)
{
if(head->info==item)
return head;
head=head->next;
}
return NULL;
}
40. Inserting an element
To insert an element in the list, the first task is to
get a free node, assign the element to be
inserted to the info field of the node, and then
new node is placed at the appropriate position
by adjusting the appropriate pointer. The
insertion in the list can take place at the
following positions:
• At the beginning of the list
• At the end of the list
• After a given element
• Before a given element
41. Inserting an element
Insert at the beginning of the list:
First test whether the linked list is initially empty, if yes, then the
element is inserted as the first and only one element by performing
the following steps:
• Assign NULL value to the next pointer and prev pointer field of the
new node
• Assign address of new node to head and tail pointer variables.
If the list is not empty, then the element is inserted as the first element
of the list by performing the following steps:
• Assign NULL value to the prev pointer field of the new node.
• Assign value of head variable (the address of the first element of the
existing list) to the next pointer field of the new node.
• Assign address of the new node to prev pointer field of the node
currently pointed by head variable, i. e. first element of the existing
list.
• Finally Assign address of the new node to the head variable.
42. Inserting an element
Insert at the beginning of the list:
Void insertatbegining (node **head, node **tail, int item)
{
node *ptr;
ptr=(node*)malloc(sizeof(node));
ptr->info=item;
if(*head==NULL)
ptr->next=ptr->prev=NULL;
*head=*tail=ptr;
else
{
ptr->prev=NULL;
ptr->next=*head;
(*head)->prev=ptr;
*head=ptr;
}
}
43. Inserting an element
Inserting at the end of the list
First test whether the linked list is initially empty, if yes, then the
element is inserted as the first and only one element by
performing the following steps:
• Assign NULL value to the next pointer and prev pointer field of
the new node
• Assign address of new node to head and tail pointer variable.
If the list is not empty, then element is inserted as the last element
of the list by performing the following steps:
• Assign NULL value to the next pointer field of the new node.
• Assign value of the tail variable (the address of the last element
of the existing list) to the prev pointer field of the new node.
• Assign address of the new node to the next pointer field of the
node currently pointed by tail variable i.e last element of the
existing list.
• Finally assign the address of the new node to tail variable.
44. Inserting an element
Insert at the end of the list:
Void insertatend (node **head, node **tail, int item)
{
node *ptr;
ptr=(node*)malloc(sizeof(node));
ptr->info=item;
if(*head==NULL)
ptr->next=ptr->prev=NULL;
*head=*tail=ptr;
else
{
ptr->next=NULL;
ptr->prev=*tail;
(*tail)->next=ptr;
*tail=ptr;
}
}
45. Inserting an element
Inserting after a given element:
Void insert afterelement (node *head, node **tail, int item, int after)
{
node *ptr, *loc;
ptr=head;
loc=search(ptr,after);
if(loc==NULL)
return;
ptr=(node*)malloc(sizeof(node));
ptr->info=item;
if(loc->next==NULL)
{
ptr->next=NULL;
loc->next=ptr;
ptr->prev=*tail;
*tail=ptr;
}
else
{
ptr->prev=loc;
ptr->next=loc->next;
(loc->next)->prev=ptr;
loc->next=ptr;
}
}
46. Inserting an element
Inserting before a given element:
Void insertbeforeelement (node **head, int item, int before)
{
node *ptr, *loc;
ptr=*head;
loc=search(ptr,before);
if(loc==NULL)
return;
ptr=(node*)malloc(sizeof(node));
ptr->info=item;
if(loc->prev==NULL)
{
ptr->prev=NULL;
loc->prev=ptr;
ptr->next=*head;
*head=ptr;
}
else
{
ptr->prev=loc->prev;
ptr->next=loc;
(loc->prev)->next=ptr;
loc->prev=ptr;
}
}
47. Deleting an element
• To delete an element from the list, first the
pointer are set properly and then the memory
occupied by the node to be deleted is
deallocated (freed).
• The deletion in the list can take place at the
following positions.
1.At the beginning of the list
2.At the end of the list
3.After a given element
4.Before a given element
48. Deleting an element
Deleting from the beginning of the list:
An element from the beginning of the lists can be
deleted by performing following steps:
• Assign the value of head ( address of the first
element of the list) to a temporary variable (say ptr)
• Further there are two cases:
1. If there is only one element in the existing list, both
head and tail variable are set to NULL.
2. If there are more than one element in the list then
following steps are given below:
– Assign NULL value to the prev pointer field of the second
node.
– Assign address of the second node to head.
3. Deallocate the memory occupied by the node pointed to by
ptr.
49. Deleting an element
Deleting from the beginning of the list:
Void deletefrombegining( node **head, node **tail)
{
node *ptr;
if(*head==NULL)
return;
ptr=*head;
if(*head==*tail) /*one element only*/
*head=*tail=NULL;
else
{
(ptr->next)->prev=NULL;
*head=ptr->next;
}
free(ptr);
}
50. Deleting an element
Deleting from the end of the list:
An element from the end of the list can be deleted by
performing following steps:
• Assign the value of tail ( address of the last element of
the list) to a temporary variable (say ptr)
• Further there are two cases:
1.If there is only one element in the existing list, both
head and tail variable are set to NULL.
2.If there are more than one element in the list then
following steps are given below:
– Assign NULL value to the next pointer field of the second
last node.
– Assign address of the second last node to tail.
3.Deallocate the memory occupied by the node pointed to by
ptr.
51. Deleting an element
Deleting from the end of the list:
Void deletefromend( node **head, node **tail)
{
node *ptr;
if(*head==NULL)
return;
ptr=*tail;
if(*head==*tail) /*one element only*/
*head=*tail=NULL;
else
{
(ptr->prev)->next=NULL;
*tail=ptr->prev;
}
free(ptr);
}
52. Deleting an element
Deleting after a given element:
Void ideleteafterelement (node *head, node **tail, int item, int after)
{
node *ptr, *loc;
ptr=head;
loc=search(ptr,after);
if(loc==NULL)
return;
else if((loc->next)->next==NULL)
{
ptr=loc->next;
loc->next=NULL;
*tail=loc;
free(ptr);
}
else
{
ptr=loc->next;
loc->next=ptr->next;
(ptr->next)->prev=loc;
free(ptr);
}
}
53. Deleting an element
Deleting before a given element:
Void ideleteafterelement (node **head, int item, int before)
{
node *ptr, *loc;
ptr=head;
loc=search(ptr,before);
if(loc==NULL)
return;
else if((loc->prev)->prev==NULL)
{
ptr=loc->prev;
loc->prev=NULL;
*head=loc;
free(ptr);
}
else
{
ptr=loc->prev;
loc->prev=ptr->prev;
(ptr->prev)->next=loc;
free(ptr);
}
}
54. Deleting entire list
The doubly linked list can be deleted either by
heading from the beginning or from the end.
The list can be deleted from the beginning by
performing the following steps:
• Assign the head pointer to a temporary
variable, say ptr.
• Advance the head pointer to the next node.
• Deallocate the memory occupied by the node
pointed to by ptr.
The above steps are repeated till the entire list
is deleted. Finally the tail pointer is set to
NULL value.
56. Circular Linked List
A circular list is a linear linked list, except that the
last element points to the first element. For non
empty circular linked list there are no NULL
pointer.
The memory declarations for representing circular
linked lists are the same as for linear linked lists
Properties:
• Can reach entire list from any node
• Need special test for end of list
• Used as buffer
57. Circular Linked List
• A Circular Linked List is a special type of
Linked List
• It supports traversing from the end of the
list to the beginning by making the last
node point back to the head of the list.
• Circular linked lists are usually sorted
• Circular linked lists are useful for playing
video and sound files in “looping” mode.
• They are also a stepping stone to
implementing graphs, an important topic in
computer graphics.
58. Representation of Circular linked
list
Suppose we want to store the list of integer numbers, then
the circular linked list can be represented in memory with
the following declarations.
typedef struct nodetype
{
int info;
struct nodetype *next;
}node;
node *head;
The above declaration define a new data type, whose each
element is of type nodetype and gives it a name node.
59. Circular Linked List
All operations performed on linear linked list can be easily
extended for circular linked lists with following
exceptions:
1. While inserting new node at the end of the lists, its
next pointer field is made to point to the first node.
2. While testing for the end of the lists, we compare the
next pointer field with the address of the first node.
head
1201 1234 1345
Circular Linked with 3 Nodes
60. Operation on Linear linked lists
• Creating an empty list
• Traversing a list
• Searching an element
• Inserting an element
• Deleting an element
61. Header Linked List
• A header list is a linked list, which
always contains a special node, called
header node, at the beginning of the
linked list.
• This header node usually contains
vital information about the linked list
such as the number of nodes in the list,
whether the list is sorted or not.
63. Header Linked List
Types of header linked list:
• Header linear linked list
• Circular header list
• Two way header list
• Two way circular header list
68. Applications of linked lists
• To implement the other data structures
such as stacks, queues, trees and graphs.
• To maintain a directory of names.
• To perform arithmetic operation on long
integers.
• To manipulate polynomial.
• To represent sparse matrices.
69. Polynomial Manipulation
A polynomial of type
4x3
+6x2
+10x+6
can be represented using following linked
list
4 3 6 2 10 1 6 0 X
Poly coefficient
power
In the above list, each node has the following structure
Coefficient of the term Power of x Link to the next node
70. Polynomial Manipulation
The required memory declarations for the
representation of a polynomial with integer
coefficients are
typedef struct nodetype
{
int coeff;
int power;
struct nodetype *next;
}node;
node *poly;
71. Examples
a x x= + +3 2 114 8
b x x x= − +8 3 1014 10 6
3 14 2 8 1 0
a
null
8 14 -3 10 10 6
b
null
Polynomial Representation: Example
72. Adding Polynomials: Figure 4:19 c = a + b
4.6.2 Adding Polynomials: c = a + b
Case 1: p->exp = q->exp
3 14 2 8 1 0
p
8 14 -3 10 10 6
q
11 14
a
b
c
73. Adding Polynomials : c = a + b (cont.)
Case 2: p->exp < q->exp
3 14 2 8 1 0
p
8 14 -3 10 10 6
q
11 14 -3 10
a
b
c
74. 3 14 2 8 1 0
p
8 14 -3 10 10 6
q
11 14 -3 10 2 8
Case 3: p->exp > q->exp
Adding Polynomials: c = a + b (cont.)
75. Representing sparse matrices
• inadequate of sequential schemes
(1) # of nonzero terms will vary after some matrix computation
(2) matrix just represents intermediate results
• new scheme
• Each column (row): a circular linked list with a head node
0 0 0 2 0 0
0 0 1 0 0 5
0 4 0 0 0 0
0 0 0 0 0 0
0 0 0 0 7 0
A 5X6 sparse matrices
76. Sparse Matrix
The description of this representation is as
• It contains one header node that has four fields….
--#of rows
--#of cols
--#of non zero elements
--head i.e. pointer to 1st
row containing at least one non zero element.
• A linked list of rows containing at least one non zero term, in the ascending
order of their row values. each node of this list has three fields
--row (row number for corresponding row list)
--next (pointer to next node in the row list)
--first (a pointer to first column in a row having non zero item)
• A linked list of columns containing nonzero terms, in the ascending order of
their column values. Each node of this list has three fields
--col (column number for corresponding row list)
--term ( a non zero value in column col)
--link (a pointer to next column having non zero element)
77. Sparse Matrix
5 6 5
1 4 2 X
2 3 1
3 2 4 X
5 X 5 7 X
6 5 X
A linked representation of sparse matrix
78. Required memory declaration
Structure of column node:
typedef struct columnnodetype
{
int col;
float element;
struct columnnodetype *link;
}columnnode;
80. Required memory declaration
Structure of header node:
typedef struct headernodetype
{
int nrow;
int ncol;
int num;
struct rownode *head;
}headernode;
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94. Linked list Problems
1. Write a function that return value 1 if the
linear linked list is sorted in the ascending
order otherwise it returns value 0.
2. Write a function that makes copies of
given linear linked list.
3. Write a function that merge two sorted
linear linked list.
4. Write a function that sorts a linear linked
list of integer values in the descending
order.
95. Josephus Problem
It consists of a group of soldiers surrounded by a heavy
enemy force. There is only one horse to escape.
Therefore, only one soldier can escape. In order to
determine which soldier will escape, they form a circle
and pick up a number n from a hat. A name is also
picked up from the hat. They start counting clockwise
around the circle from a soldier whose name is picked up
from the hat. And the soldier on which count reaches n
is removed from the circle. And the count again starts
from the soldier who was next to the soldier who is
removed from the circle. This process goes on till only
one soldier is left. This soldier will take the horse and
escapes. Write a program to solve this problem. Input to
your program is list of names of soldiers and number n
and the output should be the name of the soldier left.