Meljun Cortes Data Structures Linked Lists

Data Structures

Linked Lists

� certain class of lists may be represented using

arrays

� Lists that are fixed in length.

� Lists that do not require a considerable

amount of insertion and deletion operations

� first criterion is the fact that arrays cannot

dynamically alter their size once they have

been defined

Linked Lists * Property of STI of 38

been defined

� representing such kind of linear lists is the

linked list

� Two types of linked lists

� Singly linked list

� Doubly linked list

Data Structures

� basic format of a node

� data field or simply data is used to contain the

value of the element

� pointer field, link, or simply, reference, contains

the address of the next node in the list of a

computer memory

Singly-linked list


� All references are the same size no matter what

they refer in a given computer/operating system

� The "Next Node" in the list is called the

SUCCESSOR

Data Structures

� Head – first node in the list contains the “Martin”

� There is no limit to the size of a singly-linked list

� Adding a node to a linked list is simply a matter

Singly-linked list

Singly-linked list with 4 nodes


� Adding a node to a linked list is simply a matter

of:

� Creating a new node.

� Setting the data field of the new node to the

value to be inserted into the list.

� Assigning the address of the new node to

the pointer field of the current last node in

the list.

� Setting the pointer field of the new node to

NULL.

Data Structures

� Common operations

� Insert - usually inserted at the beginning of

the list

� Search - moves along the list searching for

the specified value then prompts you the

address of the node

� Delete – search for the value and delete the

data then connects the arrow from the

previous link straight across to the following

Singly-linked list


previous link straight across to the following

link

Data Structures

� Algorithm for basic operations

1. Inserting an item at the beginning of the list

� make a new link

� set a new link to the old first

� set first to new link

public void insertFirst(int id,

dd)

{

Singly-linked list


{

Link newLink = new Link(id,

dd);

newLink.next = first;

first = newLink;

}

Data Structures

2. Deleting an item at the beginning of the list

� save reference to link

� delete it, set first to old next

� return deleted link

public deleteFirst()

{

Link temp = first;

Singly-linked list


Link temp = first;

first = first.next;

return temp;

}

Data Structures

� display the entire list, start at first and follow the

chain of references from link to link

� start at the beginning of last until end of list

� print data

� move to next link

public displayList()

{

Singly-linked list


System.out.print(″List (first ��

last): ″); //optional

Link current = first;

while(current != null)

{

current.displayLink();

current = current.next;

}

System.out.println(″″); //optional

}

Data Structures

Singly-linked list

� Finding Specified Links

� Algorithm to find a specific link in a list assuming a non-empty list

� start at the first while no match

� if end of list, didn’t find it

� not end of list, go to the next link

� found it

public Link find(int key)

{


{


while(current.iData != key) // iData refers to integer data item declared in the class

{

if(current.next == null)

return null;

else


}

return current;

}

Data Structures

Singly-linked list

� Finding Specified Links

� algorithm of deleting a link assuming a non-empty list

� search for link

� if not found, go to next link

� found it

� if first link, change first

� otherwise, bypass it

public Link delete(int key)

{



Link previous = first;

while(current.iData != key)

{

if(current.next == null)

return null;

else

{

previous = current;


}

}

if(current == first)

first = first.next;

else

previous.next = current.next;

return current;

}

Data Structures

Singly-linked list

� other operations you can perform in a singly-linked list

� Finding the length of the list, Reading the list from left-to-right

� Retrieving the ith node in the list, where i≤n

� Storing a new value into the ith position,

where i≤n

� Inserting a new node at position i, where i≤n

� Deleting the ith element, where i≤n

� Copying a list


� Copying a list

� Sorting the nodes in the list

� Merging two or more lists

� Splitting a list into several sublists

� The following notation will be used for the purpose of this discussion:

� Pointer_Value → Node.Data -

References the Data field of the node whose address is Pointer_Value

� Pointer_Value → Node.Pointer -

References the Pointer field of the node whose address is Pointer_Value

Data Structures

� Finding the length of the list, Reading the list from left-to-right

� the only way to determine how many nodes

are contained in the list is to traverse it

� the list must be read

� Retrieving the ith node in the list, where i≤≤≤≤n

� the list must be traversed until it reaches the

desired node

Singly-linked list


desired node

� Storing a new value into the ith position, where i≤≤≤≤n

� must be traversed

� storing a new value simply requires

overwriting the data field of the node

� simple modification of retrieving a node

Data Structures

Singly-linked list

� Inserting a Node in a Singly-Linked List

� general procedure for inserting a new node at a certain position in a singly-linked list

1. Create a new node for the element.

2. Set the data field of the new node to the

value to be inserted.

3. Insert the node.

� three locations in which a node may be


� three locations in which a node may be

inserted

1. Insert the node at the start of the list

(i=1)

2. Insert the node at the end of the list

(i>length of the list)

3. Insert the node at position i, where

1<i<length of list

Data Structures

� Inserting a Node at the Start of a Singly-Linked List (i=1)

� step 3 of the general procedure includes the

following operations

1. Set the pointer field of the new node to

the value of HEAD when the HEAD

points to the current first node in the list

2. Set HEAD to the address of the new

node

Singly-linked list


node

Singly-linked list after inserting “Ken”

Singly-linked list after reassigning HEAD

Data Structures

� Inserting a Node at the End of a Singly-Linked List (i>Length of List)


following operations

1. Set the pointer field of the current last

node to the address of the new node

when the pointer field of the current last

node contains NULL.


Singly-linked list



NULL

Singly-linked list after inserting “Ken” at the end

Data Structures

� Inserting a Node at Position i (1<i<Length of List)


following operations:

1. Locate the node at position i-1.


the value of the pointer field of node i-1.

3. Set the pointer field of node i-1 to the

address of the new node.

Singly-linked list


address of the new node.

Singly-linked list after setting the pointer field of “Ken”

Data Structures

� Inserting a Node at Position i (1<i<Length of List) (cont..)

Singly-linked list

Singly-linked list after inserting “Ken” at position 3


Singly-linked list after setting the pointer field of “Ken”

Singly-linked list after setting the pointer field of “Brando”

Data Structures

Singly-linked list

� Insertion using the “Tail”

1. Create a new node for the element.

2. Set the data field of the new node to the


3. Set the pointer field of the new node to the

value of NULL.

4. Set the pointer field of the node referenced

by TAIL to the address of the new node.

5. Set TAIL to the address of the new node.


5. Set TAIL to the address of the new node.

Singly-linked list with HEAD and TAIL pointers

Data Structures

Singly-linked list

List after setting the pointer field of “Brando”

List after setting TAIL


public insertEnd (Tail, New_Value)

{

Create new node

Set Address of New Node →→→→

Node.Data to New_Value

Set Address of New Node →→→→

Node.Pointer to NULL

Set Tail→→→→ Node.Pointer to Address of New Node

Set Tail to Address of New Node

}

List after setting TAIL

Data Structures

Singly-linked list

� Deleting a Node from a Singly-Linked List

� By Position

� By Value

� make the following assumptions

� The singly-linked list has a length

of n nodes.

� The node to be deleted is at

position i, where 1≤i≤n

� summarized as follows


� summarized as follows

� Locate the node i.

� Delete the node.

� This step may be further

subdivided into two (2) separate

cases:

1. If the node i is at the HEAD of

the list (i=1).

2. If node i is not the HEAD of

the list (1<i≤n).

� Release the node from memory.

Data Structures

Singly-linked list

� Deleting the Node at the Head of the List (i = 1)

1. Set the variable HEAD to the address

contained in the pointer field of the node to

be deleted.


Singly-linked list after deleting “Anna”

Data Structures

Singly-linked list

� Deleting a Node NOT at the Head of the List(1<i≤≤≤≤n)

� Locate the preceding node (i-1).

� Set the pointer field of the preceding node

(i-1) to the value in the pointer field of the

node to be deleted.


Singly-linked list after deleting “Delia”

Singly-linked list after deleting “Brando”

Data Structures

Singly-linked list

� Releasing the Node from Memory


Memory Allocation of 3 nodes

Data Structures

Doubly-Linked List

� data field and the right pointer field function in

the same manner as in singly-linked lists

� left pointer field is used to contain the address

of the preceding node in the list or what is

known as the PREDECESSOR

Format of a Doubly-linked list


Doubly-linked list with 3 nodes

Data Structures

Doubly-Linked List

� Traversal Operation

� displayBackward() algorithm

� start at end

� until starts of list

� display data

� move to previous link

link current = last;


while(current != null)

current = current.previous;

{

current.displayLink();

current = current.previous;

Data Structures

Doubly-Linked List

� Insertion Methods

� insertLast() method algorithm

� make a new link

� if empty list

� first � newLink

� old last � newLink

� old last newLink

� newLink last

public void insertLast(double dd)


public void insertLast(double dd)

{

Link newLink = newLink(dd);

if( isEmpty() )

first = newLink;

else

{

last.next = newLink;

newLink.previous = last;

}

last = newLink;

}

Data Structures

Doubly-Linked List

� insertAfter() method algorithm

� start at beginning

� until match is found, move to next link

� not found, return false

� make a new link

� if last link

� newLink � null

� newLink last


� else not last link

� newLink � old next

� newLink old next

� old current newLink

� old current �newLink

� when found – insertion done

Data Structures

Doubly-Linked List

public Boolean insertAfter(double key, double dd)

{

Link current = firstl

while(current.dData != key)

{


if(current == null)

Return false;

}

Link newLink = new Link(dd);


Link newLink = new Link(dd);

if(current == last)

{

newLink.next = null;

last = newLink;

}

else

{

newLink.next = current.next;

current.next.previous = newLink;

}

newLink.previous = current;

current.next = newLink;

return true;

}

Data Structures

Doubly-Linked List

� deleteKey() method algorithm

� first item?

� first � old next

� not first

� old previous � old next

� last item?

� old previous last

� not last


� old previous old next

if(current==first)

first = current.next;

else

current.previous.next =

current.next;

if(current==last)

last = current.previous;

else

current.next.previous =

current.previous;

Data Structures

Doubly-Linked List

� Inserting a Node into a Doubly-Linked List

� general procedure

� Create a new node for the element.

� Set the data field of the new node to the


� Determine the position of the node in

the list based on its value.

� Insert the node.


Doubly-linked list with 3 nodes

Data Structures

Doubly-Linked List

� Inserting a Node at the Head of the List

New node after setting the left pointer field


Doubly-linked list after setting the new node’s right pointer field

Data Structures

Doubly-Linked List

� Inserting a Node at the Head of the List (cont..)

Doubly-linked list after setting left pointer field of HEAD node


Doubly-linked list after reassigning HEAD

Data Structures

Doubly-Linked List

� Insert a Node at the End of a List

New node after setting the right pointer field


Doubly-linked list after setting the new node’s left pointer field

Data Structures

Doubly-Linked List

� Insert a Node at the End of a List (cont..)

Doubly-linked list after setting right pointer field of TAIL node


Doubly-linked list after reassigning TAIL

Data Structures

Doubly-Linked List

� Inserting a Node Within the List

New node


Doubly-linked list after setting the new node’s left pointer field

Doubly-linked list after setting the new node’s right pointer field

Data Structures

Doubly-Linked List

� Inserting a Node Within the List (cont..)

Doubly-linked list after setting the right pointer field of node


Doubly-linked list after setting the right pointer field of node

Doubly-linked list setting the left pointer field of displaced node

Data Structures

Doubly-Linked List

� Deleting a Node from a Doubly-Linked List

� exactly the same as the steps in deleting a node from a singly-linked list

� Locate the node.

� Delete the node.

� Release the node from memory.

� Deleting the Node at the Head of the List


Doubly-linked list after reassigning HEAD

Doubly-linked list setting the left pointer field of node “D”

Data Structures

Doubly-Linked List

� Deleting a Node from Within the List

Doubly-linked list setting the right pointer field of node “B”


Doubly-linked list setting the right pointer field of node “B”

Doubly-linked list setting the left pointer field of node “E”

Data Structures

Exercise

� Create a two element linked list where the

nodes have string values "red" and "green".

The variable head references the node "red".

The process begins by declaring three Node

reference variables head, p, and q.


Meljun Cortes Data Structures Linked Lists

Documents

Transcript of Meljun Cortes Data Structures Linked Lists