Chapter 5 - A Simple Dynamic Linked List (Holding Strings)

Size: px

Start display at page:

Download "Chapter 5 - A Simple Dynamic Linked List (Holding Strings)"

Bertram Parsons
6 years ago
Views:

1 Chapter 5 - A Simple Dynamic Linked List (Holding Strings) Very Simple Link Class Holding String Data and Reference to Next Link (Version 1) public class Link{ private String data; private Link next; public Link(String newdata){ data = newdata; next = null; public String getdata() { return data; public void setdata(string data) { this.data = data; public Link getnext() { return next; public void setnext(link next) { this.next = next; public void showdata(){ System.out.println("Data:" + data + " Next:" + next); List Driver (Version 1) public class LinkedListDriver { /** * making/testing the HomeMadeLinkedList class (Step 1 just a few links) */ public static void main(string[] args) { Link n1 = new Link("AAA"); Link n2 = new Link("BBB"); Link n3 = new Link("CCC"); n1.setnext(n2); n2.setnext(n3); System.out.println( "\nn1: " + n1); n1.showdata(); System.out.println( "\nn2: " + n2); n2.showdata(); System.out.println( "\nn3: " + n3); n3.showdata(); System.out.println("\n\nTraversing the CHAIN"); Link n = n1; while (n!= null){ n.showdata(); n = n.getnext();

2 Console n1: Data:AAA n2: Data:BBB n3: Data:CCC Next:null Traversing the CHAIN Data:AAA Data:BBB Data:CCC Next:null

3 A Better Link Class Generic Link: GLink Holding Data of Any Type (Version 2) public class GLink<E>{ private E data; private GLink next; public GLink(E newdata){ data = newdata; next = null; public E getdata() { return data; public void setdata(e data) { this.data = data; public GLink getnext() { return next; public void setnext(glink next) { this.next = next; public void showdata(){ System.out.println("Data Class>>> " + data.getclass().getname() ); System.out.println(" Data:" + data.tostring() + "\t Next: " + next); if (data.getclass().getname().equals("cis265.matos.person")) { ((Person) data).showdata(); Driver. Testing the new GLink class (Version 2) public class LinkedListDriver { /** * GLinks hold arbitrary data connecting links by hand ClassNotFoundException */ public static void main(string[] args) throws ClassNotFoundException { // GLink n1 = new GLink("AAA"); // GLink n2 = new GLink(123); // GLink n3 = new GLink(123.99); //Not a good idea to mix types in the chain... Person p1 = new Person("Macarena", " "); GLink<String> n1 = new GLink<String>("AAA"); GLink n2 = new GLink(222); GLink<Person> n3 = new GLink<Person>(p1); // // a chain of Person objects // GLink<Person> n1 = new GLink<Person>(new Person("person1", " "));

4 // GLink<Person> n2 = new GLink<Person>(new Person("person2", " ")); // GLink<Person> n3 = new GLink<Person>(new Person("person3", " ")); //interconnecting nodes by hand n1.setnext(n2); n2.setnext(n3); // showing the GLinks System.out.println( "\nn1: " + n1); n1.showdata(); System.out.println( "\nn2: " + n2); n2.showdata(); System.out.println( "\nn3: " + n3); n3.showdata(); //TODO: move the logic for detecting class type // and printing to the GLink<E> class System.out.println("\n\nTraversing the CHAIN"); Person p; GLink n = n1; Object obj; while (n!= null){ n.showdata(); obj = n.getdata(); // ugly syntax to detect at run-time an object s class type: // if (obj.getclass().getname().equals("cis265.matos.person")) // The following is equivalent (and much simpler) if (obj instanceof Person) { p = (Person) n.getdata(); System.out.print(" >>> " ); p.showdata(); n = n.getnext(); Console n1: cis265.matos.glink@42e816 Data:AAA Next:cis265.matos.GLink@9304b1 n2: cis265.matos.glink@9304b1 Data:222 Next:cis265.matos.GLink@190d11 n3: cis265.matos.glink@190d11 Data:cis265.matos.Person@a90653 Next:null Name: Macarena Phone: Traversing the CHAIN Data:AAA Next:cis265.matos.GLink@9304b1 Data:222 Next:cis265.matos.GLink@190d11 Data:cis265.matos.Person@a90653 Next:null Name: Macarena Phone: >>> Name: Macarena Phone:

5 HomeMadeDynamicList Application (singly-linked) (Version 3) Method insertfirst(avalue) deletefirst() insertlast(avalue) deletelast() insertordered(avalue) search(avalue) deletelink(avalue) isempty() deleteall() showlist() Description Place avalue as first element of the list Remove first element of the list Place avalue as last element of the list Remove last element of the list Insert avalue in between links which are <= and > than it Return location in list of a link having data equal to avalue Remove link holding data equal to avalue Return true if list is empty, false otherwise Delete all nodes in the list Display on console links in the list GLink<E> Class public class GLink<E>{ private E data; private GLink<E> next; public GLink(E newdata){ data = newdata; next = null; public E getdata() { return data; public void setdata(e data) { this.data = data; public GLink<E> getnext() { return next; public void setnext(glink<e> next) { this.next = next; public void showdata(){ System.out.println(" Data:" + data + " Next:" + next); System.out.println("Data Class>>> " + data.getclass().getname() );

6 HomeMadeDynamicList class (Holding Control Variables and Basic List Operations) public class HomeMadeDynamicList<E> { // ///////////////////////////////////////////////// // dynamic single linked list // TODO: sortlist(), deletevalue(avalue) // clearall(), isempty(), search(avalue) // ///////////////////////////////////////////////// private GLink<E> mhead; private GLink<E> mtail; int mcount; // ///////////////////////////////////////////// public HomeMadeDynamicList() { mhead = mtail = null; mcount = 0; public GLink<E> getfirst() { return mhead; public void setfirst(glink<e> mhead) { this.mhead = mhead; public GLink<E> getlast() { return mtail; public void setlast(glink<e> mtail) { this.mtail = mtail; public int getcount() { return mcount; public void setcount(int mcount) { this.mcount = mcount; public void insertfirst(e newvalue) { GLink<E> node = new GLink<E>(newValue); if (mcount == 0) { mhead = mtail = node; mcount = 1; else { node.setnext(mhead); mhead = node; mcount++; public void insertlast(e newvalue) { GLink<E> node = new GLink<E>(newValue); if (mcount == 0) {

7 mhead = mtail = node; mcount = 1; else { mtail.setnext(node); mtail = node; mcount++; // ///////////////////////////////////////////////// public void deletefirst() throws Exception { if (mcount == 0) throw new Exception("ERROR- nothing to delete!"); if (mcount == 1) { mhead = mtail = null; mcount = 0; else { mhead = mhead.getnext(); mcount--; public void deletelast() throws Exception { GLink<E> current, previous; if (mcount == 0) throw new Exception("ERROR- nothing to delete!"); if (mcount == 1) { mhead = mtail = null; mcount = 0; else { mcount--; current = previous = mhead; while (current!= mtail) { previous = current; mtail = previous; mtail.setnext(null); // ///////////////////////////////////////////////// public static <E> E createanyobject(class<e> cls) { E ret = null; try { ret = cls.newinstance(); catch (Exception e) { // --- Exception Handling return ret; public void showlist() { System.out.println("\nmHead: \t" + mhead + "\nmtail: \t" + mtail + "\nmcount: \t" + mcount); GLink<E> current = this.mhead; // OK this is not the best solution (yet) // it works because we know that E represents

8 // Person. We'll (try to) solve this problem later. Person p = null; Object obj; while (current!= null) { obj = current.getdata(); System.out.println("Data: " + obj + "\t" + "LocNext: " + current); if (obj instanceof Person) { p = (Person) obj; p.showdata(); // showdata // ======================================================= // searching by person's phone public GLink<E> search(string searchphoneno) { Person p; GLink<E> current = mhead; while (current!= null) { p = (Person) current.getdata(); if (p.getmphone().compareto(searchphoneno) == 0) return current; return null; public boolean deleteglink(string phonenumber) { GLink<E> current = mhead; GLink<E> previous = mhead; Person p; while (current!= null) { p = (Person) current.getdata(); if (p.getmphone().compareto(phonenumber) == 0) { if (mcount == 1) { mhead = mtail = null; if (mhead == current) { mhead = current.getnext(); if (mtail == current) { mtail = previous; previous.setnext(current.getnext()); mcount--; return true; previous = current; return false; public void deleteall() { mhead = mtail = null; mcount = 0; System.gc();

9 public void displayinreverse() { GLink<E> current; int n; HomeMadeDynamicList<E> templist = new HomeMadeDynamicList<E>(); for (int i = 0; i < mcount; i++) { current = mhead; for (int j = 1; j < mcount - i; j++) { templist.insertlast(current.getdata()); System.out.println("<<<< reverse >>>>"); templist.showlist(); public boolean isempty() { return (mcount == 0); public void reverse() { HomeMadeDynamicList<E> temp = new HomeMadeDynamicList<E>(); E mtailvalue; try { while (!this.isempty()) { mtailvalue = this.mtail.getdata(); this.deletelast(); temp.insertlast(mtailvalue); this.mhead = temp.mhead; this.mtail = temp.mtail; this.mcount = temp.mcount; catch (Exception e) { System.out.println(e.getMessage()); // reverse // //////////////////////////////////////////////// public void insertphoneorder(e newnamephone) { // //////////////////////////////////////// // using Comparator interface GLink<E> lnk; Person p1, p2; if (mcount == 0) { p1 = (Person) mhead.getdata(); p2 = (Person) newnamephone; if (Person.comparePhones.compare(p1, p2) > 0) { p1 = (Person) mtail.getdata(); if (Person.comparePhones.compare(p1, p2) < 0) { this.insertlast(newnamephone); GLink<E> current = mhead; GLink<E> previous = mhead;

10 boolean keepgoing = true; while ((current!= null) && keepgoing) { p1 = (Person) current.getdata(); if (Person.comparePhones.compare(p1, p2) < 0) { previous = current; else { keepgoing = false; GLink<E> newnode = new GLink<E>(newNamePhone); newnode.setnext(current); previous.setnext(newnode); mcount++; // insertphoneorder // //////////////////////////////////////////////// public void insertalphabeticorder(e newnamephone) { // using Person's name to decide order GLink<E> lnk; Person p1, p2; if (mcount == 0) { p1 = (Person) mhead.getdata(); p2 = (Person) newnamephone; if (p1.getmname().compareto(p2.getmname()) > 0) { p1 = (Person) mtail.getdata(); if (p1.getmname().compareto(p2.getmname()) < 0) { this.insertlast(newnamephone); GLink<E> current = mhead; GLink<E> previous = mhead; boolean keepgoing = true; while ((current!= null) && keepgoing) { p1 = (Person) current.getdata(); if (p1.getmname().compareto(p2.getmname()) < 0) { previous = current; else { keepgoing = false; GLink<E> newnode = new GLink<E>(newNamePhone); newnode.setnext(current); previous.setnext(newnode); mcount++; // insertphoneorder // ////////////////////////////////////////////////// public void insertalphabeticorderv2(e newnamephone) { // using Comparable interface to compare two Person's name // The following version of the reverse method is // equivalent to the previous code but uses the

11 // compareto method of the Comparable interface // (observe that you must provide the compareto code) GLink<E> lnk; Person p1, p2; if (mcount == 0) { p1 = (Person) mhead.getdata(); p2 = (Person) newnamephone; if (p1.compareto(p2) > 0) { p1 = (Person) mtail.getdata(); if (p1.compareto(p2) < 0) { this.insertlast(newnamephone); GLink<E> current = mhead; GLink<E> previous = mhead; boolean keepgoing = true; while ((current!= null) && keepgoing) { p1 = (Person) current.getdata(); if (p1.compareto(p2) < 0) { previous = current; else { keepgoing = false; GLink<E> newnode = new GLink<E>(newNamePhone); newnode.setnext(current); previous.setnext(newnode); mcount++; // insertphoneorderv2 HomeMadeDynamicListDriver public class LinkedListDriverDos { /** * Putting all pieces together (GLink, HomeMadeLinkedList, Driver) * Inserting Person objects */ public static void main(string[] args) { // a chain of Person objects GLink<Person> p = null; HomeMadeDynamicList<Person> lst = new HomeMadeDynamicList<Person>(); lst.insertlast(new Person("person1", " ")); lst.insertlast(new Person("person2", " ")); lst.insertlast(new Person("person3", " ")); lst.insertlast(new Person("person4", " ")); lst.showlist(); System.out.println();

12 p = lst.getfirst(); while(p!= null){ System.out.println("\nLoc: " + p); p.getdata().showdata(); System.out.println(" Next: " + p.getnext()); p = p.getnext(); //while // locate person using phone number GLink<Person> lnksought = lst.search(" "); Person p2; if (lnksought == null) System.out.println("\nSorry not found"); else { System.out.println("\nFound"); lnksought.showdata(); p2 = (Person)lnkSought.getData(); p2.showdata(); // deleting a node using phone number System.out.println("\nDeleting a Node:"); lst.deleteglink(" "); lst.showlist(); // adding a new person in alphabetic order System.out.println("\nInserting in Alphabetic Order:"); lst.insertalphabeticorder(new Person("person5", " ")); lst.insertalphabeticorder(new Person("person0", " ")); lst.insertalphabeticorder(new Person("person3", " ")); lst.showlist(); // reversing the list System.out.println("\nReversing:"); lst.reverse(); lst.showlist(); Console mhead: cis265.matos.glink@42e816 mtail: cis265.matos.glink@9304b1 mcount: 4 Data: cis265.matos.person@190d11 LocNext: cis265.matos.glink@42e816 Name: person1 Phone: Data: cis265.matos.person@a90653 LocNext: cis265.matos.glink@de6ced Name: person2 Phone: Data: cis265.matos.person@c17164 LocNext: cis265.matos.glink@1fb8ee3 Name: person3 Phone: Data: cis265.matos.person@61de33 LocNext: cis265.matos.glink@9304b1 Name: person4 Phone: Loc: cis265.matos.glink@42e816 Name: person1 Phone: Next: cis265.matos.glink@de6ced Loc: cis265.matos.glink@de6ced

13 Name: person2 Phone: Next: Loc: Name: person3 Phone: Next: Loc: Name: person4 Phone: Next: null Found Data Class>>> cis265.matos.person Name: person3 Phone: Deleting a Node: mhead: cis265.matos.glink@42e816 mtail: cis265.matos.glink@9304b1 mcount: 3 Data: cis265.matos.person@190d11 LocNext: cis265.matos.glink@42e816 Name: person1 Phone: Data: cis265.matos.person@a90653 LocNext: cis265.matos.glink@de6ced Name: person2 Phone: Data: cis265.matos.person@61de33 LocNext: cis265.matos.glink@9304b1 Name: person4 Phone: Inserting in Alphabetic Order: mhead: cis265.matos.glink@14318bb mtail: cis265.matos.glink@ca0b6 mcount: 6 Data: cis265.matos.person@10b30a7 LocNext: cis265.matos.glink@14318bb Name: person0 Phone: Data: cis265.matos.person@190d11 LocNext: cis265.matos.glink@42e816 Name: person1 Phone: Data: cis265.matos.person@a90653 LocNext: cis265.matos.glink@de6ced Name: person2 Phone: Data: cis265.matos.person@1a758cb LocNext: cis265.matos.glink@1b67f74 Name: person3 Phone: Data: cis265.matos.person@61de33 LocNext: cis265.matos.glink@9304b1 Name: person4 Phone: Data: cis265.matos.person@69b332 LocNext: cis265.matos.glink@ca0b6 Name: person5 Phone: Reversing: mhead: cis265.matos.glink@173a10f mtail: cis265.matos.glink@530daa mcount: 6 Data: cis265.matos.person@69b332 LocNext: cis265.matos.glink@173a10f Name: person5 Phone: Data: cis265.matos.person@61de33 LocNext: cis265.matos.glink@a62fc3 Name: person4 Phone: Data: cis265.matos.person@1a758cb LocNext: cis265.matos.glink@89ae9e Name: person3 Phone: Data: cis265.matos.person@a90653 LocNext: cis265.matos.glink@1270b73 Name: person2 Phone: Data: cis265.matos.person@190d11 LocNext: cis265.matos.glink@60aeb0 Name: person1 Phone: Data: cis265.matos.person@10b30a7 LocNext: cis265.matos.glink@530daa Name: person0 Phone:

14 A Better Person Class Implementing the Comparable Interface (Version 4) In order to compare two Person objects we must (arbitrarily) decide how to establish order among those two objects. In our example, are we classifying according to name or phone number? Once we decide what criteria should be used, we could write this policy in the CompareTo method of the Person class. CompareTo() is the only method of the Comparable interface. For more information on the Comparable Interface read the notes at: public class Person implements Comparable<Person> { private String mname; private String mphone; public Person(String mname, String mphone) { super(); this.mname = mname; this.mphone = mphone; public String getmname() { return mname; public void setmname(string mname) { this.mname = mname; public String getmphone() { return mphone; public void setmphone(string mphone) { this.mphone = mphone; public void showdata(){ System.out.println(" Name: " + mname +" Phone: " + mphone); ///////////////////////////////////////////////// // needed to implement the Comparable interface // uses person's name to establish public int compareto(person otherperson) { String thisname = this.getmname(); String othername = otherperson.getmname(); return (thisname.compareto(othername)); The new implementation of the Person class will have an impact on direct comparison of two Person objects. For instance the method insertalphabeticalorder( ) in the HomeMadeDynamicList class can be implemented as follows: Observe the use of the overridden CompareTo( ) method in the conditional statement

15 if (p1.compareto(p2) > 0 ). public void insertalphabeticorder(e newnamephone) { ////////////////////////////////////////// // using Comparable interface GLink<E> lnk; Person p1, p2; if (mcount == 0) { p1 = (Person) mhead.getdata(); p2 = (Person) newnamephone; if (p1.compareto(p2) > 0) { p1 = (Person) mtail.getdata(); if (p1.compareto(p2) < 0) { this.insertlast(newnamephone); GLink<E> current = mhead; GLink<E> previous = mhead; boolean keepgoing = true; while ((current!= null) && keepgoing) { p1 = (Person) current.getdata(); if (p1.compareto(p2) < 0) { previous = current; else { keepgoing = false; GLink<E> newnode = new GLink<E>(newNamePhone); newnode.setnext(current); previous.setnext(newnode); mcount++; // insertalphabeticorder

16 Enhancing the Person Class Implementing Comparator Interface (Version 5) This time we want to have both possiblilities of orderin person objects (by name, and by phone number). To accomplish this goal we implement two new static Comparator.compare methods in the person class. import java.util.comparator; public class Person implements Comparable<Person> { private String mname; private String mphone; public Person(String mname, String mphone) { super(); this.mname = mname; this.mphone = mphone; public String getmname() { return mname; public void setmname(string mname) { this.mname = mname; public String getmphone() { return mphone; public void setmphone(string mphone) { this.mphone = mphone; public void showdata(){ System.out.println(" Name: " + mname +" Phone: " + mphone); ///////////////////////////////////////////////// // needed to implement the Comparable interface // uses person's name to establish public int compareto(person otherperson) { String thisname = this.getmname().touppercase(); String othername = otherperson.getmname().touppercase(); return (thisname.compareto(othername)); public static Comparator<Person> comparenames = new Comparator<Person>() { public int compare(person p1, Person p2){ return(p1.compareto(p2)); ; public static Comparator<Person> comparephones = new Comparator<Person>() { public int compare(person p1, Person p2){ return(p1.getmphone().compareto(p2.getmphone())); ; The new method could be used to support an insertion of person objects driven by either name or phone. For instance we could add the following insertphoneorder() method to the HomeMadeDynamicList class. public void insertphoneorder(e newnamephone) { ////////////////////////////////////////// // using Comparator interface

17 GLink<E> lnk; Person p1, p2; if (mcount == 0) { p1 = (Person) mhead.getdata(); p2 = (Person) newnamephone; if (Person.comparePhones.compare(p1, p2) > 0) { p1 = (Person) mtail.getdata(); if (Person.comparePhones.compare(p1, p2) < 0) { this.insertlast(newnamephone); GLink<E> current = mhead; GLink<E> previous = mhead; boolean keepgoing = true; while ((current!= null) && keepgoing) { p1 = (Person) current.getdata(); if (Person.comparePhones.compare(p1, p2) < 0) { previous = current; else { keepgoing = false; GLink<E> newnode = new GLink<E>(newNamePhone); newnode.setnext(current); previous.setnext(newnode); mcount++; // insertphoneorder

Fundamental Java Methods

Object-oriented Programming Fundamental Java Methods Fundamental Java Methods These methods are frequently needed in Java classes. You can find a discussion of each one in Java textbooks, such as Big Java.