COP 3503 FALL 2012 Shayan Javed Lecture 18
-
Upload
ciaran-fry -
Category
Documents
-
view
38 -
download
3
description
Transcript of COP 3503 FALL 2012 Shayan Javed Lecture 18
1/ 124
1
COP 3503 FALL 2012SHAYAN JAVED
LECTURE 18
Programming Fundamentals using Java
2/ 124
Data Structures
3/ 124
So far...
Looked at Arrays and ArrayLists as our data structures
4/ 124
So far...
Looked at Arrays and ArrayLists as our data structures
Very useful, but not always the best options
5/ 124
So far...
Looked at Arrays and ArrayLists as our data structures
Very useful, but not always the best options
Going to look at some other data structures
6/ 124
Data Structures
Stack Queue Linked List Trees Graph Hashtable etc.
7/ 124
Data Structures
Stack Queue Linked List Trees Graph Hashtable etc.
8/ 124
Stack
Last-In-First-Out (LIFO) Data Structure
9/ 124
Stack
Last-In-First-Out (LIFO) Data Structure
Basically...a stack of data.
10/ 124
Stack
Last-In-First-Out (LIFO) Data Structure
Basically...a stack of data.
Used when you want the oldest added data first.
11/ 124
Stack
Last-In-First-Out (LIFO) Data Structure
Basically...a stack of data.
Used when you want the oldest added data first.
Abstract data type (can store any kind of data).
12/ 124
Stack
Three Operations:
13/ 124
Stack
Three Operations:
push(Object): Pushes an object on top of a stack
14/ 124
Stack
Three Operations:
push(Object): Pushes an object on top of a stack
pop(): Returns the object at the top of the stack and removes it
15/ 124
Stack
Three Operations:
push(Object): Pushes an object on top of a stack
pop(): Returns the object at the top of the stack and removes it
peek(): Returns the object at the top without removing it
16/ 124
Stack
Some uses:
17/ 124
Stack
Some uses:
“Stack Frame” for method calls.
18/ 124
Stack
Some uses:
“Stack Frame” for method calls.
Used for evaluating arithmetic expressions: (prefix, postfix, infix)
19/ 124
Stack
Java provides a Stack class (java.util.Stack)
20/ 124
Stack
Java provides a Stack class (java.util.Stack)
Has all the operations
21/ 124
Stack
Java provides a Stack class (java.util.Stack)
Has all the operations
But how does it actually store the data? (What’s the “back-end”?)
22/ 124
Stack
Java provides a Stack class (java.util.Stack)
Has all the operations
But how does it actually store the data? (What’s the “back-end”?)
Uses the java.util.Vector class (similar to ArrayList)
23/ 124
Queue
A First-In-First-Out (FIFO) data structure.
24/ 124
Queue
A First-In-First-Out (FIFO) data structure.
Used when you want the oldest added data first.
25/ 124
Queue
A First-In-First-Out (FIFO) data structure.
Used when you want the oldest added data first.
Often used for scheduling (handle first in line)
26/ 124
Queue
Three Operations:
enqueue(Object): Adds an object to the queue
dequeue(): Returns the object at the front of the queue and removes it
peek(): Returns the object at the front without removing it
27/ 124
Queue
Java provides a Queue interface (java.util.Queue)
28/ 124
Queue
Java provides a Queue interface (java.util.Queue)
Has all the operations enqueue = add dequeue = poll
29/ 124
Queue
Java provides a Queue interface (java.util.Queue)
Has all the operations enqueue = add dequeue = poll
Interface implemented in classes like LinkedList
30/ 124
Queue
Java provides a Queue interface (java.util.Queue)
Has all the operations enqueue = add dequeue = poll
Interface implemented in classes like LinkedList
Queue<Integer> queue = new LinkedList<Integer>();
31/ 124
Arrays and ArrayLists
Work well in a lot of cases.
32/ 124
Arrays and ArrayLists
Work well in a lot of cases.
Can use as “back-end” data structures
33/ 124
Arrays and ArrayLists
Work well in a lot of cases.
Can use as “back-end” data structures
But where do they fall short?
34/ 124
Arrays and ArrayLists
Work well in a lot of cases.
Can use as “back-end” data structures
But where do they fall short? Data retrieval – excellent O(1)
35/ 124
Arrays and ArrayLists
Work well in a lot of cases.
Can use as “back-end” data structures
But where do they fall short? Data retrieval – excellent O(1) Adding data
36/ 124
Arrays and ArrayLists
Work well in a lot of cases.
Can use as “back-end” data structures
But where do they fall short? Data retrieval – excellent O(1) Adding data – inefficient O(n) in some cases
37/ 124
Arrays and ArrayLists
Work well in a lot of cases.
Can use as “back-end” data structures
But where do they fall short? Data retrieval – excellent O(1) Adding data – inefficient O(n) in some cases
38/ 124
Arrays and ArrayLists
Work well in a lot of cases.
Can use as “back-end” data structures
But where do they fall short? Data retrieval – excellent O(1) Adding data – inefficient O(n) in some cases Fixed size – have to shift/copy to new array
39/ 124
Arrays and ArrayLists
What if your application requires a lot of adds but not retrievals?
40/ 124
Arrays and ArrayLists
What if your application requires a lot of adds but not retrievals?
Use Linked Lists
41/ 124
Linked List
A list – a collection of linked nodes.
42/ 124
Linked List
A list – a collection of linked nodes.
Dynamic data structure – size is not fixed, and memory is not contiguous (unlike an array)
43/ 124
Linked List
A list – a collection of linked nodes.
Dynamic data structure – size is not fixed, and memory is not contiguous (unlike an array)
Insertion to the list is very fast – O(1) in most cases
44/ 124
Linked List
A list – a collection of linked nodes.
Dynamic data structure – size is not fixed, and memory is not contiguous (unlike an array)
Insertion to the list is very fast – O(1) in most cases
Indexing is slow. Random access also not possible
45/ 124
Linked List
Many variations:
Singly-Linked List (can only traverse forward) Doubly-Linked List (can traverse in reverse too) Circular Linked Lists Multi-Linked Lists etc.
46/ 124
Node
Basic structure – collection of linked nodes make a linked list.
47/ 124
Node
Basic structure – collection of linked nodes make a linked list.
Stores some data and a link to the next Node.
48/ 124
Node
Basic structure – collection of linked nodes make a linked list.
Stores some data and a link to the next Node.
int null
49/ 124
Node
Basic structure – collection of linked nodes make a linked list.
Stores some data and a link to the next Node.
int int null
50/ 124
Singly-Linked List (SLL)
Nodes connected to each other
51/ 124
Singly-Linked List (SLL)
Nodes connected to each other
int int nullint
52/ 124
Singly-Linked List (SLL)
Nodes connected to each other
SLL only stores links to two nodes:
int int nullint
53/ 124
Singly-Linked List (SLL)
Nodes connected to each other
SLL only stores links to two nodes: Head node (front)
int int nullint
head
54/ 124
Singly-Linked List (SLL)
Nodes connected to each other
SLL only stores links to two nodes: Head node (front) Tail node (end)
int int nullint
head tail
55/ 124
Singly-Linked List (SLL)
Operations: LinkedList(): create an empty list
56/ 124
Singly-Linked List (SLL)
Operations: LinkedList(): create an empty list append(Object): add to the end
57/ 124
Singly-Linked List (SLL)
Operations: LinkedList(): create an empty list append(Object): add to the end insert(Object, index): add at a certain index
58/ 124
Singly-Linked List (SLL)
Operations: LinkedList(): create an empty list append(Object): add to the end insert(Object, index): add at a certain index remove(index): remove Object at index remove(Object): remove Object
59/ 124
Singly-Linked List (SLL)
Operations: LinkedList(): create an empty list append(Object): add to the end insert(Object, index): add at a certain index remove(index): remove Object at index remove(Object): remove Object get(Object): return index of Object get(index): return Object at index
60/ 124
Singly-Linked List (SLL)
Operations: LinkedList(): create an empty list append(Object): add to the end insert(Object, index): add at a certain index remove(index): remove Object at index remove(Object): remove Object get(Object): return index of Object get(index): return Object at index size(): return size of the list
61/ 124
Singly-Linked List (SLL)
Operations: LinkedList(): create an empty list append(Object): add to the end insert(Object, index): add at a certain index remove(index): remove Object at index remove(Object): remove Object get(Object): return index of Object get(index): return Object at index size(): return size of the list clear(): empty the list
62/ 124
Singly-Linked List (SLL)
Create an Empty SLL:
63/ 124
Singly-Linked List (SLL)
Create an Empty SLL:
head tail
null
64/ 124
Singly-Linked List (SLL)
Create an Empty SLL:
public SLL() {
head = null;
tail = null;
}
head tail
null
65/ 124
Singly-Linked List (SLL)
append(Object):
66/ 124
Singly-Linked List (SLL)
append(Object):
Create a Node with that Object
Obj null
67/ 124
Singly-Linked List (SLL)
append(Object):
Create a Node with that Object
Obj null
head tail
68/ 124
Singly-Linked List (SLL)
append(Object): append another object
Obj null
head tail
69/ 124
Singly-Linked List (SLL)
append(Object): append another object
Create a Node with that Object
Obj null
head tail
Obj null
70/ 124
Singly-Linked List (SLL)
append(Object): append another object
Create a Node with that Object Make tail point to it
Obj
head tail
Obj null
71/ 124
Singly-Linked List (SLL)
append(Object): append another object
Create a Node with that Object Make tail point to it Update tail Node
Obj
head tail
Obj null
72/ 124
Singly-Linked List (SLL)
size():
73/ 124
Singly-Linked List (SLL)
size():
Obj
head tail
Obj nullObj Obj
74/ 124
Singly-Linked List (SLL)
size():
Obj
head tail
Obj nullObj Obj
temp
75/ 124
Singly-Linked List (SLL)
size():
Obj
head tail
Obj nullObj Obj
temp
76/ 124
Singly-Linked List (SLL)
size():
Obj
head tail
Obj nullObj Obj
temp
77/ 124
Singly-Linked List (SLL)
size():
Obj
head tail
Obj nullObj Obj
temp
78/ 124
Singly-Linked List (SLL)
size():
Obj
head tail
Obj nullObj Obj
temp
79/ 124
Singly-Linked List (SLL)
size():
Keep incrementing until you reach “null”.
Obj
head tail
Obj nullObj Obj
temp
80/ 124
Singly-Linked List (SLL)
get(Object): Returns index of first Node with that object
81/ 124
Singly-Linked List (SLL)
get(Object): Returns index of first Node with that object
You should know how to traverse
82/ 124
Singly-Linked List (SLL)
get(Object): Returns index of first Node with that object
You should know how to traverse
Compare object with equals() method
83/ 124
Singly-Linked List (SLL)
get(Object): Returns index of first Node with that object
You should know how to traverse
Compare object with equals() method Return index if found -1 if not found
84/ 124
Singly-Linked List (SLL)
remove(Object):
Obj
head tail
Obj nullObj Obj
85/ 124
Singly-Linked List (SLL)
remove(Object):
Obj
head tail
Obj nullObj Obj
86/ 124
Singly-Linked List (SLL)
remove(Object):
Obj
head tail
Obj nullObj Obj
87/ 124
Singly-Linked List (SLL)
remove(Object):
Obj
head tail
Obj nullObj
Obj
88/ 124
Singly-Linked List (SLL)
remove(Object):
Obj
head tail
Obj nullObj
89/ 124
Singly-Linked List (SLL)
remove(Object):
remove(index) - remove at a certain index remove(Node) - remove a certain Node
Work the same way
Obj
head tail
Obj nullObj
90/ 124
Singly-Linked List (SLL)
So now we know how to: append, prepend, insert
91/ 124
Singly-Linked List (SLL)
So now we know how to: append, prepend, insert find the size
92/ 124
Singly-Linked List (SLL)
So now we know how to: append, prepend, insert find the size find the index of a specific element
93/ 124
Singly-Linked List (SLL)
So now we know how to: append, prepend, insert find the size find the index of a specific element remove an object/Node
94/ 124
Singly-Linked List (SLL)
So now we know how to: append, prepend, insert find the size find the index of a specific element remove an object/Node
What about sorting?
95/ 124
Singly-Linked List (SLL)
Sorting:
Bubble Sort Selection Sort Insertion Sort
96/ 124
Singly-Linked List (SLL)
Sorting:
Bubble Sort Selection Sort Insertion Sort
How many of these can you implement for Linked Lists?
97/ 124
Singly-Linked List (SLL)
Sorting: We should swap nodes
98/ 124
Singly-Linked List (SLL)
Sorting: We should swap nodes
Obj
head tail
Obj nullObj Obj
99/ 124
Singly-Linked List (SLL)
Sorting: We should swap nodes
Obj
head tail
Obj nullObj Obj
100/ 124
Singly-Linked List (SLL)
Sorting: We should swap nodes
Obj
head tail
Obj null
Obj
Obj
101/ 124
Singly-Linked List (SLL)
Sorting: We should swap nodes
Obj
head tail
Obj null
Obj
Obj
102/ 124
Singly-Linked List (SLL)
Sorting: We should swap nodes
Obj
head tail
Obj null
Obj
Obj
103/ 124
Singly-Linked List (SLL)
Sorting: We should swap nodes
Obj
head tail
Obj nullObjObj
104/ 124
Singly-Linked List (SLL)
Sorting: We should swap nodes
How many nodes were changed?
Obj
head tail
Obj nullObjObj
105/ 124
Singly-Linked List (SLL)
Sorting: We should swap nodes
How many nodes were changed? 3
Obj
head tail
Obj nullObjObj
106/ 124
Singly-Linked List (SLL)
Swap:
Obj
head tail
Obj nullObj Obj Obj
107/ 124
Singly-Linked List (SLL)
Swap:
Obj
head tail
Obj nullObj Obj Obj
108/ 124
Singly-Linked List (SLL)
Swap:
Also have to modify the ones before them
Obj
head tail
Obj nullObj Obj Obj
109/ 124
Singly-Linked List (SLL)
Swap:
Also have to modify the ones before them
Obj
head tail
Obj nullObj Obj Obj
node1 node2
110/ 124
Singly-Linked List (SLL)
Swap:
Also have to modify the ones before them
Obj
head tail
Obj nullObj Obj Obj
node1 node2
node1P node2P
111/ 124
Singly-Linked List (SLL)
Swap: RESULT:
Also have to modify the ones before them We have now seen two cases
Obj
head tail
Obj nullObj Obj Obj
node2 node1
node1P node2P
112/ 124
Singly-Linked List (SLL)void swap(Node node1, Node node2, Node node1P, Node node2P) {
if (node1.next == node2) { // side-by-side (1st case)
node1.next = node2.next;
node2.next = node1;
}
else { // 2nd case
Node temp = node1.next;
node1.next = node2.next;
node2.next = temp;
node2P.next = node1;
}
if (node1P != null) // why?
node1P.next = node2;
// what about the head and tail nodes?
// update them accordingly
}
113/ 124
Singly-Linked List (SLL)void swap(Node node1, Node node2, Node node1P, Node node2P) {
if (node1.next == node2) { // side-by-side (1st case)
node1.next = node2.next;
node2.next = node1;
}
else { // 2nd case
Node temp = node1.next;
node1.next = node2.next;
node2.next = temp;
node2P.next = node1;
}
if (node1P != null) // why?
node1P.next = node2;
// what about the head and tail nodes?
// update them accordingly
}
114/ 124
Singly-Linked List (SLL)void swap(Node node1, Node node2, Node node1P, Node node2P) {
if (node1.next == node2) { // side-by-side (1st case)
node1.next = node2.next;
node2.next = node1;
}
else { // 2nd case
Node temp = node1.next;
node1.next = node2.next;
node2.next = temp;
node2P.next = node1;
}
if (node1P != null) // why?
node1P.next = node2;
// what about the head and tail nodes?
// update them accordingly
}
115/ 124
Singly-Linked List (SLL)void swap(Node node1, Node node2, Node node1P, Node node2P) {
if (node1.next == node2) { // side-by-side (1st case)
node1.next = node2.next;
node2.next = node1;
}
else { // 2nd case
Node temp = node1.next;
node1.next = node2.next;
node2.next = temp;
node2P.next = node1;
}
if (node1P != null) // why?
node1P.next = node2;
// what about the head and tail nodes?
// update them accordingly
}
116/ 124
Singly-Linked List (SLL)void swap(Node node1, Node node2, Node node1P, Node node2P) {
if (node1.next == node2) { // side-by-side (1st case)
node1.next = node2.next;
node2.next = node1;
}
else { // 2nd case
Node temp = node1.next;
node1.next = node2.next;
node2.next = temp;
node2P.next = node1;
}
if (node1P != null) // why?
node1P.next = node2;
// what about the head and tail nodes?
// update them accordingly
}
117/ 124
Singly-Linked List (SLL)void swap(Node node1, Node node2, Node node1P, Node node2P) {
if (node1.next == node2) { // side-by-side (1st case)
node1.next = node2.next;
node2.next = node1;
}
else { // 2nd case
Node temp = node1.next;
node1.next = node2.next;
node2.next = temp;
node2P.next = node1;
}
if (node1P != null) // why?
node1P.next = node2;
// what about the head and tail nodes?
// update them accordingly
}
118/ 124
Singly-Linked List (SLL)void swap(Node node1, Node node2, Node node1P, Node node2P) {
if (node1.next == node2) { // side-by-side (1st case)
node1.next = node2.next;
node2.next = node1;
}
else { // 2nd case
Node temp = node1.next;
node1.next = node2.next;
node2.next = temp;
node2P.next = node1; // the node before node2
}
if (node1P != null) // why?
node1P.next = node2;
// what about the head and tail nodes?
// update them accordingly
}
119/ 124
Singly-Linked List (SLL)void swap(Node node1, Node node2, Node node1P, Node node2P) {
if (node1.next == node2) { // side-by-side (1st case)
node1.next = node2.next;
node2.next = node1;
}
else { // 2nd case
Node temp = node1.next;
node1.next = node2.next;
node2.next = temp;
node2P.next = node1; // the node before node2
}
if (node1P != null) // why?
node1P.next = node2;
// what about the head and tail nodes?
// update them accordingly
}
120/ 124
Singly-Linked List (SLL)void swap(Node node1, Node node2, Node node1P, Node node2P) {
if (node1.next == node2) { // side-by-side (1st case)
node1.next = node2.next;
node2.next = node1;
}
else { // 2nd case
Node temp = node1.next;
node1.next = node2.next;
node2.next = temp;
node2P.next = node1; // the node before node2
}
if (node1P != null) // why?
node1P.next = node2;
// what about the head and tail nodes?
// update them accordingly
}
121/ 124
Singly-Linked List (SLL)
Sorting: So swap is not straightforward
122/ 124
Singly-Linked List (SLL)
Sorting: So swap is not straightforward
Once you figure out swap, you can implement Bubble and Selection Sort
123/ 124
Singly-Linked List (SLL)
Sorting: So swap is not straightforward
Once you figure out swap, you can implement Bubble and Selection Sort
Try to implement the Sorting Methods for Linked Lists
124/ 124
Summary
Arrays/ArrayLists: useful data structures but not always optimal. Retrieval very quick, insertion can be slow
Stacks/Queues: Abstract data types useful for LIFO/FIFO storage. Implemented using arrays/SLLs
Linked Lists: Alternative to arrays – insertion is fast but retrieval is slow.