Lecture IV: Lists II

Transcription

1 Lecture IV: Lists II

2 Skip Lists

3 Skip Lists Skip Lists are a more efficient implementation of a Linked List. a Skip List is a linked list with more links which skip over various nodes. Skip Lists can be used instead of a balanced binary tree items are inserted into a binary tree randomly, the tree must be "rebalanced" every time an item is added. we will discuss binary trees at a later time. Skip Lists use a balancing technique based on probability. a random number generator helps to decide how many "levels" of links any given node in the list has. for us we will use a simulated coin flip to represent a 50% probability.

4 Skip List Example Skip List with One Level Skip List with Two Levels Skip List with Three Levels

5 Skip Lists Recall that in a normal list most operations (search, sort, insert, delete, etc.) are O(n) we have to scan node by node to perform these operations. Because the Skip List performs most operations by skipping over nodes, we can a performance increase of O(logn). Recall: O(logn) algorithms usually means you are reducing the overall data set by some fraction as you operate on the data.

6 Review: Linked List Pros and Cons Pros: Insertion and deletion can be O(1) if we insert / delete from the beginning or end of the list (assuming we keep a pointer to the tail). No waste of memory. Cons: Cannot really search a Linked List in better than O(n) time. Cannot jump around the list very easily. Skip Lists help to correct some of these cons Skip Lists can be a good implementation for a Map type data structure.

7 Skip List Properties The numbers you see here are keys: keys are unique keys are in sorted order Skip Lists have a maximum number of levels: max level can be assigned or dynamically computed as needed. our example uses a predetermined maximum number of levels Each level (on average) contains about 1/2 the number of elements of the previous level The head (in green) is a list of "dummy nodes" with no keys or values, it is just a list of pointers.

8 Choosing the Max Number of Levels According to the creator of Skip Lists (William Pugh), the maximum number of levels of a Skip List should be no smaller than: max_levels = (int)ceiling(lg2(number_of_elements)) this is based on the probability that each level higher in the list will have (on average) half the number of elements as a lower level. This level can be handled in many ways: specify the number of elements in your list and use the above formula internally to compute the max number of levels. specify the number of levels when you instantiate your list. let your implementation dynamically update the max number of levels based on the needs of the list.

9 The Node Class Each Node of the Skip List will have the following: a generic data field for the key a generic data field for the value an ArrayList of random size (representing the levels that this node can point to). this is a list of Nodes.

10 The Skip List Class This class has two data fields: a data field to store the maximum number of levels a header data field which is a dummy Node which initially points to a list of pointers that are all null. This class includes the basic methods to find, insert, and delete elements in the list.

11 Find Implementation Finding a Key (k) in the list is very simple when we follow the three cases: if k == key we found what we were looking for and we can return the value at that position. if k < next key, we go down a level (i.e. go to the next pointer in the arraylist at the current node) if k >= next key, we go to the next node in the current level. Example: Finding 35

12 Find Algorithm The current node = head For each level in the list: while next node at the current level is not null AND the key we are finding is >= the key in the next node at the current level move current forward to the next node. if we find the node we want, we will end up at the node before the one we want so we need to move the pointer forward using level 0 if current is null return false. if the key we want to find is equal to the current node's key return true other wise return false

13 Insert Algorithm Use the same find() method we saw previously to find the insertion point: this is the point before where the number would appear. While we are searching for the insertion point, keep a list of pointers that we might have to update here I have an update list in the insert algorithm at the end we will use the update list of pointers to splice the new node into the list. Once the insertion point has been found "splice" in the new node.

14 Delete Algorithm Similar to insert. Use the find algorithm to locate the node before the node we want to delete. Here we also keep an update list of pointers that we will possibly need to update. Once the deletion point has been found, "unsplice" the node you want to remove using the update list.

15 Stacks

16 Stack A stack is a list-type data structure that stores data in a certain order: LIFO (Last-in, First-Out) FILO (First-in, Last-Out) There are equivalent Think of a stack of plates. When you want to get a plate you (hopefully) take the top plate. When you want to put a plate away you (hopefully) put the plate on the top of the stack. The Stack only uses one end of its list (either the beginning or end, depending on the implementation). We call this the "top" of the Stack.

17 Stack Stacks have two main operations: push(): adding an element to the top of the Stack. pop(): removing and returning the element on the top of the Stack. underflow: trying to pop something from an empty Stack. overflow: trying to push something onto a Stack that is full.

18 Stack Implementation Stacks implementations: static arrays dynamic arrays linked lists Array / Dynamic List Implementation: Operations take constant time O(1) If there is no limit to the stack, the resize operation can be expensive. Linked List Implementation: Expands and shrinks nicely. Every option is constant time O(1). Extra memory used up by references.

19 Applications of Stacks Balancing of Symbols checking for matching ( ), " ",[ ], { }, etc. Infix to postfix conversion vs Evaluation of a postfix expression Implementing function calls Finding spans (spans in a stock market graph) Browser Back Button Undo operation in a text editor Checking Matching HTML Tags Use by another data structure.

20 Java Collections Framework: Vector & Stack The JCF (Java Collections Framework) was introduced in Java 2 Vector and Stack existed before the JCF these were redesigned to fit into JCF, but all their oldstyle methods were retained for compatibility

21 Java Collections Framework: Vector & Stack Vector is the same as ArrayList, except contains synchronized methods for accessing and modifying the vector synchronized methods prevent data corruption when the vector is accessed by two or more threads concurrently (multi-threading) If your application does not use multi-threading, most of the time ArrayLists are more efficent than Vectors. Vector extends AbstractList

22 Java Collections Framework: Vector

23 Java Collections Framework: Stack The Stack class is implemented as an extension of Vector

24 Queues

25 Queue a queue is another list type data structure that stores data in FIFO (First-in, First-out) ordering. insertions into the queue are done at the end of the queue. deletions / removals are done at the beginning of the queue Think of a line at an amusement part. People enter the line from the back and move towards and exit at the front.

26 Queue Queues have two main operations: enqueue(): adding an element to the queue de-queue(): removing an element from the queue

27 Queue Implementations Common implementations: simple circular array dynamic circular array linked list All operations are O(1) no matter the implementation. Of course there will be overhead with a dynamic list implementation due to the resizing of the list if you allow your queue to expand. Why circular arrays? With a normal array, you have to worry about continuously shifting elements to the front of the array. shifting elements as we know takes time and has a performance cost. With a "circular" array, we still have a normal array, but we treat it as if the beginning and end of the arrays were contiguous.

28 Queue Implementations With a circular array, we keep a pointer to the front and ends of the queue: when elements are added or removed from the queue, all we need to do is update where each pointer is pointing instead of shifting all of the elements. We can use the mod operator to keep the indexes within bounds and "wrap" the index around to the beginning or end as needed.

29 Applications of Queues Schedueling tasks of an operating system by order of arrival. Simulation of real-world queues (amusement park lines, deli counter ticket system, really any first-come firstserved system. Asynchronous data transfer (file IO, pipes, sockets) Wait times for customers at a call center. Determining the optimum number of cashiers to have at checkout lines given x number of people.

30 Set

31 Sets set: an efficient data structure for storing and processing nonduplicate elements. any list type data structure can be converted into a set simply have your data structure enforce that there can be no duplicate items. The Set interface extends Collection does not introduce new methods or constants it enforces that an instance of Set contains no duplicate elements (prevents duplicates from being added) AbstractSet class extends AbstractCollection partially implements Set provides concrete implements for the equals() method and the hashcode() method hash code of a set: the sum of all the hash codes of all the elements in the set

32 Sets Sets in Java can be created using three of the concrete Set classes: HashSet LinkedHashSet TreeSet

33 Title

34 HashSet A concrete class that implements Set. Has no guaranteed ordering to the elements. Constructors: no-arg: empty HashSet HashSet from an existing collection default initial capacity: 16 default load factor: 0.75 load factor is a value between 0.0 and 1.0 and measures how full a set is allowed to be before its capacity is increased capacity is usually doubled when expansion is needed high load factors decrease the space costs but increase the search time, generally 0.75 is a good tradeoff between time and space costs.

35 HashSet To make a HashSet efficient, objects added to a HashSet need to implement the hashcode() method in a way which properly disperses the hash code. This is related to the idea of hashing. We will talk about this at a later time. hashcode() is defined in Object the hash codes of two objects must be the same, if the two objects are equal two unequal objects may have the same hash code, but you should implement the hashcode() method to avoid too many such cases. most classes in the Java API implement hashcode() See Code: HashSetDemo.java CollectionMethodsWithHashSetDemo.java

36 LinkedHashSet extends HashSet with a linked-list implementation that supports an ordering of the elements in the Set. generally this is insertion order See Code: LinkedHashSetDemo.java

37 TreeSet SortedSet is a subinterface of Set guarantees the elements in the Set are sorted provides methods first() and last() to get the first and last elements in the set provides headset(toelement) and tailset(fromelement) for returning a portion of the set whose elements are less than toelement and greater than or equal to fromelement. NavigableSet extends SortedSet: provides navigation methods lower(e), floor(e), ceiling(e) and higher(e) which return elements less than, less than or equal, greater than or equal, and greater than a given element or null if there is no such element pollfirst() and polllast() remove and return the first and last elements in the TreeSet

38 TreeSet A TreeSet can be sorted according to Comparable or using a Comparator See Code: TreeSetComparableDemo.java TreeSetComparatorDemo.java See Also: SetListPerformanceDemo.java CountKeywords.java

39 Maps

40 Maps map: like a dictionary that provides a quick lookup to retrieve a value using a key (stores key/value pairs) keys are like indexes but keys could really be any data type, not just integer maps cannot contain duplicate keys sort of like the primary key of a database if you took CS-122

41 Maps Three concrete Classes for Maps: HashMap LinkedHashMap TreeMap

42 Map

43 Maps

44 Map Types HashMap efficient for locating a value, inserting an entry, deleting an entry entries are not ordered LinkedHashMap extends HashMap with linked-list implementation supports an ordering of the entries in the map generally insertion order or the order they were last accessed from least recently accessed to most recently accessed this depends on which Constructor was used to make the Map TreeMap efficient for traversing the keys in sorted order keys can be sorted using Comparable or Comparator. See Code: MapDemo.java