Comp 249 Programming Methodology Chapter 15 Linked Data Structure - Part B Dr. Aiman Hanna...
-
Upload
lily-marsh -
Category
Documents
-
view
218 -
download
0
Transcript of Comp 249 Programming Methodology Chapter 15 Linked Data Structure - Part B Dr. Aiman Hanna...
Comp 249 Programming Methodology
Chapter 15Linked Data Structure - Part B
Dr. Aiman HannaDepartment of Computer Science & Software Engineering
Concordia University, Montreal, Canada
These slides has been extracted, modified and updated from original slides of Absolute Java 3 rd Edition by Savitch; which has originally been prepared by Rose Williams of Binghamton University. Absolute Java is published by
Pearson Education / Addison-Wesley.
Copyright © 2007 Pearson Addison-WesleyCopyright © 2013 Aiman Hanna
All rights reserved
The StackThe Stack
A stack is a way of manipulating a A stack is a way of manipulating a data structuredata structure
The data structure is not necessarily The data structure is not necessarily a linked data structurea linked data structure A stack removes items in the reverse A stack removes items in the reverse
order of which they were inserted into order of which they were inserted into the structure (LIFO: Last In First Out)the structure (LIFO: Last In First Out)
A linked list that inserts and deletes A linked list that inserts and deletes only at the head of the list is a stackonly at the head of the list is a stack
15-2
The QueueThe Queue A queue is a way of manipulating a data A queue is a way of manipulating a data
structurstructur The insertion and deletion are in a The insertion and deletion are in a
first-in/first-out fashion (FIFO) like a line at a first-in/first-out fashion (FIFO) like a line at a bankbank Customers add themselves to the end of the line Customers add themselves to the end of the line
and are served from the front of the lineand are served from the front of the line The data structure can be a linked list, or The data structure can be a linked list, or
other structures, such as arraysother structures, such as arrays In the case of a linked data structure, it is In the case of a linked data structure, it is
easier to perform the manipulation if the list easier to perform the manipulation if the list has pointers at both ends (head and tail)has pointers at both ends (head and tail) Nodes are removed from the Nodes are removed from the frontfront (head), and are (head), and are
added to the added to the backback (tail) (tail)
15-3
A Queue Class (Part 1 of A Queue Class (Part 1 of 5)5)
15-4
A Queue Class (Part 2 of A Queue Class (Part 2 of 5)5)
15-5
A Queue Class (Part 3 of A Queue Class (Part 3 of 5)5)
15-6
A Queue Class (Part 4 of A Queue Class (Part 4 of 5)5)
15-7
A Queue Class (Part 5 of A Queue Class (Part 5 of 5)5)
15-8
Demonstration of the Demonstration of the Queue Class (Part 1 of 2)Queue Class (Part 1 of 2)
15-9
Demonstration of the Demonstration of the Queue Class (Part 2 of 2)Queue Class (Part 2 of 2)
15-10
Running TimesRunning Times How fast is a program?How fast is a program?
"Seconds"?"Seconds"? Consider: large input? .. small input?Consider: large input? .. small input?
In order to provide proper running time, a In order to provide proper running time, a table of running time should be produced, table of running time should be produced, and should consider different input sizes and and should consider different input sizes and the program running timesthe program running times
The running times can be obtained as a value The running times can be obtained as a value of a function of a function T(N)T(N), where N is the input size , where N is the input size and and T(N)T(N) is the program running time for is the program running time for such value such value NN
19-11
Example of a Program Running Example of a Program Running TimesTimes
19-12
Consider Sorting Consider Sorting ProgramProgram
Faster on smaller input set?Faster on smaller input set? PerhapsPerhaps Might depend on "state" of setMight depend on "state" of set
"Mostly" sorted already?"Mostly" sorted already?
Consider worst-case running timeConsider worst-case running time T(N)T(N) is time taken by "hardest" case is time taken by "hardest" case
This is the case that takes longest to sortThis is the case that takes longest to sort
19-13
Counting OperationsCounting Operations
T(N) given by formula, such as:T(N) given by formula, such as:T(N) = 5N + 5T(N) = 5N + 5 "On inputs of size N program runs for"On inputs of size N program runs for
5N + 5 time units"5N + 5 time units" This time must also be "computer-This time must also be "computer-
independent"independent" Doesn’t matter how "fast" computers areDoesn’t matter how "fast" computers are So, we cannot depend on "time" for So, we cannot depend on "time" for
estimatesestimates Instead, count the number of "operations"Instead, count the number of "operations"
19-14
Counting Operations Counting Operations ExampleExample
int i = 0;int i = 0;Boolean found = false;Boolean found = false;while (( i < N) && !found)while (( i < N) && !found)
if (a[I] == target) if (a[I] == target)found = true;found = true;
else elsei++;i++;
5 operations per loop iteration:5 operations per loop iteration:<, &&, !, [ ], ==, ++<, &&, !, [ ], ==, ++
After N iterations, final three: <, &&, !After N iterations, final three: <, &&, ! So: 6N+5 operations when target not foundSo: 6N+5 operations when target not found
19-15
Big-O NotationBig-O Notation
Recall: 6N+5 operations in "worst-case"Recall: 6N+5 operations in "worst-case" Expressed in "Big-O" notationExpressed in "Big-O" notation
Some constant "c" factor whereSome constant "c" factor wherec(6N+5) is actual running timec(6N+5) is actual running time
c different on different systemsc different on different systems
We say code runs in time O(6N+5)We say code runs in time O(6N+5) But typically only consider "highest term"But typically only consider "highest term"
Term with highest exponentTerm with highest exponent
O(N) hereO(N) here
19-16
Big-O TerminologyBig-O Terminology
Linear running time:Linear running time: O(N)—directly proportional to input size O(N)—directly proportional to input size
NN Quadratic running time:Quadratic running time:
O(NO(N22) ) Logarithmic running time:Logarithmic running time:
O(log N)O(log N) Typically "log base 2"Typically "log base 2" Very fast algorithms!Very fast algorithms!
19-17
Display 15.32 Display 15.32 Comparison of Running TimesComparison of Running Times
19-18
Efficiency of Linked ListsEfficiency of Linked Lists
Find method for linked listFind method for linked list May have to search entire listMay have to search entire list On average would expect to search half On average would expect to search half
of the list, or n/2of the list, or n/2 In big-O notation, this is O(n)In big-O notation, this is O(n)
Adding to a linked listAdding to a linked list When adding to the start we only When adding to the start we only
reassign some referencesreassign some references Constant time or O(1)Constant time or O(1)
15-19
Hash TablesHash Tables A hash table or hash map is a data A hash table or hash map is a data
structure that efficiently stores and structure that efficiently stores and retrieves data from memoryretrieves data from memory
Here we discuss a hash table that uses Here we discuss a hash table that uses an array in combination with singly an array in combination with singly linked listslinked lists
Uses a hash functionUses a hash function Maps an object to a keyMaps an object to a key In our example, a string to an integerIn our example, a string to an integer
See HashTable1.javaSee HashTable1.java
17-20
Simple Hash Function Simple Hash Function for Stringsfor Strings
Sum the ASCII value of every Sum the ASCII value of every character in the string and then character in the string and then compute the modulus of the sum compute the modulus of the sum using the size of the fixed array. using the size of the fixed array.
17-21
private int computeHash(String s){ int hash = 0; for (int i = 0; i < s.length(); i++) { hash += s.charAt(i); } return hash % SIZE; // SIZE = 10 in example}
Example: “dog” = ASCII 100, 111, 103Hash = (100 + 111 + 103) % 10 = 4
Hash Table IdeaHash Table Idea StorageStorage
Make an array of fixed size, 10 for instanceMake an array of fixed size, 10 for instance In each array element store a linked listIn each array element store a linked list To add an item, map (i.e. hash) it to one of To add an item, map (i.e. hash) it to one of
the 10 array elements, then add it to the the 10 array elements, then add it to the linked list at that locationlinked list at that location
RetrievalRetrieval To look up an item, determine its hash code To look up an item, determine its hash code
then search the linked list at the then search the linked list at the corresponding array slot for the itemcorresponding array slot for the item
17-22
Constructing a Hash Constructing a Hash Table Table
(1 of 2)(1 of 2)1. Existing hash table initialized with ten empty linked lists
empty empty empty empty empty empty empty empty empty empty
0 1 2 3 4 5 6 7 8 9
hashArray = new LinkedList3[SIZE]; // SIZE = 10
hashArray
2. After adding "cat" with hash of 2
empty empty empty empty null empty empty empty empty
0 1 2 3 4 5 6 7 8 9
hashArray
cat
15-23
Constructing a Hash Constructing a Hash Table Table
(2 of 2)(2 of 2)3. After adding "dog" with hash of 4 and "bird" with hash of 7
empty empty empty empty empty empty empty
0 1 2 3 4 5 6 7 8 9
hashArray
cat dog bird
4. After adding "turtle" with hash of 2 – collision and chained to linked list with "cat"
empty empty empty empty empty empty empty
0 1 2 3 4 5 6 7 8 9
hashArray
turtle dog bird
cat
15-24
Hash Table EfficiencyHash Table Efficiency Worst CaseWorst Case
Every item inserted into the table has the same Every item inserted into the table has the same hash key, the find operation may have to search hash key, the find operation may have to search through all items every time (same performance as through all items every time (same performance as a linked list, O(n) to find)a linked list, O(n) to find)
Best CaseBest Case Every item inserted into the table has a different Every item inserted into the table has a different
hash key, the find operation will only have to search hash key, the find operation will only have to search a list of size 1, very fast, O(1) to find.a list of size 1, very fast, O(1) to find.
Can decrease the chance of collisions with a Can decrease the chance of collisions with a better hash functionbetter hash function
Tradeoff: Lower chance of collision with Tradeoff: Lower chance of collision with bigger hash table, but more wasted memory bigger hash table, but more wasted memory spacespace
17-25
Set Template ClassSet Template Class A set is a collection of elements in which A set is a collection of elements in which
no element occurs more than once, and no element occurs more than once, and order has no significanceorder has no significance
We can implement a simple set that uses We can implement a simple set that uses a linked list to store the items in the seta linked list to store the items in the set
Fundamental set operations we will Fundamental set operations we will support:support: AddAdd ContainsContains UnionUnion IntersectionIntersection
17-26
Sets Using Linked ListsSets Using Linked Lists
15-27
See Sets1.java
TreesTrees Trees are a very important and widely Trees are a very important and widely
used data structureused data structure Like linked lists, they are a structure Like linked lists, they are a structure
based on nodes and links, but are more based on nodes and links, but are more complicated than linked listscomplicated than linked lists All trees have a node called the All trees have a node called the rootroot Each node in a tree can be reached by Each node in a tree can be reached by
following the links from the root to the nodefollowing the links from the root to the node There are no cycles in a tree: Following the There are no cycles in a tree: Following the
links will always lead to an "end"links will always lead to an "end"
15-28
TreesTrees A binary tree is the most common kind of treeA binary tree is the most common kind of tree
Each node in a binary tree has exactly two link Each node in a binary tree has exactly two link instance variablesinstance variables
A binary tree must satisfy the Binary Search Tree A binary tree must satisfy the Binary Search Tree Storage RuleStorage Rule
The root of the tree serves a purpose similar to that The root of the tree serves a purpose similar to that of the instance variable of the instance variable headhead in a linked list in a linked list The node whose reference is in the The node whose reference is in the rootroot instance instance
variable is called the variable is called the root noderoot node
The nodes at the "end" of the tree are called The nodes at the "end" of the tree are called leaf leaf nodesnodes Both of the link instance variables in a leaf node Both of the link instance variables in a leaf node
are are nullnull
15-29
A Binary Tree (Part 1 of A Binary Tree (Part 1 of 2)2)
15-30
Binary Search Tree Binary Search Tree Storage RuleStorage Rule
1.1. All the values in the left subtree must be All the values in the left subtree must be less than the value in the root nodeless than the value in the root node
2.2. All the values in the right subtree must All the values in the right subtree must be greater than or equal to the value in be greater than or equal to the value in the root nodethe root node
3.3. This rule is applied recursively to each of This rule is applied recursively to each of the two subtreesthe two subtrees
(The base case for the recursion is an empty tree)(The base case for the recursion is an empty tree)
See Trees1.javaSee Trees1.java15-31
Tree PropertiesTree Properties Note that a tree has a recursive structureNote that a tree has a recursive structure
Each tree has two subtrees whose root nodes Each tree has two subtrees whose root nodes are the nodes pointed to by the are the nodes pointed to by the leftNextleftNext and and rightNextrightNext of the root node of the root node
This makes it possible to process trees using This makes it possible to process trees using recursive algorithmsrecursive algorithms
If the values of a tree satisfying the Binary If the values of a tree satisfying the Binary Search Tree Storage Rule are output Search Tree Storage Rule are output using using Inorder ProcessingInorder Processing, then the values , then the values will be output in order from smallest to will be output in order from smallest to largestlargest
15-32
Inorder ProcessingInorder Processing
1.1. Process the left subtreeProcess the left subtree
2.2. Process the data in the root nodeProcess the data in the root node
3.3. Process the right subtreeProcess the right subtree
15-33
Preorder ProcessingPreorder Processing
1.1. Process the data in the root nodeProcess the data in the root node
2.2. Process the left subtreeProcess the left subtree
3.3. Process the right subtreeProcess the right subtree
15-34
Postorder ProcessingPostorder Processing
1.1. Process the left subtreeProcess the left subtree
2.2. Process the right subtreeProcess the right subtree
3.3. Process the data in the root nodeProcess the data in the root node
15-35
Efficiency of Binary Efficiency of Binary Search TreesSearch Trees
A Binary search trees that is as short as A Binary search trees that is as short as possible can be processed most efficientlypossible can be processed most efficiently A short tree is one where all paths from root to A short tree is one where all paths from root to
a leaf differ by at most one nodea leaf differ by at most one node
When this is so, the search is about as When this is so, the search is about as efficient as the binary search on a sorted efficient as the binary search on a sorted arrayarray Its worst-case running time is O(log Its worst-case running time is O(log nn), where ), where
nn is the number of nodes in the tree is the number of nodes in the tree
15-36
Efficiency of Binary Efficiency of Binary Search TreesSearch Trees
As a tree becomes more tall and thin, this As a tree becomes more tall and thin, this efficiency falls off efficiency falls off In the worst case, it is the same as that of In the worst case, it is the same as that of
searching a linked list with the same number searching a linked list with the same number of nodesof nodes
Maintaining a tree so that it remains short Maintaining a tree so that it remains short and fat, as nodes are added, is known as and fat, as nodes are added, is known as balancing the treebalancing the tree A tree maintained in this manner is called a A tree maintained in this manner is called a
balanced treebalanced tree
15-37