mit – 594 data structures and algorithms masters of information technology ms. marife s. edu

MIT – 594 Data Structures and AlgorithmsMasters of Information Technology

Ms. Marife S. Edu

Consists of a sequence of nodes each containing arbitrary data fields and one or two references (“links”) pointing to the next and/or previous nodes.

The order of the linked items may be different from the order that the data items are stored in memory or on disk, allowing the list of items to be traversed in a different order.

Self-referential data type because it contains a pointer or link to another datum of the same type.

Permits insertion and removal of nodes at any point in the list in constant time, but do not allow random access.

Types: Singly-linked lists, Doubly-linked lists, and Circularly-linked lists

Linked list can be implemented in most languages.

Languages such as Lisp and Scheme have the data structure built in, along with operations access the linked list.

Procedural or object oriented languages such as C, C++, and Java typically rely on mutable references to create linked list

Developed in 1955-56 by Allen Newell, Cliff Shaw and Herbert Simon at RAND Corporation as the primary data structure for their Information Processing Language (IPL).

IPL was used by the authors to develop several early artificial intelligence programs, including the Logic Theory Machine, the General Problem Solver, and a computer chess program.

Reports on their work appeared in IRE Transactions on Information Theory in 1956, and several conference proceedings from 1957-1959, including Proceedings of the Western Joint Computer Conference in 1957 and 1958, and Information Processing (Proceedings of the first UNESCO International Conference on Information Processing) in 1959.

The now-diagram consisting of blocks representing list nodes with arrows pointing to successive list nodes appear in “Programming the Logic Theory Machine” by Newell and Shaw in Proc. WJCC, February 1957.

The problem of machine translation for natural language processing led Victor Yngve at Massachussets Institute of Technology (MIT) to use linked list as data structures in his COMIT programming language for computer research in the field of linguistics.

LISP, standing for list processor, was created by John McCarthy in 1958 while he was at MIT and in 1960 he published its design in a paper in the Communications of the ACM, entitled “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part 1”. One of LISP’s major data structures is the Linked List.

Singly – Linked Lists Doubly – Linked Lists

or slist for short The simplest kind of linked list Has one line per node This link points to the next node in the list, or to

a null value or empty list if it is the final node. Containing two values: the value of the current

node and a link to the next node The first part holds or points to information

about the node, and the second part holds the address of the next node.

Travels one way

Data Pointer

Figure 1: Node

Data field Pointer field

First node in the list

Last node in the list

Next node in the list

Goldilocks

05H

Figure 2: Singly Linked List with 4 Nodes

HEAD

01H 05H 03H

Papa Bear

03HMama Bear

20HBaby Bear

Null

20H

There is no limit to the size of a singly-linked list. Adding a nodes to a linked list is simply a matter of:

1.Creating a new node2.Setting the data field of the new node to the

value to be inserted into the list.3.Assigning the address of the new node to the

pointer field of the current last node in the list.4.Setting the pointer field of the new node to NULL.

The only way to determine how many nodes are contained in the list is to traverse it.

This means that we will have to “read” the list.

It is only possible to read a singly-linked list from left to right die to the order of the addresses stored in the pointer field.

The following psuedocode accepts as input a variable named Head which contains the address of the first node in the list.

Pointer_Value Node.Data - Reference the Data field of the node whose address is Pointer_Value

Pointer_Value Node.Pointer - Reference the Pointer field of the node whose address is Pointer_Value

Read_List(Head){

If(Head = NULL) then{

Print “The list is empty”Exit

}

Set Num_Nodes to 1Set Next_Node to Head Node.Pointer /* Get the address of the next node */

Print Head Node.Data /* Print contents of Data Field*/

While(Next_Node is not NULL){Increment Num_NodesPrint Next_Node Node.DataSet Next_Node to Next_Node Node.Pointer }Print “”Print “The number of nodes in the list is” Num_Nodes

}

Philip 09H

To simulate the Read_List pseudocode.HEAD

05H

James of Zebedee

02H John 04H Peter 06H

09H 02H 04H

Bartholomew 21H

06H

Matthew 31H

21H

James 27H Thaddeus 15H

Simon 18H

31H 27H

15H 18H

Andrew 22H Thomas 25H

22H 25H

JudasNULL

Figure 3. Singly-linked list with 12 nodes

Num_Nodes = 1Next_Node = address of “James of Zebedee” (09H)Print “Philip”While Loop: 1st IterationNum_Nodes = 2Print “James of Zebedee”Next_Node = address of “John” (02H)While Loop: 2nd IterationNum_Nodes = 3Print “John”Next_Node = address of “Peter” (04H)While Loop: 3rd IterationNum_Nodes = 4Print “Peter”Next_Node = address of “Bartholomew” (06H)While Loop: 4th IterationNum_Nodes = 5Print “Bartholomew”Next_Node = address of “Matthew” (21H)

While Loop: 5th IterationNum_Nodes = 6Print “Matthew”Next_Node = address of “James” (31H)While Loop: 6th IterationNum_Nodes = 7Print “James”Next_Node = address of “Thaddeus” (27H)While Loop: 7th IterationNum_Nodes = 8Print “Thaddeus”Next_Node = address of “Simon” (15H)While Loop: 8th IterationNum_Nodes = 9Print “Simon”Next_Node = address of “Andrew” (18H)

While Loop: 9th IterationNum_Nodes = 10Print “Andrew”Next_Node = address of “Thomas” (22H)While Loop: 10th IterationNum_Nodes = 11Print “Thomas”Next_Node = address of “Judas” (25H)While Loop: 11th IterationNum_Nodes = 12Print “Judas”Next_Node = NULL

Print “”Print “The number of nodes in the list is 12”

SUMMARY of OUTPUT

PhilipJames of ZebedeeJohnPeterBartholomewMatthewJamesThaddeusSimonAndrewThomasJudas

The number of nodes in the list is 12

To retrieve a specific element in a singly linked list, we would have to traverse the list until we reach desired node.

Retrieve_Node(Head, Node_Num){

If (Head = NULL) then /* the list is empty */

{

Print “Error: The list is empty”Exit

}

Set I to 1Set Next_Node to HeadWhile ((Next_Node is not NULL) AND (I < Node_Num)){

Increment ISet Next_Node to Next_Node Node.Pointer

}

If (Next_Node = NULL) then{

Print “Error: Element number exceeds length of list”

}

Else{

Print Next_Node Node.Data

}

}

Figure 4. Algorithm for Retrieving the ith Element In A Singly Linked List

To simulate the Retrieve_Node algorithm, let us try to retrieve the 3rd node in the list presented in Figure 3.

I = 1Next_Node = address of “Philip” (05H)

While Loop: 1st IterationI = 2Next_Node = address of “James of Zebedee” (09H)

While Loop: 2nd IterationI = 3Next_Node = address of “John” (02H)

/* Else Clause: Next_Node is NOT NULL */Print “John”

As with the previous algorithm, in order to store a new value into a specific element in a singly-linked list, we would have to traverse the list until we reach desired node.

The procedure accepts as input the address of the Head node – Head, the number of the node to be modified – Node_Num, and the new value to be stored into the node – New Value.

Store_Value(Head, Node_Num, New_Value){

If (Head = NULL) then /* the list is empty */

{

Print “Error: The list is empty”Exit

}

Set I to 1Set Next_Node to HeadWhile ((Next_Node is not NULL) AND (I < Node_Num)){

Increment ISet Next_Node to Next_Node Node.Pointer

}

If (Next_Node = NULL) then{

Print “Error: Element number exceeds length of list”

}

Else{

Set Next_Node Node.Data to New_Value

}

}

Figure 5. Algorithm for Storing A New Value Into the ith Node In A Singly Linked List

To simulate the algorithm we will once again use the list in Figure 3. Let us assume that the data field of the 4th node will be modified from “Peter” to “The Rock”

I = 1Next_Node = address of “Philip” (05H)While Loop: 1st IterationI = 2Next_Node = address of “James of Zebedee” (09H)While Loop: 2nd IterationI = 3Next_Node = address of “John” (02H)While Loop: 3rd IterationI = 4Next_Node = address of “Peter” (04H)/*Else Clause: Next Node is NOT NULL */

Data Field of node 4 = “The Rock”

Philip 09H

HEAD

05H

James of Zebedee

02H John 04H The Rock 06H

09H 02H 04H

Bartholomew 21H

06H

Matthew 31H

21H

James 27H Thaddeus 15H

Simon 18H

31H 27H

15H 18H

Andrew 22H Thomas 25H

22H 25H

JudasNULL

Figure 6. Singly-linked After Replacing “Peter” with “The Rock”

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 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 of the list (i <

length of the list)

Set the pointer field of the new node to the value of HEAD

Set HEAD to the address of the new node.

Suppose that we would like to insert “Voltes V” at the beginning of the following list

Daimos 10HHEAD

20H

Mazinger Z 05H VoltronNULL

10H 05H

Figure 7. Singly-linked With 3 nodes

Voltes V

30H

Figure 8. New Created Node “Voltes V”

In the next step, we set the pointer field of the node “Voltes V” to the address contained in the variable HEAD. This will effectively link “Voltes V” to “Daimos”.

Set Address of New Node Node.Pointer to Head

Daimos 10H

HEAD

20H


10H 05H

Voltes V 20H

30H

Figure 9. Singly-Linked list after inserting “Voltes V”

Daimos 10H

HEAD

20H


10H 05H

Voltes V 20H

30H

Figure 10. Singly-Linked list after Reassigning HEAD

Set HEAD to Address of New Node

The Final linked list will look like the diagram below

Set the pointer field of the current last node to the address of the new node.

Set the pointer field of the new node to NULL.

For example, let us suppose that we would like to insert “Voltes V” at the end of the list.

Set Address of “Voltron” Node.Pointer to Address of New Node

Set the pointer field of “Voltes V” to NULL. This will signal that “Voltes V is the new last node in list”

Set Address of New Node Node.Pointer to NULL

Daimos 10H

HEAD

20H

Mazinger Z 05H Voltron 30H

10H 05H

Voltes VNULL

30H

Figure 11. Singly-Linked list after Inserting “Voltes V” At The End

The Resulting linked list

Locate the node at position i –1 Set the pointer field of the new node to the

value of the pointer field of node i –1 Set the pointer field of node i –1 to the

address of the new node.

Suppose that we would like “Voltes V” to be the 3rd node in our list. Once again perform the first two steps of our general procedure and create the new node. The next step requires us to locate the node at position i –1.

Since i = 3, this means that we are interested in node 2 which is “Mazinger Z”. We will then set the pointer field of “Voltes V” to the contents of the pointer field of “Mazinger Z”.

Set Address of New Node Node.Pointer to Address of “Mazinger Z” Node.Pointer

Daimos 10H

HEAD

20H


10H 05H

Voltes V 05H

30H

Figure 12. Singly-Linked list after Setting the Pointer Field of “Voltes V”

As can be seen in the figure, the last step causes both “Voltes V” and “Mazinger Z” to point to “Voltron”. In the next step, we set the pointer field of “Mazinger Z” to the address of “Voltes V”. Set Address of “Mazinger Z” Node.Pointer to Address of sNew Node

Daimos 10H

HEAD

20H


10H 05H

Voltes V 05H

30H

Figure 13. Singly-Linked list after Inserting “Voltes V” At Position 3

Head – The address of the first node in the list

I – The position where the new node will be inserted

New_Value – the new value to be inserted into the list

Insert_Node(Head, I, New_Value){

Create New NodeSet Address of New_Node Node.Data to New_Value

If (I = 1) then /* Insert New Node at start of list */{

Set Address of New Node Node.Pointer to Head

Set Head to Address of New Node

Exit

}

Decrement I

Set Ctr to 1

Set Next Node to Head

While ((Ctr < 1) AND (Next_Node is not NULL)) /* Locate i –1 */

{

Increment CtrSet Last_Node to Next_Node /* Store address of the previous node */

Set Next_Node to Next_Node Node.Pointer}

If (Next_Node is NULL) then /* Insert New Node at end of list */{

Set Last_Node Node.Pointer to Address of New Node

Set Address of New_Node Node.Pointer to NULL

}

Else /* Node i –1 has been found */

{

Set Address of New Node Node.Pointer to Next_Node Node.Pointer

Set Next_Node Node.Pointer to Address of New Node

}

}

1. Insert the node “Voltes V” at the start of the listInput the Insert_Node: (Address of “Daimos”, 1, “Voltes V”)

Create node for “Voltes V”

Address of “Voltes V” Node.Data = “Voltes V”

Voltes V

30H

Result of Statements

/* First IF Statement */

Address of “Voltes V” Node.Pointer = Address of “Daimos”

Head = Address of “Voltes V”

2. Insert the node “Voltes V” at the end of the listInput the Insert_Node: (Address of “Daimos”, 9999, “Voltes V”)

Create node for “Voltes V”

Address of “Voltes V” Node.Data = “Voltes V”

Voltes V

30H


I = 9998

Ctr = 1

Next_Node = Address of “Daimos”

While Loop: 1st Iteration

Ctr = 2

Last _Node = Address of “Daimos”

Next_Node = Address of “Mazinger Z”

While Loop: 2nd Iteration

Ctr = 3

Last _Node = Address of “Mazinger Z”

Next_Node = Address of “Voltron”

While Loop: 3rd Iteration

Ctr = 4

Last _Node = Address of “Voltron”

Next_Node = NULL

/* Second IF Statement */

Address of “Voltron” Node.Pointer = Address of “Voltes V”

Address of “Voltes V” Node.Pointer = NULL

Daimos 10H

HEAD

20H


10H 05H

Voltes VNULL

30H


There are some applications that frequently insert nodes at the end if the linked list. To eliminate the amount of time wasted traversing the list each time a new node is added, a variable can be created to hold the address of the current last node. Let us call this variable TAIL.

Create a new node for the element Set the data field of the new node to the

value to be inserted Set the pointer field of the new node to the

value of NULL Set the pointer field of the node referenced

by TAIL to the address of the new node Set TAIL to the address of the new node

Create a new node Set the data field of the new node to the

value to be insertedSet Address of New Node Node.Data to “Voltes V”

Set the pointer field of the new node to the value of NULL


Set the pointer field of the node referenced by TAIL to the address of the new node

Set Address of “Voltron” Node.Pointer to address of New Node

Daimos 10H

HEAD

20H


10H 05H

Voltes VNULL

30H

Figure 14. Singly-Linked list after setting The Pointer Field of “Voltron”

Set TAIL to the address of the new nodeSet TAIL to the Address of New Node

Daimos 10H

HEAD

20H


10H 05H

Voltes VNULL

30H

TAIL

Figure 15. Singly-Linked list after setting The TAIL

Insert_End(Tail, New_Value){

Create New NodeSet Address of New Node Node.Data to New_Value


Set TAIL Node.Pointer to Address of New Node

Set TAIL to Address of New Node

}

The following is the corresponding pseudocode that inserts a node at the end of a singly-linked list with the use of the variable TAIL. It accepts as input the address of the last node in the list – Tail, and the value to be inserted into the list – New_Value.

Figure 16. Algorithm for Inserting A Node At the End of A Singly-Linked List Using TAIL

Input to Insert_End(Address of “Voltron”, “Voltes V”)

Create a node for “Voltes V” Address of “Voltes V” Node.Data = “Voltes V” Address of “Voltes V” Node.Pointer = NULL

Voltes V

30H


Address of “Voltron” Node.Pointer = Address of “Voltes V”


Daimos 10H

HEAD

20H


10H 05H

Voltes VNULL

30H

TAIL

Tail = Address of “Voltes V”


Daimos 10H

HEAD

20H


10H 05H

Voltes VNULL

30H

TAIL

By Position – The position of the node with respect to the start of the list is specified

By Value – The contents of the data field of the node is identified. This method may only be used if the nodes in the list are unique.

Assumptions: 1. The singly-linked list has a length of n nodes2. The node to be deleted is at position i, where 1 < i < n

Locate the node i Delete the node

This step may be further subdivided into two separate classes

a. if the node i is at the HEAD of the list (i = 1)b. if the node i is not at the HEAD of the list ( 1 < i <

n)

Release the node from memory

Set the variable HEAD to the address contained in the pointer field of the node to be deleted.

Set HEAD to HEAD Node.Pointer

HEAD


10H 05H

Figure 17. Singly-Linked List After Deleting “Daimos”

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.

Daimos 10H

HEAD

20H


10H 05H

Deleted the node “Mazinger Z” which is at position 2.

Set Address of “Daimos” Node.Pointer to Address of “Mazinger Z” Node.Pointer

Daimos 05H

HEAD

20H

VoltronNULL

05H

Releasing The Node From Memory

Deleting a node does not only mean that we should remove it from the list. Every time a node is created, memory is allocated for the node according to its size. When we “unlink” a node from a list, it simply becomes “invisible” to the other nodes but it is still present in memory. To avoid wasting unnecessary storage, we must FREE a node every time it is deleted.

FREE (ADDR)

In spite of the benefit in memory requirements when using singly-linked list, we notice one main disadvantage: It is only possible to traverse the list from left to right.

In some applications, this type of processing is sufficient

However, there are applications that require the capability of reading a linked list in both directions.

An example of this is an application that performs a number of deletions.

DataRight

PointerLeft Pointer

Figure 18. Format Of A Doubly-Linked List Node

HEAD

15H

Snoopy 01HNULL Woodstock 25H15H

01H

Charlie Brown

NULL01H

25H

Figure 19. Doubly-Linked List With 3 Node

TAIL

From Left to Right (Head to Tail) From Right to Left (Tail to Head)

Pointer_Value Node.Data – References the Data field of the node whose address is Pointer_Value

Pointer_Value Node.Left_Pointer – References the Left Pointer field of the node whose address is Pointer_Value

Pointer_Value Node. Right_Pointer – References the Right Pointer field of the node whose address is Pointer_Value

Read_Dbl_List_LR(Head){

If(Head = NULL){

Print “The List is Empty” Exit

}

Set Num_Nodes to 1

Set Next_Node to Head Node.Right_Pointer /* Get the address of the next node */

Print Head Node.Data /* Print contents of Data Field */

While(Next_Node is not NULL){

Increment Num_NodesPrint Next_Node Node.Data

Set Next_Node to Next_Node Node.Right_Pointer }

Print “” Print “The Number of nodes in the list is” Num_Nodes

}

HEAD

15H

Archie Andrews

01HNULLBetty

Cooper25H15H

01H

Veronica Lodge

NULL01H

25H

Figure 20. Doubly-Linked List With 3 Nodes

TAIL

Num_Nodes = 1

Next_Node = address of “Betty Cooper” (01H)

Print “Archie Andrews”


Num_Nodes = 2

Print “Betty Cooper”

Next_Node = address of “Veronica Lodge” (25H)


Num_Nodes = 3

Print “Veronica Lodge”

Next_Node = NULL

Print “”

Print “The number of nodes in the list is 3”

Summary of Output

Archie Andrews

Betty Cooper

Veronica Lodge


Read_Dbl_List_RL(Tail){

If(Tail = NULL){

Print “The List is Empty” Exit

}

Set Num_Nodes to 1Set Next_Node to Tail Node.Left_Pointer /* Get the address of the next node */

Print Tail Node.Data /* Print contents of Data Field */

While(Prev_Node is not NULL){

Increment Num_NodesPrint Prev_Node Node.DataSet Prev_Node to Next_Node Node.Left_Pointer

}

Print “” Print “The Number of nodes in the list is” Num_Nodes

}

Num_Nodes = 1

Prev_Node = address of “Betty Cooper” (01H)

Print “Veronica Lodge”


Num_Nodes = 2

Print “Betty Cooper”

Prev_Node = address of “Archie Andrews” (15H)


Num_Nodes = 3

Print “Archie Andrews”

Prev_Node = NULL

Print “”

Print “The number of nodes in the list is 3”

Summary of Output

Veronica Lodge

Betty Cooper

Archie Andrews


Head – The address of the first node in the list Tail – The address of the last node in the list Node_Pos – The position of the node in the list Num_Nodes – The number of nodes in the list

Fast_Retrieve(Head, Tail, Node_Pos, Num_Nodes){

If ((Num_Nodes = 0) OR (Tail = NULL) OR (Head = NULL)) then {

Display_Error_Message (1) Exit

}

If ((Node_Pos = 0) OR (Node_Pos > Num_Nodes)) then {

Display_Error_Message (2) Exit

}/* Get the position of the middle node */

If (Num_Nodes is Odd) then {

Set Mid_Pos to ((Num_Nodes + 1) / 2 )}

Else {

Set Mid_Pos to (Num_Nodes / 2 )}

/* Verify if the node to be retrieved is at the latter part of the list */

If (Node_Pos > Mid_Pos) then {

Traverse_From_Tail () }

Else {

Traverse_From_Head () }

}

Traverse_From_Head () {

Set I to 1

Set Next_Node to Head

While ((Next_Node is not NULL) AND (I < Node_Pos){

Increment I

Set Next_Node to Next_Node Node.Right_Pointer }

If (Next_Node = NULL ) then {

Display_Error_Message (3) }

Else {

Print Next_Node Node.Data}

}

Traverse_From_Tail () {

Set I to Num_Nodes

Set Prev_Node to Tail

While ((Prev_Node is not NULL) AND (I > Node_Pos){

Decrement I

Set Prev_Node to Prev_Node Node.Left_Pointer }

If (Prev_Node = NULL ) then {

Display_Error_Message (3) }

Else {

Print Prev_Node Node.Data}

}

Display_Error_Message(Message_Type) /* Prints a message on the screen based on the Message_Type */

{

Switch (Message_Type)

{

Case (1)

{

Print “Error: List is Empty”

Case (2)

{

Print “Error: Position of node to be retrieved should be Greater than 0 and must not be greater than the number of nodes in the list”

}

Default{

Print “Error: Position of node to be retrieved exceeds ACTUAL length of List ”

Print “The number of nodes specified is greater than ACTUAL number of nodes in list”

}

}

}

HEAD72H

A Partridge in a Pear Tree

NULL

23H Two Turtle Doves72H 40H

Three French Hens23H 01H

Five Gold Rings01H 46H

Seven Swans A Swimming

46H 35H

Nine Ladies Dancing35H 55H

Eleven Pipers Piping55H 13H

Four Calling Birds 40H 19H

Six Geese A Laying19H 08H

Eight Maids A Milking

08H 28H

Ten Lords A Leaping28H 90H

Twelve Drummers Drumming

90HNULL

TAIL

23H

40H 01H

19H 46H

08H 35H

28H 55H

90H 13H

Figure 21. Doubly-Linked List With 12 Nodes

By applying the algorithm Fast_Retrieve, let us try to see what “ My True Love ” sent on the third day of Christmas. Parameters passed to Fast_Retrieve(72H, 13H, 3, 12)

Mid_Pos = 6

/* Traverse_From_Head */I = 1

Next_Node = Head (72H)


I = 2

Next_Node = Address of Node 2 (23H)


I = 3

Next_Node = Address of Node 3 (40H)

Print “Three French Hens ”

Create a new node for the element Set the data field for the new node value to

be inserted Determine the position of the node in the

list based on its value Insert

Insert_Node_Dbl (Head, Tail, New_Value) {

If (Head = NULL ) then

{

Print “Error: List is Empty”

Exit

}

Create New Node

Set Address of New Node Node.Data to New_Value

If (Head Node.Data > New_Value) then /* Insert node at head of list */

{

Insert_Dbl_Head()}

Else{

If (Tail Node.Data > New_Value) then {

Insert_Dbl_Tail()}

Else

{

Insert_Dbl_Within()}

}

}

Insert_Dbl_Head () {

Set Address of New Node Node.Left_Pointer to NULL

Set Address of New Node Node.Right_Pointer to Head

Set Head Node.Left_Pointer to Address of New Node

Set Head to Address of New Node}

Insert_Dbl_Tail () {

Set Address of New Node Node.Right_Pointer to NULL

Set Address of New Node Node.Left_Pointer to Tail

Set Tail Node.Right_Pointer to Address of New Node

Set Tail to Address of New Node

}

Insert_Dbl_Within() {

Set Displaced_Node to Head Node.Right_Pointer /* Determine Position of Node */

While(Displaced_Node Node.Data < New_Value ) {

Set Displaced_Node to Displaced_Node Node.Right_Pointer

}

Set Address of New Node Node.Left_Pointer to Displaced_Node Node.Left_Pointer

Set Address of New Node Node.Right_Pointer to Displaced_Node

Set (Displaced_Node Node.Left_Pointer) Node.Right_Pointer to Address of New Node

Set Displaced_Node Node.Left_Pointer to Address of New Node

}

HEAD

20H

Batman 80HNULL Spiderman 04H20H Superman NULL80H

80H 04H

1. Let us insert “Aquaman” into the list.

Parameters passed to Insert_Node_Dbl (20H, 04H, “Aquaman”)

Create new node

Address of New Node (33H) Node.Data = “Aquaman”

Aquaman

33H

HEAD

20H


80H 04H

/* First IF Statement Insert Node at Head of List */

/* Insert_Dbl_Head */

Address of New Node (33H) Node.Left_Pointer = NULL

Address of New Node (33H) Node.Right_Pointer = Head (20H)

Aquaman 20HNULL

33H

TAIL

HEAD

20H

Batman 80H33H

Superman NULL80HSpiderman 04H20H

80H 04H

Head (20H) Node.Left_Pointer = Address of New Node (33H)

Aquaman 20HNULL

33HTAIL

Head = Address of New Node (33H)

20H

Batman 80H33H

Superman NULL80HSpiderman 04H20H

80H 04H

Aquaman 20HNULL

33HTAIL

HEAD Final Result

HEAD

20H


80H 04H

2. Let us insert “Wonder Woman” into the list.

Parameters passed to Insert_Node_Dbl (20H, 04H, “Wonder Woman”)

Create new node

Address of New Node (33H) Node.Data = “Wonder Woman”

Wonder Woman

33H

HEAD

20H


80H 04H

/* Second IF Statement Insert Node at End of List */

/* Insert_Dbl_Tail */

Address of New Node (33H) Node.Right_Pointer = NULL

Address of New Node (33H) Node.Left_Pointer = Tail (04H)

Wonder Woman

NULL04H

33H

TAIL

HEAD

20H

Batman 80HNULL Superman 33H80HSpiderman 04H20H

80H 04H

Tail (04H) Node.Right_Pointer = Address of New Node (33H)

Wonder Woman

NULL04H

33H

TAIL

Tail = Address of New Node (33H)

Final Result

20H

Batman 80HNULL Superman 33H80HSpiderman 04H20H

80H 04H

Wonder Woman

NULL04H

33H

TAIL

HEAD

HEAD

20H


80H 04H

3. Let us insert “Flash” into the list.

Parameters passed to Insert_Node_Dbl (20H, 04H, “Flash”)

Create new node

Address of New Node (33H) Node.Data = “Flash”

Flash

33H

HEAD

20H


80H 04H

/* Last IF Statement Insert Node Within the List */

/* Insert_Dbl_Within */

Displaced Node = Address of “Spiderman” (80H)

Address of New Node (33H) Node.Left_Pointer = Address of “Batman” (20H)

Address of New Node (33H) Node.Right_Pointer = Address of “Spiderman” (80H)

Flash 80H20H

33H

TAIL

HEAD

20H


80H 04H

Address of “Batman” (20H) Node.Right_Pointer = Address of New Node (33H)

Flash 80H20H

33H

TAIL

HEAD

20H

Batman 33HNULL

Spiderman 04H33H Superman NULL80H

80H 04H

Address of “Spiderman” (80H) Node.Left_Pointer = Address of New Node (33H)

Flash 80H20H

33H

TAIL

Final Result

Locate the node1. At the head of the list2. Within the list

Delete the node Release the node from the memory

HEAD

02H

B 08HNULL

08H

D 40H02H E NULL08H

40H

TAIL

Set the variable HEAD to the address of the second node in the list, node “D”.Note that the address of node “D” is contained in the right pointer field of the HEAD node, node “B”

HEAD

02H

B 08HNULL

08H

D 40H02H E NULL08H

40H

TAIL

Doubly-Linked List after Reassigning HEAD

Set the left pointer field of the new HEAD node, node “D”, to NULL

HEAD

08H

D 40HNULL E NULL08H

40H

TAIL

Doubly-Linked List after Setting The Left Pointer Field of Node “D”

Set the right pointer field of node “B” to the address of node “E”.Note that the address of node “B” is contained in the left pointer field of node “D” and the address of node “E” is contained in the right pointer field of node “D”.

HEAD

02H

B 40HNULL

08H

D 40H02H

E NULL08H

40H

TAIL

Doubly-Linked List Setting The Right Pointer Field of Node “B”

Set the left pointer field of node “E” to the address of node “B”

HEAD

02H

B 40HNULL E NULL02H

40H

TAIL

Doubly-Linked List after Setting The Left Pointer Field of Node “E”

A circular list is formed by making use of variables which would otherwise be null. The last element of the list is made the predecessor of the first element; the first element, the successor of the last.

The upshot is that e no longer need both a head and tail variable to keep track of the list.

Even if only a single variable is used, both the first and the last list elements can be found in constant time.

02H

May 08HNULL

08H

June 40H02H July NULL08H

40H

mit – 594 data structures and algorithms masters of information technology ms. marife s. edu

Documents

linked listslinked list

list of items

linked items

list processor

linked listsdoubly

linked listdeveloped

successive list nodes

data items