Presentation is loading. Please wait.

Presentation is loading. Please wait.

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

Published byWilfred Simon Modified over 9 years ago

Similar presentations

Presentation on theme: "1/ 124 COP 3503 FALL 2012 SHAYAN JAVED LECTURE 18 Programming Fundamentals using Java 1."— Presentation transcript:

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

2 2/ 124 Data Structures

3 3/ 124 So far...  Looked at Arrays and ArrayLists as our data structures

4 4/ 124 So far...  Looked at Arrays and ArrayLists as our data structures  Very useful, but not always the best options

5 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 6/ 124 Data Structures  Stack  Queue  Linked List  Trees  Graph  Hashtable  etc.

7 7/ 124 Data Structures  Stack  Queue  Linked List  Trees  Graph  Hashtable  etc.

8 8/ 124 Stack  Last-In-First-Out (LIFO) Data Structure

9 9/ 124 Stack  Last-In-First-Out (LIFO) Data Structure  Basically...a stack of data.

10 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 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 12/ 124 Stack  Three Operations:

13 13/ 124 Stack  Three Operations:  push(Object): Pushes an object on top of a stack

14 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 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 16/ 124 Stack  Some uses:

17 17/ 124 Stack  Some uses:  “Stack Frame” for method calls.

18 18/ 124 Stack  Some uses:  “Stack Frame” for method calls.  Used for evaluating arithmetic expressions:  (prefix, postfix, infix)

19 19/ 124 Stack  Java provides a Stack class (java.util.Stack)

20 20/ 124 Stack  Java provides a Stack class (java.util.Stack)  Has all the operations

21 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 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 23/ 124 Queue  A First-In-First-Out (FIFO) data structure.

24 24/ 124 Queue  A First-In-First-Out (FIFO) data structure.  Used when you want the oldest added data first.

25 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 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 27/ 124 Queue  Java provides a Queue interface (java.util.Queue)

28 28/ 124 Queue  Java provides a Queue interface (java.util.Queue)  Has all the operations  enqueue = add  dequeue = poll

29 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 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 queue = new LinkedList ();

31 31/ 124 Arrays and ArrayLists  Work well in a lot of cases.

32 32/ 124 Arrays and ArrayLists  Work well in a lot of cases.  Can use as “back-end” data structures

33 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 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 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 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 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 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 39/ 124 Arrays and ArrayLists  What if your application requires a lot of adds but not retrievals?

40 40/ 124 Arrays and ArrayLists  What if your application requires a lot of adds but not retrievals?  Use Linked Lists

41 41/ 124 Linked List  A list – a collection of linked nodes.

42 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 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 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 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 46/ 124 Node  Basic structure – collection of linked nodes make a linked list.

47 47/ 124 Node  Basic structure – collection of linked nodes make a linked list.  Stores some data and a link to the next Node.

48 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 49/ 124 Node  Basic structure – collection of linked nodes make a linked list.  Stores some data and a link to the next Node. int null

50 50/ 124 Singly-Linked List (SLL)  Nodes connected to each other

51 51/ 124 Singly-Linked List (SLL)  Nodes connected to each other int null int

52 52/ 124 Singly-Linked List (SLL)  Nodes connected to each other  SLL only stores links to two nodes: int null int

53 53/ 124 Singly-Linked List (SLL)  Nodes connected to each other  SLL only stores links to two nodes:  Head node (front) int null int head

54 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 null int headtail

55 55/ 124 Singly-Linked List (SLL)  Operations:  LinkedList():create an empty list

56 56/ 124 Singly-Linked List (SLL)  Operations:  LinkedList():create an empty list  append(Object):add to the end

57 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 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 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 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 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 62/ 124 Singly-Linked List (SLL)  Create an Empty SLL:

63 63/ 124 Singly-Linked List (SLL)  Create an Empty SLL: headtail null

64 64/ 124 Singly-Linked List (SLL)  Create an Empty SLL: public SLL() { head = null; tail = null; } headtail null

65 65/ 124 Singly-Linked List (SLL)  append(Object):

66 66/ 124 Singly-Linked List (SLL)  append(Object):  Create a Node with that Object Obj null

67 67/ 124 Singly-Linked List (SLL)  append(Object):  Create a Node with that Object Obj null headtail

68 68/ 124 Singly-Linked List (SLL)  append(Object):append another object Obj null headtail

69 69/ 124 Singly-Linked List (SLL)  append(Object):append another object  Create a Node with that Object Obj null headtail Obj null

70 70/ 124 Singly-Linked List (SLL)  append(Object):append another object  Create a Node with that Object  Make tail point to it Obj headtail Obj null

71 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 headtail Obj null

72 72/ 124 Singly-Linked List (SLL)  size():

73 73/ 124 Singly-Linked List (SLL)  size(): Obj headtail Obj null Obj

74 74/ 124 Singly-Linked List (SLL)  size(): Obj headtail Obj null Obj temp

75 75/ 124 Singly-Linked List (SLL)  size(): Obj headtail Obj null Obj temp

76 76/ 124 Singly-Linked List (SLL)  size(): Obj headtail Obj null Obj temp

77 77/ 124 Singly-Linked List (SLL)  size(): Obj headtail Obj null Obj temp

78 78/ 124 Singly-Linked List (SLL)  size(): Obj headtail Obj null Obj temp

79 79/ 124 Singly-Linked List (SLL)  size():  Keep incrementing until you reach “null”. Obj headtail Obj null Obj temp

80 80/ 124 Singly-Linked List (SLL)  get(Object): Returns index of first Node with that object

81 81/ 124 Singly-Linked List (SLL)  get(Object): Returns index of first Node with that object  You should know how to traverse

82 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 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 84/ 124 Singly-Linked List (SLL)  remove(Object): Obj headtail Obj null Obj

85 85/ 124 Singly-Linked List (SLL)  remove(Object): Obj headtail Obj null Obj

86 86/ 124 Singly-Linked List (SLL)  remove(Object): Obj headtail Obj null Obj

87 87/ 124 Singly-Linked List (SLL)  remove(Object): Obj headtail Obj null Obj

88 88/ 124 Singly-Linked List (SLL)  remove(Object): Obj headtail Obj null Obj

89 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 headtail Obj null Obj

90 90/ 124 Singly-Linked List (SLL)  So now we know how to:  append, prepend, insert

91 91/ 124 Singly-Linked List (SLL)  So now we know how to:  append, prepend, insert  find the size

92 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 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 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 95/ 124 Singly-Linked List (SLL)  Sorting:  Bubble Sort  Selection Sort  Insertion Sort

96 96/ 124 Singly-Linked List (SLL)  Sorting:  Bubble Sort  Selection Sort  Insertion Sort  How many of these can you implement for Linked Lists?

97 97/ 124 Singly-Linked List (SLL)  Sorting:  We should swap nodes

98 98/ 124 Singly-Linked List (SLL)  Sorting:  We should swap nodes Obj headtail Obj null Obj

99 99/ 124 Singly-Linked List (SLL)  Sorting:  We should swap nodes Obj headtail Obj null Obj

100 100/ 124 Singly-Linked List (SLL)  Sorting:  We should swap nodes Obj headtail Obj null Obj

101 101/ 124 Singly-Linked List (SLL)  Sorting:  We should swap nodes Obj headtail Obj null Obj

102 102/ 124 Singly-Linked List (SLL)  Sorting:  We should swap nodes Obj headtail Obj null Obj

103 103/ 124 Singly-Linked List (SLL)  Sorting:  We should swap nodes Obj headtail Obj null Obj

104 104/ 124 Singly-Linked List (SLL)  Sorting:  We should swap nodes  How many nodes were changed? Obj headtail Obj null Obj

105 105/ 124 Singly-Linked List (SLL)  Sorting:  We should swap nodes  How many nodes were changed? 3 Obj headtail Obj null Obj

106 106/ 124 Singly-Linked List (SLL)  Swap: Obj headtail Obj null Obj

107 107/ 124 Singly-Linked List (SLL)  Swap: Obj headtail Obj null Obj

108 108/ 124 Singly-Linked List (SLL)  Swap:  Also have to modify the ones before them Obj headtail Obj null Obj

109 109/ 124 Singly-Linked List (SLL)  Swap:  Also have to modify the ones before them Obj headtail Obj null Obj node1node2

110 110/ 124 Singly-Linked List (SLL)  Swap:  Also have to modify the ones before them Obj headtail Obj null Obj node1node2 node1Pnode2P

111 111/ 124 Singly-Linked List (SLL)  Swap: RESULT:  Also have to modify the ones before them  We have now seen two cases Obj headtail Obj null Obj node2node1 node1Pnode2P

112 112/ 124 Singly-Linked List (SLL) void swap(Node node1, Node node2, Node node1P, Node node2P) { if (node1.next == node2) {// side-by-side (1 st case) node1.next = node2.next; node2.next = node1; } else {// 2 nd 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 113/ 124 Singly-Linked List (SLL) void swap(Node node1, Node node2, Node node1P, Node node2P) { if (node1.next == node2) {// side-by-side (1 st case) node1.next = node2.next; node2.next = node1; } else {// 2 nd 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 114/ 124 Singly-Linked List (SLL) void swap(Node node1, Node node2, Node node1P, Node node2P) { if (node1.next == node2) {// side-by-side (1 st case) node1.next = node2.next; node2.next = node1; } else {// 2 nd 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 115/ 124 Singly-Linked List (SLL) void swap(Node node1, Node node2, Node node1P, Node node2P) { if (node1.next == node2) {// side-by-side (1 st case) node1.next = node2.next; node2.next = node1; } else {// 2 nd 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 116/ 124 Singly-Linked List (SLL) void swap(Node node1, Node node2, Node node1P, Node node2P) { if (node1.next == node2) {// side-by-side (1 st case) node1.next = node2.next; node2.next = node1; } else {// 2 nd 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 117/ 124 Singly-Linked List (SLL) void swap(Node node1, Node node2, Node node1P, Node node2P) { if (node1.next == node2) {// side-by-side (1 st case) node1.next = node2.next; node2.next = node1; } else {// 2 nd 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 118/ 124 Singly-Linked List (SLL) void swap(Node node1, Node node2, Node node1P, Node node2P) { if (node1.next == node2) {// side-by-side (1 st case) node1.next = node2.next; node2.next = node1; } else {// 2 nd 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 119/ 124 Singly-Linked List (SLL) void swap(Node node1, Node node2, Node node1P, Node node2P) { if (node1.next == node2) {// side-by-side (1 st case) node1.next = node2.next; node2.next = node1; } else {// 2 nd 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 120/ 124 Singly-Linked List (SLL) void swap(Node node1, Node node2, Node node1P, Node node2P) { if (node1.next == node2) {// side-by-side (1 st case) node1.next = node2.next; node2.next = node1; } else {// 2 nd 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 121/ 124 Singly-Linked List (SLL)  Sorting:  So swap is not straightforward

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

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

Similar presentations

Chapter 25 Lists, Stacks, Queues, and Priority Queues

Chapter 25 Lists, Stacks, Queues, and Priority Queues
Stacks, Queues, and Linked Lists

Stacks, Queues, and Linked Lists
Chapter 24 Lists, Stacks, and Queues

Chapter 24 Lists, Stacks, and Queues
Stack & Queues COP 3502.

Stack & Queues COP 3502.
Stacks & Their Applications COP 3502. Stacks  A stack is a data structure that stores information arranged like a stack.  We have seen stacks before.

Stacks & Their Applications COP Stacks  A stack is a data structure that stores information arranged like a stack.  We have seen stacks before.
Stacks, Queues, and Deques. 2 A stack is a last in, first out (LIFO) data structure Items are removed from a stack in the reverse order from the way they.

Stacks, Queues, and Deques. 2 A stack is a last in, first out (LIFO) data structure Items are removed from a stack in the reverse order from the way they.
CS Data Structures II Review COSC 2006 April 14, 2017

CS Data Structures II Review COSC 2006 April 14, 2017
Abstract Data Types (ADT) Collection –An object that can hold a list of other objects Homogeneous Collection –Contains elements all of the same type –Example:

Abstract Data Types (ADT) Collection –An object that can hold a list of other objects Homogeneous Collection –Contains elements all of the same type –Example:
1 Chapter 24 Lists Stacks and Queues. 2 Objectives F To design list with interface and abstract class (§24.2). F To design and implement a dynamic list.

1 Chapter 24 Lists Stacks and Queues. 2 Objectives F To design list with interface and abstract class (§24.2). F To design and implement a dynamic list.
Tirgul 3 Subjects of this Tirgul: Linked Lists Doubly-Linked Lists Sparse Matrices Stack Queue.

Tirgul 3 Subjects of this Tirgul: Linked Lists Doubly-Linked Lists Sparse Matrices Stack Queue.
E.G.M. Petrakisstacks, queues1 Stacks  Stack: restricted variant of list  elements may by inserted or deleted from only one end : LIFO lists  top: the.

E.G.M. Petrakisstacks, queues1 Stacks  Stack: restricted variant of list  elements may by inserted or deleted from only one end : LIFO lists  top: the.
Unit 11 1 Unit 11: Data Structures H We explore some simple techniques for organizing and managing information H This unit focuses on: Abstract Data Types.

Unit 11 1 Unit 11: Data Structures H We explore some simple techniques for organizing and managing information H This unit focuses on: Abstract Data Types.
CS102 – Data Structures Lists, Stacks, Queues, Trees, Hash Collections Framework David Davenport Spring 2002.

CS102 – Data Structures Lists, Stacks, Queues, Trees, Hash Collections Framework David Davenport Spring 2002.
1 Data Structures  We can now explore some advanced techniques for organizing and managing information  Chapter 12 of the book focuses on: dynamic structures.

1 Data Structures  We can now explore some advanced techniques for organizing and managing information  Chapter 12 of the book focuses on: dynamic structures.
Chapter 12 C Data Structures Acknowledgment The notes are adapted from those provided by Deitel & Associates, Inc. and Pearson Education Inc.

Chapter 12 C Data Structures Acknowledgment The notes are adapted from those provided by Deitel & Associates, Inc. and Pearson Education Inc.
Lecture 6: Linked Lists Linked lists Insert Delete Lookup Doubly-linked lists.

Lecture 6: Linked Lists Linked lists Insert Delete Lookup Doubly-linked lists.
Stack: Linked List Implementation Push and pop at the head of the list New nodes should be inserted at the front of the list, so that they become the top.

Stack: Linked List Implementation Push and pop at the head of the list New nodes should be inserted at the front of the list, so that they become the top.
TCSS 342, Winter 2005 Lecture Notes

TCSS 342, Winter 2005 Lecture Notes
1 Lecture 26 Abstract Data Types – IV Overview  The List ADT  Implementing Stacks as Linked List  Linked List Implementation of Queues .  Preview:

1 Lecture 26 Abstract Data Types – IV Overview  The List ADT  Implementing Stacks as Linked List  Linked List Implementation of Queues .  Preview:
Stacks, Queues, and Deques

Stacks, Queues, and Deques

Similar presentations

Ads by Google