Scribd
Upload
25 views

Doubly Linked Lists: MTS3023 - Data Structures

Doubly linked lists allow traversal in both directions by including "left" and "right" pointers in each node. FindItem searches the list and returns the location of a matching item and whether it was found. InsertItem inserts a new node before the found location, updating left and right pointers as needed. Special cases for insertion at the head or end of the list are handled separately. Headers and trailers simplify the implementation by avoiding special cases for the first and last nodes. Linked lists can also represent arrays of records without dynamic allocation by storing nodes in a static array. Large integers can be represented using a list ADT where each node holds a digit.

Uploaded by

azray
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
25 views

Doubly Linked Lists: MTS3023 - Data Structures

Doubly linked lists allow traversal in both directions by including "left" and "right" pointers in each node. FindItem searches the list and returns the location of a matching item and whether it was found. InsertItem inserts a new node before the found location, updating left and right pointers as needed. Special cases for insertion at the head or end of the list are handled separately. Headers and trailers simplify the implementation by avoiding special cases for the first and last nodes. Linked lists can also represent arrays of records without dynamic allocation by storing nodes in a static array. Large integers can be represented using a list ADT where each node holds a digit.

Uploaded by

azray
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 20

Doubly Linked Lists

MTS3023 -Data Structures


Node data
 data: the user's data
 right, left: the address of the next
and previous node in the list

right Data left


Node data
struct Node {
string data;
struct Node *right;
struct Node *left;
};
Finding a List Item
 We no longer need to use prevLocation
(we can get the predecessor of a node
using its back member)

Headptr
Finding a List Item (cont.)

Headptr
Inserting into a Doubly Linked
List

1. newNode->right = location->right; 3. location->right->left=newNode;


2. newNode->left= location 4. location->right = newNode;
FindItem(listData, item, location,
found)
 RetrieveItem, InsertItem, and DeleteItem
all require a search

 Write a general non-member function


FindItem that takes item as a parameter and
returns location and found.

 InsertItem and DeleteItem need location


(ignore found)

 RetrieveItem needs found (ignores location)


Headptr

Headptr

Headptr

If(location->left != NULL)
location = location->left
Finding a List Item (cont.)
void FindItem( Node* listData, string item,
struct Node *&location, bool &found)
{
// precondition: list is not empty

bool moreToSearch = true;


else {
location = listData;
if(location->left== NULL)
found = false;
moreToSearch = false;
while( moreToSearch && !found) { else
location = location->left;
if(item < location->data) }
moreToSearch = false; }
else if(item == location->data) }
found = true;
How can we distinguish between
the following two cases?
Headptr

Headptr
Special case: inserting in the
beginning
Headptr
Inserting into a Doubly
Linked List
void InsertItem(string item)
{
Headptr
struct Node *newNode;
struct Node *location;
bool found;
newNode = new Node;
newNode->data = item;
if (listData != NULL) {
FindItem(listData, item, location, found);
if (location->data > item) {
newNode->right = location->right; else
newNode->left = location; headptr = newNode; (3)
(4)
(1) location->back = newNode;
if (location != headptr) // special case
(location->right)->left = newNode; } Headptr

(2)

(3)
Inserting into a Doubly Linked
List
else { // insert at the end
newNode->right = location;
location->left= newNode;
newNode->left = NULL;
}
}
else { // insert into an empty list
listData = newNode;
newNode->left = NULL; Headptr

newNode->right = NULL;
}
length++;
}
Deleting from a Doubly Linked
List

Headptr

 Be careful about the end cases!!


Headers and Trailers
 Special cases arise when we are dealing
with the first or last nodes
 How can we simplify the
implementation?
◦ Idea: make sure that we never insert or
delete the ends of the list
◦ How? Set up dummy nodes with values
outside of the range of possible values
Headers and Trailers (cont.)

 Header Node: contains a value smaller


than any possible list element
 Trailer Node: contains a value larger
than any possible list element

Headptr
A linked list as
an array of records
 What are the advantages of using
linked lists?
(1) Dynamic memory allocation
(2) Efficient insertion-deletion (for sorted
lists)
 Can we implement a linked list without
dynamic memory allocation ?
A linked
list as an
array of
records
(cont.)
Case Study: Implementing a
large integer ADT
 The range of integer values varies from
one computer to another
 For long integers, the range is
[-2,147,483,648 to 2,147,483,647]
 How can we manipulate larger integers?
Case Study: Implementing a
large integer ADT (cont.)

- A special list ADT

You might also like