cop 3503 fall 2012 shayan javed lecture 18

1/ 124

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

Last-In-First-Out (LIFO) Data Structure

9/ 124

Basically...a stack of data.

10/ 124

Used when you want the oldest added data first.

11/ 124

Abstract data type (can store any kind of data).

12/ 124

Three Operations:

13/ 124

Three Operations:

push(Object): Pushes an object on top of a stack

14/ 124

Three Operations:

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

15/ 124

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

Some uses:

17/ 124

Some uses:

“Stack Frame” for method calls.

18/ 124

Some uses:

“Stack Frame” for method calls.

Used for evaluating arithmetic expressions: (prefix, postfix, infix)

19/ 124

Java provides a Stack class (java.util.Stack)

20/ 124

Has all the operations

21/ 124

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

22/ 124

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

Uses the java.util.Vector class (similar to ArrayList)

23/ 124

A First-In-First-Out (FIFO) data structure.

24/ 124

25/ 124

Often used for scheduling (handle first in line)

26/ 124

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

Java provides a Queue interface (java.util.Queue)

28/ 124

Has all the operations enqueue = add dequeue = poll

29/ 124

Interface implemented in classes like LinkedList

30/ 124

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

Basic structure – collection of linked nodes make a linked list.

47/ 124

Stores some data and a link to the next Node.

48/ 124

int null

49/ 124

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

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

64/ 124

public SLL() {

head = null;

tail = null;

head tail

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

head tail

Obj null

71/ 124

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

head tail

Obj null

72/ 124

size():

73/ 124

size():

head tail

Obj nullObj Obj

74/ 124

size():

head tail

Obj nullObj Obj

75/ 124

size():

head tail

Obj nullObj Obj

76/ 124

size():

head tail

Obj nullObj Obj

77/ 124

size():

head tail

Obj nullObj Obj

78/ 124

size():

head tail

Obj nullObj Obj

79/ 124

size():

Keep incrementing until you reach “null”.

head tail

Obj nullObj Obj

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):

head tail

Obj nullObj Obj

85/ 124

remove(Object):

head tail

Obj nullObj Obj

86/ 124

remove(Object):

head tail

Obj nullObj Obj

87/ 124

remove(Object):

head tail

Obj nullObj

88/ 124

remove(Object):

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

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

head tail

Obj nullObj Obj

99/ 124

head tail

Obj nullObj Obj

100/ 124

head tail

Obj null

101/ 124

head tail

Obj null

102/ 124

head tail

Obj null

103/ 124

head tail

Obj nullObjObj

104/ 124

How many nodes were changed?

head tail

Obj nullObjObj

105/ 124

How many nodes were changed? 3

head tail

Obj nullObjObj

106/ 124

head tail

Obj nullObj Obj Obj

107/ 124

head tail

Obj nullObj Obj Obj

108/ 124

Also have to modify the ones before them

head tail

Obj nullObj Obj Obj

109/ 124

head tail

Obj nullObj Obj Obj

node1 node2

110/ 124

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

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.

cop 3503 fall 2012 shayan javed lecture 18

stack of data

queue java

kind of data

stack class java

queue interface java

linkedlist queue queue

lifo data structure

fifo data structure

Documents

shayan sms collection

cop 3503 fall 2012 shayan javed lecture 4

cop 3503 fall 2012 shayan javed lecture 15

cop 3503 fall 2012 shayan javed lecture 8

t1a2 hbef 3503

aktiviti 1- hbef 3503

shayan ghose portfolio

1/ 47 cop 3503 fall 2012 shayan javed lecture 19 programming...

csc2457 3d & geometric deep presenter: shayan

1 / 89 cop 3503 fall 2012 shayan javed lecture 11...

shayan ahmed javed ali muhammad ameen saeed ahmed shahbaz...

cop 3503 fall 2012 shayan javed lecture 5

shayan looser

cop 3503 fall 2012 shayan javed lecture 2

3503 almashriqnews

cop 3503 fall 2012 shayan javed lecture 3

shayan solutions company presentation

t1a1 hbef 3503

€¦ · 2 draft amendment 3503 === budg/3503=== budget...

cop 3503 fall 2012 shayan javed lecture 11