1/ 124 COP 3503 FALL 2012 SHAYAN JAVED LECTURE 18 Programming Fundamentals using Java 1.

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...


Very useful, but not always the best options

5/ 124

So far...


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


Basically...a stack of data.

10/ 124

Stack



Used when you want the oldest added data first.

11/ 124

Stack




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:


pop(): Returns the object at the top of the stack and removes it

15/ 124

Stack

Three Operations:


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


Has all the operations

21/ 124

Stack



But how does it actually store the data? (What’s the “back-end”?)

22/ 124

Stack



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



25/ 124

Queue



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


Has all the operations enqueue = add dequeue = poll

29/ 124

Queue



Interface implemented in classes like LinkedList

30/ 124

Queue



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



Can use as “back-end” data structures

33/ 124




But where do they fall short?

34/ 124




But where do they fall short? Data retrieval – excellent O(1)

35/ 124




But where do they fall short? Data retrieval – excellent O(1) Adding data

36/ 124




But where do they fall short? Data retrieval – excellent O(1) Adding data – inefficient O(n) in some cases

37/ 124




But where do they fall short? Data retrieval – excellent O(1) Adding data – inefficient O(n) in some cases

38/ 124




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


What if your application requires a lot of adds but not retrievals?

40/ 124


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


Dynamic data structure – size is not fixed, and memory is not contiguous (unlike an array)

43/ 124

Linked List



Insertion to the list is very fast – O(1) in most cases

44/ 124

Linked List



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


Stores some data and a link to the next Node.

48/ 124

Node



int null

49/ 124

Node



int int null

50/ 124

Singly-Linked List (SLL)

Nodes connected to each other

51/ 124



int int nullint

52/ 124



SLL only stores links to two nodes:

int int nullint

53/ 124



SLL only stores links to two nodes: Head node (front)

int int nullint

head

54/ 124



SLL only stores links to two nodes: Head node (front) Tail node (end)

int int nullint

head tail

55/ 124


Operations: LinkedList(): create an empty list

56/ 124


Operations: LinkedList(): create an empty list append(Object): add to the end

57/ 124


Operations: LinkedList(): create an empty list append(Object): add to the end insert(Object, index): add at a certain index

58/ 124


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


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


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


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


Create an Empty SLL:

63/ 124



head tail

null

64/ 124



public SLL() {

head = null;

tail = null;

}

head tail

null

65/ 124


append(Object):

66/ 124


append(Object):

Create a Node with that Object

Obj null

67/ 124


append(Object):


Obj null

head tail

68/ 124


append(Object): append another object

Obj null

head tail

69/ 124




Obj null

head tail

Obj null

70/ 124



Create a Node with that Object Make tail point to it

Obj

head tail

Obj null

71/ 124



Create a Node with that Object Make tail point to it Update tail Node

Obj

head tail

Obj null

72/ 124


size():

73/ 124


size():

Obj

head tail

Obj nullObj Obj

74/ 124


size():

Obj

head tail

Obj nullObj Obj

temp

75/ 124


size():

Obj

head tail

Obj nullObj Obj

temp

76/ 124


size():

Obj

head tail

Obj nullObj Obj

temp

77/ 124


size():

Obj

head tail

Obj nullObj Obj

temp

78/ 124


size():

Obj

head tail

Obj nullObj Obj

temp

79/ 124


size():

Keep incrementing until you reach “null”.

Obj

head tail

Obj nullObj Obj

temp

80/ 124


get(Object): Returns index of first Node with that object

81/ 124



You should know how to traverse

82/ 124




Compare object with equals() method

83/ 124




Compare object with equals() method Return index if found -1 if not found

84/ 124


remove(Object):

Obj

head tail

Obj nullObj Obj

85/ 124


remove(Object):

Obj

head tail

Obj nullObj Obj

86/ 124


remove(Object):

Obj

head tail

Obj nullObj Obj

87/ 124


remove(Object):

Obj

head tail

Obj nullObj

Obj

88/ 124


remove(Object):

Obj

head tail

Obj nullObj

89/ 124


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


So now we know how to: append, prepend, insert

91/ 124


So now we know how to: append, prepend, insert find the size

92/ 124


So now we know how to: append, prepend, insert find the size find the index of a specific element

93/ 124


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


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


Sorting:

Bubble Sort Selection Sort Insertion Sort

96/ 124


Sorting:

Bubble Sort Selection Sort Insertion Sort

How many of these can you implement for Linked Lists?

97/ 124


Sorting: We should swap nodes

98/ 124



Obj

head tail

Obj nullObj Obj

99/ 124



Obj

head tail

Obj nullObj Obj

100/ 124



Obj

head tail

Obj null

Obj

Obj

101/ 124



Obj

head tail

Obj null

Obj

Obj

102/ 124



Obj

head tail

Obj null

Obj

Obj

103/ 124



Obj

head tail

Obj nullObjObj

104/ 124



How many nodes were changed?

Obj

head tail

Obj nullObjObj

105/ 124



How many nodes were changed? 3

Obj

head tail

Obj nullObjObj

106/ 124


Swap:

Obj

head tail

Obj nullObj Obj Obj

107/ 124


Swap:

Obj

head tail

Obj nullObj Obj Obj

108/ 124


Swap:

Also have to modify the ones before them

Obj

head tail

Obj nullObj Obj Obj

109/ 124


Swap:


Obj

head tail

Obj nullObj Obj Obj

node1 node2

110/ 124


Swap:


Obj

head tail

Obj nullObj Obj Obj

node1 node2

node1P node2P

111/ 124


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;


node2.next = temp;

node2P.next = node1;

}

if (node1P != null) // why?


// what about the head and tail nodes?

// update them accordingly

}

113/ 124




node2.next = node1;

}

else { // 2nd case



node2.next = temp;


}





}

114/ 124




node2.next = node1;

}

else { // 2nd case



node2.next = temp;


}





}

115/ 124




node2.next = node1;

}

else { // 2nd case



node2.next = temp;


}





}

116/ 124




node2.next = node1;

}

else { // 2nd case



node2.next = temp;


}





}

117/ 124




node2.next = node1;

}

else { // 2nd case



node2.next = temp;


}





}

118/ 124




node2.next = node1;

}

else { // 2nd case



node2.next = temp;

node2P.next = node1; // the node before node2

}





}

119/ 124




node2.next = node1;

}

else { // 2nd case



node2.next = temp;


}





}

120/ 124




node2.next = node1;

}

else { // 2nd case



node2.next = temp;


}





}

121/ 124


Sorting: So swap is not straightforward

122/ 124



Once you figure out swap, you can implement Bubble and Selection Sort

123/ 124



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.

1/ 124 COP 3503 FALL 2012 SHAYAN JAVED LECTURE 18 Programming Fundamentals using Java 1.

Documents

stack of data

queue java

kind of data

stack class java

queue interface java

linkedlist queue queue

lifo data structure

fifo data structure