Suppose that we have linked list of integers where each node is represented as: // An item in the list.

Transcription

1 Linked List Suppose that we have linked list of integers where each node is represented as: class ListNode { int item; // An item in the list. ListNode next; // Pointer to next item in the list. This node definition is used in a linked list implementation in the following (the implementation is the very same from the book. It is a modified version of the book code, LinkedList2.java [1] ). Example 1. A linked list implementation (IntList.java) public class IntList{ private class ListNode{ private int item; private ListNode next; public ListNode(){ item = 0; next = null; public ListNode(int newitem, ListNode linkvalue){ item = newitem; next = linkvalue;

2 private ListNode head; public IntList(){ head = null; /** Adds a node at the start of the list with the specified data. The added node will be the first node in the list. */ public void addtostart(int item){ head = new ListNode(item, head); /** Removes the head node and returns true if the list contains at least one node. Returns false if the list is empty. */ public boolean deleteheadnode(){ if (head!= null){ head = head.next; return true; else return false;

3 /** Returns the number of nodes in the list. */ public int size(){ int count = 0; ListNode position = head; while (position!= null){ count++; position = position.next; return count; public boolean contains(int item){ return (find(item)!= null); /** Finds the first node containing the target item, and returns a reference to that node. If target is not in the list, null is returned. */

4 private ListNode find(int target){ ListNode position = head; int itematposition; while (position!= null){ itematposition = position.item; if (itematposition==target) return position; position = position.next; return null; public void outputlist(){ ListNode position = head; while (position!= null){ System.out.println(position.item ); position = position.next; public boolean isempty(){ return (head == null);

5 public void clear(){ head = null; /* For two lists to be equal they must contain the same data items in the same order. */ public boolean equals(object otherobject){ if (otherobject == null) return false; else if (getclass( )!= otherobject.getclass( )) return false; else{ IntList otherlist = (IntList)otherObject; if (size()!= otherlist.size()) return false; ListNode position = head; ListNode otherposition = otherlist.head; while (position!= null){

6 if (position.item!=otherposition.item) return false; position = position.next; otherposition = otherposition.next; return true; We will also make use of the following driver code: Example 2. A driver of linked list implementation (IntListDemo.java) public class IntListDemo{ public static void main(string [] args){ IntList anintlist = new IntList(); populatelist(anintlist); anintlist.outputlist();

7 public static void populatelist(intlist anintlist){ for(int i=0;i<10;i++){ anintlist.addtostart(new java.util.random().nextint(100)); Now, given the above: 1. Write a method, sumiterative, that uses iteration to calculate the the sum of all the ints in the linked list. Also, write a recursive method to calculate the sum. 2. Write a method, sumrecursive, that uses recursion to calculate the the sum of all the ints in the linked list. Hint for recursive method As we know a recursive method solves a problem by utilizing itself, but on a smaller input (or a set of input). The first task is to divide the problem in to sub-problen of smaller input. We realize that a linked list can be sub-divided into a smaller list easily. This is done by taking out the node pointed by head and treating the rest of the list as another list (referred by what?), which is of course one size smaller. We can recursively sub-divide this new list again and get futher smaller lists. As we access the node pointed by head, we can retrive the value it contains and accumulate it for the sum. Our base condition is the fact that a head pointing to null is an empty list and the sum in such case is 0.

8 This completes our strategy for recursion. But there is an issue. A recursive method by definition works a on a smaller input. In other words, it requires an input. As we solved in the non-recursive sum, we should have noticed that our sum does not require a argument, whereas the recursive method requires an argument, an argument that represents the list (smaller input). A list can be represented by the head of the list, so our recursive method can do its task by getting heads of lists. From a pure object oriented point of view and encapsulation exposing the head to the driver class is not a good idea. Beside, it will cause additional unnessary burden on the linked list implementation (for example, one can pass an unrelated head of a linked list to get sum). To cope with this, we will make our recursive sun method private. We will have the a public sum method that does not take any parameter and this will be used by the driver class. This public sum method will in turn call the recurive method by passing the private head of the list. 3. Write a method that will make a copy of a list, with the order of the items of the list reversed. The method should return a new list of IntList type. The original list should not be modified. [1] Which can be downloaded from ftp://ftp.awl.com/cseng/authors/savitch/abjava4e

9 Doubly Linked List Consider the following implementation of doubly linked list, modified from Dr. Yan's moddle code: Example 3. A Doubly linked list implementation (SimpleDoublyLinkedList.java) // // One way to build a list is by created a linked collection of node objects. // The code below implements a linked list in this manner. // The node class. Each node contains a value object, plus a reference to the last // and next nodes in the list. class ListNode<T>{ private T value; private ListNode<T> next; private ListNode<T> previous; public ListNode(T value){ this.value = value; next = null; previous = null; public void setvalue(t value){ this.value = value; next = null; previous = null;

10 public T getvalue(){ return value; public void setnext(listnode<t> next){ this.next = next; public ListNode<T> getnext(){ return next; public void setprevious(listnode<t> previous){ this.previous = previous; public ListNode<T> getprevious(){ return previous; //The SimpleLinkedList class. Note that it implements the SimpleList interface. public class SimpleDoublyLinkedList<T extends Comparable<T>> implements SimpleList<T>{ ListNode<T> head; // pointer to start of list ListNode<T> tail; // pointer to end of list

11 int currentsize; // constructor public SimpleDoublyLinkedList(){ head = null; tail = null; currentsize = 0; // constructor public SimpleDoublyLinkedList(ListNode<T> head){ this.head = head; this.tail = head; currentsize = 1; public int getsize(){ return currentsize; // retrieve an item at a specific index public T getitemat(int index){ ListNode<T> target; if (index > currentsize - 1) throw (new SimpleListIndexOutOfBoundsException());

12 target = getnode(0, index, head); return target.getvalue(); // set an object at a specific index public void setitemat(int index, T item){ ListNode<T> target; if (index > currentsize - 1) throw (new SimpleListIndexOutOfBoundsException()); target = getnode(0, index, head); target.setvalue(item); to // add a new object to the list at a specific index. Care must be taken // adjust all references appropriately public void insertitemat(int index, T item){ if (index > currentsize - 1) throw (new SimpleListIndexOutOfBoundsException()); ListNode<T> target, previous; ListNode<T> newnode = new ListNode<T>(item); target = getnode(0, index, head);

13 // handle a few special cases if (index == 0) head = newnode; previous = target.getprevious(); if (previous!= null) previous.setnext(newnode); target.setprevious(newnode); newnode.setprevious(previous); newnode.setnext(target); currentsize += 1; to // delete an object from the list at a specific index. Care must be taken // adjust all references sappropriately public void deleteitemat(int index){ if (index > currentsize - 1) throw (new SimpleListIndexOutOfBoundsException()); ListNode<T> target, previous, next; target = getnode(0, index, head);

14 // handle a few special cases if (index == (currentsize - 1)) tail = tail.getprevious(); if (index == 0) head = head.getnext(); // now delete the object previous = target.getprevious(); next = target.getnext(); if (previous!= null) previous.setnext(next); if (next!= null) next.setprevious(previous); currentsize -= 1; // add a node to the end of the list public void append(t item){ ListNode<T> newnode = new ListNode<T>(item); if (currentsize == 0) head = tail = newnode; else{ tail.setnext(newnode); newnode.setprevious(tail);

15 tail = newnode; currentsize += 1; // a simple iterative technique to find the node at a given index. It is // superior to the recursive method in that it is easy to write and it // does not exhoust the stack. protected ListNode<T> getnode(int current, int selected, ListNode<T> node){ while(current!= selected){ node = node.getnext(); current += 1; return node; Here is the modified interface: Example 4. The SimpleList interface (SimpleList.java)

16 // SimpleList.java // // An interface that defines the method that must be implmemented by any // class that serves as a list public interface SimpleList <T> { public int getsize(); public T getitemat(int index); public void setitemat(int index, T item); public void insertitemat(int index, T item); public void deleteitemat(int index); public void append(t item); And a sample driver: Example 5. A Doubly linked list driver (SimpleDoublyLinkedListDemo.java) import java.util.random; public class SimpleDoublyLinkedListDemo{ public static void main(string[] args) { SimpleDoublyLinkedList<Integer> mylist;

17 int anint; Random arandomgenerator; arandomgenerator = new Random(); mylist = new SimpleDoublyLinkedList<Integer>(); for(int i=0;i<10;i++){ anint = arandomgenerator.nextint(100); mylist.append(anint); System.out.println("added: " + anint); System.out.println("List content: "); for (int i = 0; i < mylist.getsize(); i++){ System.out.println( mylist.getitemat(i)); Now, given the above: 1. Write a method that prints the list from start to end. 2. Write a method that prints the list from end to start. 3. Write a method that inserts element in an ascending sorted order. Once this method is implemented, you can invoke the method implemented in 1 to print the list in ascending order and invoke the method implemented in 2 to print the list in descending order.