Linked List: Traversal Insertion Deletion. Linked List Traversal LB.

Linked List: Traversal InsertionDeletion

Linked List Traversal

• Traversal means “visiting” or examining each node.

• Simple linked list– Start at the beginning– Go one node at a time until the end

• Recursive procedure (or function)– Given a head pointer– Looks at just one node– What procedure will look at the rest?

The Node Code

Node definesa record

data isoftype Num

next isoftype Ptr toa Node

endrecord

The Big Picture

stackhead

98 12 6

The Little Picture

The Classic Code

Procedure Traverse

(current isoftype in Ptr toa Node)

// Precon: Pass in pointer to a list

// Purpose: Print each data item

// Postcon: No changes to list

if(current <> NIL) then

print(current^.data)

Traverse(current^.next)

endprocedure // Traverse

The Big Picture

stackhead

98 12 6

Questions?

Insertion Into Linked Lists

Node Definition

node definesa record

data isoftype Num

next isoftype ptr toa node

endrecord

The Scenario

• You have a linked list– Perhaps empty, perhaps not– Perhaps ordered, perhaps not

• You want to add an element into the linked list

48 17 142head //

Adding an Element to a Linked List

Involves two steps:

• Finding the correct location

• Doing the work to add the node

Finding the Correct Location

• Three possible positions:– The front– The end– Somewhere in the middle

Inserting to the Front

• There is no work to find the correct location

• Empty or not, head will point to the right location

48 17 142head 93

Inserting to the End

• Find the end of the list(when at NIL)

– Recursion or iteration

48 17 142head //93 //

Don’t Worry!

Inserting to the Middle

• Used when order is important

• Go to the node that should follow the one to add

– Recursion or iteration

17 48 142head //93 //142

The Work to Add the Node

• Create the new node• Fill in the data field• Deal with the next field

– Point to nil (if inserting to end)– Point to current (front or middle)

temp <- new(Node) temp^.data <- new_data temp^.next <- current current <- temp

Three Types of Insertion

• To front– No recursion needed

• To end– Get to the end, then add node

• In order (in middle)– To maintain sorted property

Inserting at the Front of a Linked List

Inserting to the Front of a Linked List

• Need an in/out pointer parameter

• Create new node• Fill in data• Make new node’s next pointer point to

current• Update current to point to new node

procedure Insert (current iot in/out ptr toa Node, new_data isoftype in Num)

temp isoftype ptr toa Node temp <- new(Node) temp^.data <- new_data temp^.next <- current current <- tempendprocedure

Current new_data temp2R

Animated Insert to Front of Linked List

(current iot in/out ptr toa Node,

temp <- new(Node)temp^.data <- new_datatemp^.next <- currentcurrent <- temp

Inserting at the End of a Linked List

Inserting to End of a Linked List

• Recursively traverse the list until at end• Then:

– Create new node at current– Fill in data– Terminate the new node’s

next pointer to point to NIL

Inserting to the End of a Linked List

procedure Add_To_End( current isoftype in/out Ptr toa Node, new_data isoftype in Num )

// Purpose: Add new node to end of list

// Pre: current points to NIL-terminated list

// Post: new list has added element at end

if( current = NIL ) then

current <- new( Node )

current^.data <- new_data

current^.next <- NIL

Add_To_End( current^.next, new_data)

endprocedure //Add_To_End

48 17 142head 53

current new_data 53R

Inserting at the End of a Linked List

Inserting in Order into a Linked List

Inserting In Order into a Linked List

• Recursively traverse until you find the correct place to insert– Compare to see if you need to insert before

current– If adding largest value, then insert at the end

• Perform the commands to do the insertion– Create new node– Add data– Update the next pointer of the new node– Update current to point to new node

Inserting in Order into a Linked List

procedure Insert_In_Order(current isoftype in/out Ptr toa Node, new_data isoftype in Num )

// comments here temp isoftype Ptr toa Node if ((current = NIL) OR (current^.data > new_data)) then temp <- new( Node ) temp^.data <- new_data temp^.next <- current current <- temp else Insert_In_Order(current^.next,new_data) endifendprocedure //Insert_In_Order

13 18 23Head

Inserting In Order into a Linked List

current new_data tempR 19

Summary

• Inserting into a linked list involves two steps:– Find the correct location– Do the work to insert the new value

• We can insert into any position– Front– End– Somewhere in the middle

(to preserve order)

Questions?

Deleting an Element from a Linked List

The Node Definition

Node definesa record

data isoftype num

next isoftype ptr toa Node

endrecord

The Scenario

• Begin with an existing linked list– Could be empty or not– Could be ordered or not

The Scenario

Finding the Match

• We’ll examine three situations:

– Delete the first element

– Delete the first occurrence of an element

– Delete all occurrences of a particular element

Deleting the First Element

• This can be done without any traversal/searching• Requires an in/out pointer

procedure DeleteFront(current iot in/out ptr toa Node)

// deletes the first node in the list if (current <> nil) then current <- current^.next endifendprocedure

Deleting from a Linked List

• Deletion from a linked list involves two steps:– Find a match to the element to be deleted

(traverse until nil or found)– Perform the action to delete

• Performing the deletion is trivial:

current <- current^.next– This removes the element, since nothing will

point to the node.

.Delete(head, 4)..

procedure Delete(cur iot in/out ptr toa Node, target isoftype in num)

// Delete single occurrence of a node. if(cur <> NIL) then if(cur^.data = target) then

cur <- cur^.next else

Delete(cur^.next, target) endif endifendprocedure

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Linked List Deletion(All Occurrences)

Deleting All Occurrences

• Deleting all occurrences is a little more difficult.

• Traverse the entire list and don’t stop until you reach nil.

• If you delete, recurse on current• If you don’t delete, recurse on

current^.next

.Delete(head, 4)..

// Delete all occurrences of a node. if(cur <> NIL) then if(cur^.data = target) then

cur <- cur^.next Delete(cur, target) else

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Target = 4

.Delete(head, 4)..

Summary

• Deletion involves:– Getting to the correct position– Moving a pointer so nothing points to

the element to be deleted

• Can delete from any location– Front– First occurrence– All occurrences

Questions?

Linked List: Traversal Insertion Deletion. Linked List Traversal LB.

Documents

Transcript of Linked List: Traversal Insertion Deletion. Linked List Traversal LB.

UNIT-2. Singly Linked List Doubly Linked List Circular Linked List Representing Stack with Linked List. Representing Queue with Linked List.

1 Linked List Position (1). 2 Linked List Position (2)

Fall 2005 Data Structure Linked List – Single Linked List.

Iterator for linked-list traversal, Template & STL COMP171 Fall 2005.

Chapter 5 Topics l Meaning of a Linked List l Meaning of a Dynamic Linked List l Traversal, Insertion and Deletion of Elements in a Dynamic Linked List.

Linked List Traversal Lesson xx

Arrays are not always the optimal data Linked Lists · List with a single element nBefore: After: qWe must change head to null. ... Recursive linked list traversal –which is correct?

Linked List Lecture One Data Structuresfiles.imtschool.com/Online/DataStructure/Lecture 1/linked...Linked list operation Creation is used to create a linked list. Once a linked list

1 Chapter 16 Linked Structures Dale/Weems. 2 Chapter 16 Topics l Meaning of a Linked List l Meaning of a Dynamic Linked List l Traversal, Insertion and.

Linked List 3 Stack 33 Queue 40 - WordPress.com By Dhaval S Sheth(9033271276) 3 Linked List Singly Linked List Explain Singly Linked list: - Ans. A singly linked list is a linked list

Linked List

Linked Lists CSC220 Winter 2004-5. Array vs Linked List node Array Linked List.

CIRCULAR LINKED LIST. Circular Linked List- A circular linked list is a linked list in which last element or node of the list points to first node. For.

Linked List 1. Introduction to Linked List 2. Node Class 3. Linked List 4. The Bag Class with Linked List.

1 Chapter 16-1 Linked Structures Dale/Weems. 2 Chapter 16 Topics l Meaning of a Linked List l Meaning of a Dynamic Linked List l Traversal, Insertion.

Linear List Linked Representationorca.st.usm.edu/~nwang/teaching/datastructures/Notes/Linked List 2.pdfLinear List Linked Representation. Linked Representation • list elements are

Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum

Walking Linked Data: a graph traversal approach to explain clusters

Lecture Objectives Linked list data structures: Singly-linked (cont.) Doubly-linked Circular Implementing the List interface as a linked list.

LECTURE NOTES ON DATA STRUCTURES USING C · LECTURE NOTES ON DATA STRUCTURES USING C Revision 4.0 1 December, ... Circular Single Linked List ... Non Recursive Traversal Algorithms