cop 3503 fall 2012 shayan javed lecture 18
DESCRIPTION
COP 3503 FALL 2012 Shayan Javed Lecture 18. Programming Fundamentals using Java. Data Structures. So far. Looked at Arrays and ArrayLists as our data structures. So far. Looked at Arrays and ArrayLists as our data structures Very useful, but not always the best options. So far. - PowerPoint PPT PresentationTRANSCRIPT
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.