Week 4 - Friday What did we talk about last time? Linked lists You - - PowerPoint PPT Presentation

Week 4 - Friday

 What did we talk about last time?  Linked lists

 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?

 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!

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; … }

Create a new iterator that points at the head of the list

Whether or not there is something in the current spot in the list

Get the current thing in the list

Remove the current item from the list (optional)

 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

 Insert at front (or back)

• Θ(1)

 Delete at front

• Θ(1)
• Delete at back costs Θ(n) unless we used doubly linked lists

 Search

• Θ(n)

 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 14 5 3 29 28 41 58

X X X

 If ordered, search is

• Θ(log n)

 Go to index is

• Θ(log n)

 Insert at end

• Θ(log n)

 Delete

• Totally insane, at least Θ(n)

 Trees end up being a better alternative

 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

 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

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() {} }

 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

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() {} }

 Finish linked list queue implementation  Recursion

 Finish Assignment 2

• Due tonight by midnight!

 Keep working on Project 1

• Don't fall behind!