Lecture 19 Linked List Operations Iterative vs Recursive

Lecture 19 Linked List Operations

Iterative vs Recursive List Operations n With few exceptions, recursive implementations of common list operations are more compact and easier to commit to memory than their iterative counterparts. The cost of this advantage is a thorough understanding of recursion.

Iterative vs Recursive List Operations n We compare iteration with recursion for a few list operations: l l l display delete insert. In. Order

Class Node class Node { int data; Node next; Node(int i, Node link) {data = i; next = link; } }; 15 -113 4

Display Iterative Version void Display(Node first) { Node ptr = first; while (ptr != null) { System. out. println( ptr. get. Data() ; ) ptr = ptr. get. Next(); } } Recursive Version void Display(Node list) // 10 20 30 null { if (list != NULL) { System. out. println( ptr. get. Data() ; ) Display(list. get. Next()); // TAIL RECURSION } } 15 -113 5

Reverse Display Iterative Version void Reverse. Display(Node list) // this is really hard to do in a singly linked-list { Node ptr = list; vector V= new Vector(); while (ptr != null) { V. add(ptr); // store them in a vector ptr = ptr. get. Next(); } for (int I=V. size()-1; I>=0; I--) System. out. print(ptr. get. Value()); } Recursive Version void Reverse. Display(Node list) { if (list != null) // 10 20 30 null { Reverse. Display(list. get. Next()); // HEAD RECURSION System. out. print(list. get. Value()); } } 15 -113 6

Insert In Order - Iterative version Iterative Version void Insert. In. Order(Node list, int val) { if (list == null || val < list. get. Value()) 30 { null list = new Node(val, list); // nextnode = new Node(val); nextnode->next = first; first = nextnode; } else { // 10 20 30 null val = 25 Node temp = list; while (temp. get. Next() != null && val >= (temp. get. Next()). get. Data()) temp = temp. get. Next(); temp. get. Next() = new Node(val, temp. get. Next()); } } 15 -113 7

Insert In Order - Recursive version Recursive Version void Insert. In. Order(Node list, int val) { if (list == null || val < list. get. Data()) { list = new Node(val, list); } else Insert. In. Order(list. get. Next(), val); } // 10 20 30 null val = 25 15 -113 8

Delete Node - Iterative version void Delete(Node list, int target) {Node temp; if (list != null) { temp = list; if (temp. get. Data() == target) { list = list. get. Next(); delete temp; } else { while (temp. get. Next() && (temp. get. Next()). get. Data() != target) temp = temp. get. Next(); if (temp. get. Next() != null) { Node hold = temp. get. Next(); temp. get. Next() = (temp. get. Next()). get. Next(); delete hold; } } 15 -113 9

Delete Node - Recursive version void delete(Node list, int target) { if (list != null) if (list. get. Data() == target) { Node temp = list; list = list. get. Next(); delete temp; } else delete(list. get. Next(), target); } 15 -113 10

Insert At Front - Iterative version void Insert. At. Front(Node list, int val) { Node temp; temp = new Node(val); temp->next = list; list = temp; } 15 -113 11

Search - Iterative version Node Search(Node list, int key) { Node temp; temp = list; while (temp != null && temp. get. Data() != key) temp = temp. get. Next(); return temp; } 15 -113 12