Data Structures and Algorithms, Winter term 2017 Practice Assignment 7

Transcription

1 German University in Cairo Media Engineering and Technology Prof. Dr. Slim Abdennadher Dr. Wael Abouelsaadat Data Structures and Algorithms, Winter term 2017 Practice Assignment 7 Exercise 7-1 Using the LinkList class provided to you on the website, adding the following methods: void insertlast(object o): inserts an object o at the end of the linked list. Your implementation should be an internal recursive one. public void insertlastrec(object o) if (head == null) head = new Link(o); else insertlastrec(head, o); public void insertlastrec(link l, Object o) if (l.next == null) l.next = new Link(o); else insertlastrec(l.next, o); void insertlast(object o): inserts an object o at the end of the linked list. Your implementation should be an external one. public static void insertlast(linklist l, Object o) LinkList tmp = new LinkList(); while(!l.isempty()) tmp.insertfirst(l.removefirst()); tmp.insertfirst(o); while(!tmp.isempty()) l.insertfirst(tmp.removefirst()); Object removelast(): removes and returns the last element from the linked list. Your implementation should be an external one. public static Object removelast(linklist l) LinkList tmp = new LinkList(); while(!l.isempty()) tmp.insertfirst(l.removefirst()); Object res = tmp.removefirst(); while(!tmp.isempty()) l.insertfirst(tmp.removefirst()); return res; 1

2 Exercise 7-2 Reverse Write a Java method reverse that takes as input a linked list of integers and reverses it. For example if the input list is: 1, 2, 3, 8, 10, 15 then reverse should return the list: 15, 10, 8, 3, 2, 1 a) Implement the method as an instance method of the class LinkList public LinkList reverse1() LinkList revlist = new LinkList(); while(current!= null) Link l = new Link(current.data); l.next = revlist.head; revlist.head = l; return revlist; The following solution stores the reversed values in the original list: public void reverse2() LinkList revlist = new LinkList(); while(current!= null) Link l = new Link(current.data); l.next = revlist.head; revlist.head = l; head = revlist.head; b) Implement the method externally in a class LinkListApp public static LinkList reverse1(linklist list) LinkList revlist = new LinkList(); while(!list.isempty()) revlist.insertfirst(list.removefirst()); return revlist; The following solution stores the reversed values in the original list: public static void reverse2(linklist list) LinkList revlist = new LinkList(); while(!list.isempty()) revlist.insertfirst(list.removefirst()); while(!revlist.isempty()) list.insertlast(revlist.removefirst()); 2

3 Exercise 7-3 Reverse in place Write a Java method reverse that takes as input a linked list of integers and reverses it without using any external data structures, only use the input linked list. The reverse should be done in place. For example if the input list is: 1, 2, 3, 8, 10, 15 then reverse should return the list: 15, 10, 8, 3, 2, 1 a) Implement the method as an instance method of the class LinkList public void reverseinplace() Link current = head.next; Link previous = head; while(current!=null) Link temp = current.next; current.next= previous; previous=current; current = temp; head.next=null; head=previous; Exercise 7-4 Remove Duplicates Write an external Java method removeduplicates that takes as input a linked list of integers sorted in ascending order and deletes any duplicate nodes from the list. For example, if the input list is: then removeduplicates should change the list to: 1, 2, 3, 3, 5, 7, 7, 15 1, 2, 3, 5, 7, 15 public static void removeduplicates(linklist s1) LinkList templist = new LinkList(); templist.insertlast(s1.removefirst()); while(!s1.isempty()) if(!s1.getfirst().equals(templist.getlast())) templist.insertlast(s1.removefirst()); else s1.removefirst(); while(!templist.isempty()) s1.insertlast(templist.removefirst()); Exercise 7-5 Count 3

4 a) Write an iterative method called countiter() that returns the total number of elements in a linked list, or 0 if the list is empty. public int countiter() int n = 0; for(link x = head; x!= null; x = x.next) n++; return n; Another solution using while loop: public int countiter2() int n = 0; Link x = head; while(x!=null) n++; x=x.next; return n; b) Write a recursive method called countrec() that returns the total number of elements in a linked list, or 0 if the list is empty. public int countrec() return countrechlp(head); public int countrechlp(link l) if(l == null) return 0; else return 1 + countrechlp(l.next); Exercise 7-6 Mix elements of a List Write an external iterative method static LinkList mix(linklist x) that rearranges the list x as follows: the first element is taken from the front followed by the first element from the end, then the second element from the front followed by the second from the end and so on. Example: The mix method invoked on the linked list 1, 2, 3, 4, 5, 6, 7 should return the linked list 1, 7, 2, 6, 3, 5, 4. public static LinkList mix(linklist x) LinkList result = new LinkList(); while(!x.isempty()) result.insertlast(x.removefirst()); if(!x.isempty()) result.insertlast(x.removelast()); return result; 4

5 Exercise 7-7 Cut a List Write a method static LinkList cut(linklist x) that divides the list x into two (roughly) equal halves and puts the second half at the front of the first half. Write an internal (instance) method void cutlist() that performs the same operation. Example: The cut method invoked on the linked list: 1, 2, 3, 4, 5, 6, 7 will return the linked list: 5, 6, 7, 1, 2, 3, 4 External implementation: static LinkList cut(linklist x) LinkList front = new LinkList(); LinkList back = new LinkList(); while(!x.isempty()) front.insertlast(x.removefirst()); if(!x.isempty()) back.insertfirst(x.removelast()); while(!back.isempty()) front.insertfirst(back.removelast()); return front; Internal implementation: public void cutlist() if (head==null) return; Link current=head; Link previous= null; int count=0; while (current!=null) count++; current=head; for (int i=1; i<count/2 +count%2; i++) current=current.next; previous = current; while (current.next!=null) current.next = head; head = previous.next; previous.next = null; 5

6 Exercise 7-8 Splitting a List Write a java method frontbacksplit that takes as input a linked list of integers. The method should split the list into two sublists: one for the front half and one for the back half and print each. If the number of elements is odd, then the extra element should be placed into the front list. Note that your method should not alter the original list; instead, it should just print the contents of the two lists. For example, if the input list is then frontbacksplit should print: 2, 3, 5, 7, 11 First sublist:2,3,5, Second sublist:7,11 Note: Getting this right for all cases is harder than it looks. You should check your solution against a few cases (length = 2, length = 3, length = 4)to make sure that the list gets split correctly in all cases. If it works right for length = 4, then it will probably work right for length = public static void frontbacksplit(linklist list) int count = 0; LinkList temp = new LinkList(); while (!list.isempty()) temp.insertlast(list.removefirst()); count++; LinkList sublist1 = new LinkList(); LinkList sublist2 = new LinkList(); for (int i = 0;i < (count + 1)/2;i++) Object o = temp.removefirst(); list.insertlast(o); sublist1.insertlast(o); while (!temp.isempty()) Object o = temp.removefirst(); list.insertlast(o); sublist2.insertlast(o); System.out.print("First sublist:"); System.out.print(subList1.toString()+" "); System.out.print("Second sublist: "); System.out.print(subList2.toString()+" "); System.out.println(); Exercise 7-9 Alternating Split Write a Java method alternatingsplit that takes as input a linked list of characters and divides its nodes to make two smaller lists. The sublists should be made from the alternating elements in the original list. Your method should not alter the original list, just create two new lists and print them. For example, if the input list is: then alternatingsplit should print: a, b, c, d, e 6

7 First sublist: a, c, e, Second sublist:b, d public static void alternatingsplit(linklist list) LinkList sublist1 = new LinkList(); LinkList sublist2 = new LinkList(); LinkList templist = new LinkList(); int count = 0; if(list.isempty()) System.out.print("List is empty"); return; while(!list.isempty()) Object temp = list.removefirst(); if(count % 2 == 0) sublist1.insertlast(temp); else templist.insertlast(temp); count++; sublist2.insertlast(temp); while(!templist.isempty()) list.insertlast(templist.removefirst()); System.out.print("First sublist: "); System.out.print(subList1.toString()+" "); System.out.print("Second sublist: "); System.out.print(subList2.toString()+" "); System.out.println(); Exercise 7-10 Max of a list Write an iterative method max that takes a linked list as input, and returns the value of the maximum key in the linked list. Assume all keys are positive integers, and return null if the list is empty. Implement the method both externally and internally. External implementation: public static Object max(linklist l) if(l.isempty()) return null; Comparable max = (Comparable)l.removeFirst(); while(!l.isempty()) Object item = l.removefirst(); if(max.compareto(item) < 0) max = (Comparable)item; return max; Internal implementations: /*** max internal iterative ************************/ public Object max() if (head == null) return null; Comparable max = (Comparable)head.data; 7

8 Link current = head.next; while (current!= null) if (max.compareto(current.data) < 0) max = (Comparable)current.data; return max; /*** max internal recursive ************************/ public Object maxrec() if (head == null) return null; return maxrec(head); public Object maxrec(link l) if (l.next == null) return l.data; Comparable maxrest = (Comparable)maxRec(l.next); if (maxrest.compareto(l.data) > 0) return maxrest; return l.data; Exercise 7-11 Contains Implement an iterative internal method boolean contains(object o) inside class LinkedList which returns true if the linked list contains an object equal to Object o, and false otherwise. public boolean contains(object o) while(current!= null) if(current.data.equals(o)) return true; return false; Alternative implementation using for-loop: public boolean contains2(object o) for (current!= null;current = current.next) if (current.data.equals(o)) return true; return false; Implement a recursive internal method boolean containsrec(object o) which performs the same function. public boolean containsrec(object o) return containsrec(head, o); public boolean containsrec(link l, Object o) if (l == null) return false; 8

9 if (l.data.equals(o)) return true; return containsrec(l.next, o); Exercise 7-12 Implement each of the following methods both internally (using reference manipulation) and externally (using the methods available in the LinkList class). merge that merges two linked lists equals that returns true if the two lists consist of the same elements intersection that returns the intersection of two linked lists difference that returns the difference of two linked lists union that returns the union of two linked lists Implement all methods both internally inside the LinkList class and externally inside LinkListApp class. a) Implementation of all the methods internally as instance methods of the class LinkList public LinkList merge(linklist l) LinkList o=new LinkList(); o.head=head; Link current=head; while(current.next!=null) current=current.next; current.next=l.head; return o; public boolean equals(linklist l) Link c1 = this.head; Link c2 = l.head; while(c1!= null && c2!= null) if(!c1.data.equals(c2.data)) return false; c1 = c1.next; c2 = c2.next; return c1 == null && c2 == null; public boolean contains(object o) while(current!= null) if(current.data.equals(o)) return true; return false; public LinkList intersection(linklist l) LinkList result = new LinkList(); while(current!= null) 9

10 if(l.contains(current.data)) result.insertlast(current.data); return result; public LinkList difference(linklist l) LinkList result = new LinkList(); while(current!= null) if(!l.contains(current.data)) result.insertlast(current.data); return result; public LinkList union(linklist l) return this.difference(l).merge(l); b) Implementation of all the methods externally in the class LinkListApp public static LinkList merge(linklist x,linklist y) LinkList z=new LinkList(); while(!x.isempty()) z.insertlast(x.removefirst()); while(!y.isempty()) z.insertlast(y.removefirst()); return z; public static boolean equals(linklist l1, LinkList l2) LinkList temp1 = new LinkList(); LinkList temp2 = new LinkList(); boolean equal = true; while(!l1.isempty() &&!l2.isempty() && equal) Object o1 = l1.removefirst(); Object o2 = l2.removefirst(); if(!o1.equals(o2)) equal = false; temp1.insertfirst(o1); temp2.insertfirst(o2); if(equal) equal = l1.isempty() && l2.isempty(); while(!temp1.isempty()) l1.insertfirst(temp1.removefirst()); while(!temp2.isempty()) l2.insertfirst(temp2.removefirst()); return equal; public static LinkList intersection(linklist x,linklist y) LinkList z=new LinkList(); LinkList temp=new LinkList(); while(!x.isempty()) Object k=x.removefirst(); while(!y.isempty()) 10

11 temp.insertlast(y.getfirst()); if(k.equals(y.removefirst())) z.insertlast(k); break; while(!temp.isempty()) y.insertlast(temp.removefirst()); return z; public static LinkList difference(linklist x,linklist y) LinkList z=new LinkList(); LinkList temp=new LinkList(); while(!x.isempty()) Object k=x.removefirst(); boolean flag=true; while(!y.isempty()) temp.insertlast(y.getfirst()); if(k.equals(y.removefirst())) flag=false; break; if(flag) z.insertlast(k); while(!temp.isempty()) y.insertlast(temp.removefirst()); return z; public static LinkList union(linklist x,linklist y) return merge(difference(x, y), y); 11