1. Week 4 - Friday
CS221

2. Last time What did we talk about last time?
Doubly linked list implementation

3. Questions?

4. Project 1
Bitmap Manipulator

5. Interview question
You are given a reference to a node in a singly linked list and some data
You need to insert the data into the node in front of the node you are given a reference to
You do not have the head reference, you do not have a reference to the previous node
How do you do the insertion?

6. Generic Linked List with Iterator

7. Things aren't that different!
The generic part is really easy once you get the syntax set up
You use T instead of int (or whatever type you designed your linked lists to hold)
The trickier thing is to define an iterator class that can keep track of where you are inside the list
It has to be a non-static inner class!

8. Definition
public class LinkedList<T> implements Iterable<T> { private class Node { public T data; public Node next; public Node previous; } private class ListIterator implements Iterator<T> { public Node current; … private Node head = null; private Node tail = null; public int size = 0;

9. Constructor
Create a new iterator that points at the head of the list

10. boolean hasNext()
Whether or not there is something in the current spot in the list

11. T next()
Get the current thing in the list

12. void remove()
Remove the current item from the list (optional)

13. Other kinds of linked lists

14. Circular linked lists
Linked lists can be made circular such that the last node points back at the head node
This organization is good for situations in which we want to cycle through all of the nodes in the list repeatedly
tail 23 47 58

15. Performance of a circular linked list
Insert at front (or back)
Θ(1)
Delete at front
Delete at back costs Θ(n) unless we used doubly linked lists
Search
Θ(n)

16. Skip lists
We can design linked lists with multiple pointers in some nodes
We want ½ of the nodes to have 1 pointer, ¼ of the nodes to have 2 pointers, 1/8 of the nodes to have 3 pointers…
head X 28 X 5 41 X 3 14 29 58

17. Performance of skip lists
If ordered, search is
Θ(log n)
Go to index is
Insert at end
Delete
Totally insane, at least Θ(n)
Trees end up being a better alternative

18. Self organizing lists
We want to make items that are used frequently easy to get at
Several different approaches, mostly based on finding items repeatedly
Move to front: After finding an item, put it in the front
Transpose: After finding an item, move it up by one
Count: Keep the list ordered by how often you get a particular item (requires a counter in each node)
Ordering: Sort the list according to some feature of the data

19. Linked List Stack

20. Stack Implementations
Dynamic array
Advantages: pop and top are O(1)
Disadvantages: limited size, making push O(n) in the worst case (still O(1) amortized)
Linked list
Advantages: push, pop, and top are O(1)
Disadvantages: slightly slower than the array version, considerably more memory overhead

21. Linked list implementation
public class ListStack { private static class Node { public String data; public Node next; } private Node top = null; private int size = 0; public void push(String value) {} public String pop() {} public String peek() {} //instead of top public int size() {}

22. Linked List Push

23. Linked List Pop

24. Linked List Peek

25. Linked List Size

26. Queue Implementations
Circular array
Advantages: dequeue and front are O(1)
Disadvantages: limited size, making enqueue O(n) in the worst case (still O(1) amortized)
Linked list
Advantages: enqueue, dequeue, and front are O(1)
Disadvantages: slightly slower than the array version, considerably more memory overhead

27. Linked list implementation
class ListQueue { private class Node { public String data; public Node next; } private Node head = null; private Node tail = null; private int size = 0; public void enqueue(String value) {} public String dequeue() {} public String front() {} public int size() {}

28. Linked List Front

29. Linked List Size

30. Linked List Enqueue

31. Linked List Dequeue

32. Review

33. Week 1 Programming model Java Java Collections Framework OOP
Polymorphism
Interfaces
Threads
Exceptions
Generics
Java Collections Framework

34. Week 2 Big Oh Notation Big Omega and Big Theta Abstract Data Types
Formal definition: f(n) is O(g(n)) if and only if
f(n) ≤ c∙g(n) for all n > N
for some positive real numbers c and N
Worst-case, asymptotic, upper bound of running time
Ignore lower-order terms and constants
Big Omega and Big Theta
Abstract Data Types
Array-backed list

35. Week 3 Stacks Queues FILO data structure
Operations: push, pop, top, empty
Dynamic array implementation
Queues
FIFO data structure
Operations: enqueue, dequeue, front, empty
Circular (dynamic) array implementation
JCF implementations: Deque<T> interface
ArrayDeque<T>
LinkedList<T>

36. Week 4 Linked lists Special lists Linked list implementation of stacks
Performance issues
Single vs. double
Insert, delete, find times
Special lists
Circular
Skip
Self-organizing
Linked list implementation of stacks
Linked list implementation of queues

37. Sample Problems

38. Running time Let M and N be two integers, where M is no larger than N
Use Big Θ notation to give a tight upper bound, in terms of N, on the time that it will take to
Add M and N (by hand, using the normal algorithm)
Multiply M and N (by hand, using the normal algorithm)
Use Big Θ notation to give the same bounds but this time in terms of n, where n is the number of digits in N

39. What's the running time in Θ?
int end = n; int count = 0; for( int i = 1; i <= n; i++ ) { end /= 2; for( int j = 1; j <= end; j++ ) count++; }

40. What's the running time in Θ?
int end = n; int count = 0; for( int i = 1; i <= n*n; i+=2) count++;

41. What's the running time in Θ?
int count = 0; for( int i = 1; i <= n; i++ ) { for( int j = 1; j <= n/j; j++ ) count++; }

42. Lighten
If we increase the R, G, and B values of every pixel by 25%, the image will get lighter
Let pixels be a byte[][] array with height rows and width*3 bytes in each row
Write the code to lighten the image by 25%
To do the math, you've got to change the range from -128 – 127 to 0 – 255
Then cap the value of each color component at 255 and shift back to -128 – 127

43. Reverse a linked list Assume the following: public class List {
private static class Node {
public int data;
public Node next; }
private Node head = null; …
Write a method in List that reverses the linked list.

44. Code to reverse a linked list
public void reverse() { if( head != null ) { Node reversed = head; Node temp = head; Node rest = head.next; temp.next = null; while( rest != null ) { temp = rest; rest = rest.next; temp.next = reversed; reversed = temp; } head = reversed;

45. Palindrome Write a method that takes a CharBuffer object
The CharBuffer object has two methods:
nextChar() which extracts a char from the input stream
hasNextChar() which returns true as long as there is another char to extract
The method should return true if the input stream is a palindrome (the same backwards as forwards) and false otherwise
Use no String objects or arrays (other than the one embedded in the stack)
Hint: Use at least 3 JCF Deque (stack) objects

46. Upcoming

47. Next time…
Exam 1!

48. Reminders Finish Project 1 Exam 1 is Monday
Due tonight, September 22 by 11:59pm
Exam 1 is Monday