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