data structures queue stack insert and delete time complexity

M269
Algorithms, Data
Structures and
Computability

Agenda
• Introduction to Data Structures.
• ADT vs. DS.
• Python Built-in Data Structures (Lists, Tuples, Sets, Dict).
• Famous Data Structures:
Stack.
Queue.
Linked Lists && Doubly Linked Lists.

Dictionaries (I)
• Store pairs of entries called items
{ 'CS' : '743-713-3350', 'UHPD' : '713-743-3333'}
• Each pair of entries contains
• A key
• A value
• Key and values are separated by a colon
• Paris of entries are separated by commas
• Dictionary is enclosed within curly braces

Usage
• Keys must be unique within a dictionary
• No duplicates
• If we have
age = {'Alice' : 25, 'Bob' :28}
then
age['Alice'] is 25 #is used for checking the value
and
age['Bob'] is 28

Dictionaries are mutable
• >>> age = {'Alice' : 25, 'Bob' : 28}
• >>> saved = age
• >>> age['Bob'] = 29
• >>> age
{'Bob': 29, 'Alice': 25}
• >>> saved
{'Bob': 29, 'Alice': 25}

Keys must be unique
• >>> age = {'Alice' : 25, 'Bob' : 28, 'Alice' : 26}
• >>> age
{'Bob': 28, 'Alice': 26} # if two value for the same key  the
last one is
the one that will be saved

Displaying contents
• >>> age = {'Alice' : 25, 'Carol': 'twenty-two'}
• >>> age.items()
dict_items([ ('Alice', 25), ('Carol', 'twenty-two')])
• >>> age.keys()
dict_keys([ 'Alice', 'Carol'])
• age.values()
dict_values([28, 25, 'twenty-two'])

Updating directories
• >>> age = {'Alice': 26 , 'Carol' : 22}
The update function either update existing value or create it if no
exist
• >>> age.update({'Bob' : 29})
• >>> age
{'Bob': 29, 'Carol': 22, 'Alice': 26}
• >>> age.update({'Carol' : 23})
• >>> age
{'Bob': 29, 'Carol': 23, 'Alice': 26}

Returning a value
• >>> age = {'Bob': 29, 'Carol': 23, 'Alice': 26}
• >>> age.get('Bob')
29
• >>> age['Bob']
29

Removing a specific item (I)
• >>> a = {'Alice' : 26, 'Carol' : 'twenty-two'}
• >>> a
{'Carol': 'twenty-two', 'Alice': 26}
• # pop function take the key remove the key and value from the dictionary and return the
value
• >>> a.pop('Carol’)
'twenty-two'
• >>> a
{'Alice': 26}

Removing a specific item (II)
• >>> a.pop('Alice')
26
• >>> a
{}

Remove the first item
# popitem()  it will select the first item in the dictionary to return and remove it
• >>> age = {'Bob': 29, 'Carol': 23, 'Alice': 26}
• >>> age.popitem()
• ('Bob', 29)
• >>> age
• {'Carol': 23, 'Alice': 26}
• >>> age.popitem()
('Carol', 23)
• >>> age
{'Alice': 26}

14
Data Types & Data Structures
• Applications/programs read data, store data temporarily,
process it and finally output results.
• What is data? Numbers, Characters, etc.
Application/
Program
Input
data
Output
data

Introduction to Data Structures

16
The Need for Data Structures
• Data structures organize data
 more efficient programs.
• More powerful computers  more complex applications.
• More complex applications demand more calculations.
• Complex computing tasks are unlike our everyday experience.
• Any organization for a collection of records can be searched,
processed in any order, or modified.
• The choice of data structure and algorithm can make the difference
between a program running in a few seconds or many days.

17
Efficiency
A solution is said to be efficient if it solves the problem within its
resource constraints.
• Space
• Time
• The cost of a solution is the amount of resources that the
solution consumes… expressed in terms of big O notation

18
Selecting a Data Structure
Select a data structure as follows:
1. Analyze the problem to determine the resource
constraints a solution must meet.
2. Determine the basic operations that must be supported.
Quantify the resource constraints for each operation.
3. Select the data structure that best meets these
requirements.

19
Abstract Data Types
Abstract Data Type (ADT): a definition for a data type solely in
terms of a set of values and a set of operations on that data
type.
Each ADT operation is defined by its inputs and outputs.
Encapsulation: Hide implementation details.

20
Data Structure
• A data structure is the physical implementation of an ADT.
• Each operation associated with the ADT is implemented by one or more subroutines in
the implementation.
• Data structure usually refers to an organization for data in main memory.
• File structure is an organization for data on peripheral storage, such as a disk
drive.
• Data structure is representation of the logical relationship existing between
individual elements of data.
• In other words, a data structure is a way of organizing all data items that
considers not only the elements stored but also their relationship to each other.

21
Logical vs. Physical Form
Data items have both a logical and a physical form.
Logical form: definition of the data item within an ADT.
• Ex: Integers in mathematical sense: +, -
Physical form: implementation of the data item within a data
structure.
• Ex: 16/32 bit integers, overflow.

What is Program
• Data structure affects the design of both structural & functional aspects of a program.
Program=algorithm + Data Structure
• You know that a algorithm is a step by step procedure to solve a particular function.
• A Set of Instructions
• Data Structures + Algorithms
• Data Structure = A Container stores Data
• Algorithm = Logic + Control
• That means, algorithm is a set of instruction written to carry out certain tasks & the
data structure is the way of organizing the data with their logical relationship retained.
• To develop a program of an algorithm, we should select an appropriate data structure
for that algorithm.
• Therefore algorithm and its associated data structures from a program.

Functions of Data Structures
• The most commonly used operation on data
structure are broadly categorized into following
types:
• Create.
• Insert
• Delete
• update
Some DS need extra functions
• Selection.
• Searching.
• Sorting.
• Merging.
Insertion needs sometime
• Index.
• Key.
• Position.
• Priority.

Common Data Structures
• List
• Set
• Tuple
• Dictionary
• Stack
• Queue
• Linked List
• Tree
• Heap
• Hash Table
• Priority Queue
this lecture
through next lectures
https://www.youtube.com/watch?v=R-HLU9Fl5ug
Video tutorial: (in Python)
https://www.programiz.com/python-programming/list
Interactive tutorial: (in Python)
https://www.programiz.com/python-programming/set
https://www.programiz.com/python-programming/tuple
https://www.programiz.com/python-programming/dictionary

Stack Data Structure
Visualize the Stack:
https://visualgo.net/en/list

26
The Stack ADT
• The Stack ADT stores arbitrary
objects
• Insertions and deletions follow
the last-in first-out scheme
• Think of a spring-loaded plate
dispenser
• Main stack operations:
• push(object): inserts an element
• object pop(): removes and returns
the last inserted element
• Auxiliary stack operations:
• object top(): returns the last
inserted element without
removing it
• integer len(): returns the
number of elements stored
• boolean is_empty(): indicates
whether no elements are stored

Applications of Stacks
• Direct applications
• Page-visited history in a Web browser
• Undo sequence in a text editor
• Chain of method calls in a language that supports recursion
• Indirect applications
• Auxiliary data structure for algorithms
• Component of other data structures

List-based Stack
• A simple way of implementing the Stack ADT uses a list
• We add elements from left to right
• A variable keeps track of the index of the top element
S
0 1 2 t
…

Performance and Limitations
•Performance
•Let n be the number of elements in the
stack
•The space used is O(n)
•Each operation runs in time O(1) (amortized
in the case of a push)

Queue Data Structure
Visualize the Queue:

The Queue ADT
• The Queue ADT stores arbitrary
objects
• Insertions and deletions follow
the first-in first-out scheme
• Insertions are at the rear of the
queue and removals are at the
front of the queue
• Main queue operations:
• enqueue(object): inserts an
element at the end of the queue
• object dequeue(): removes and
returns the element at the
front of the queue
• Auxiliary queue
operations:
• object first(): returns the
element at the front
without removing it
• integer len(): returns the
number of elements stored
• boolean is_empty():
indicates whether no
elements are stored

Applications of Queues
• Direct applications
• Waiting lists, bureaucracy
• Access to shared resources (e.g., printer)
• Multiprogramming
• Indirect applications
• Auxiliary data structure for algorithms
• Component of other data structures

Queue in Python
• Use the following three instance variables:
• _data: is a reference to a list instance with a fixed capacity.
• _size: is an integer representing the current number of elements
stored in the queue (as opposed to the length of the data list).
• _front: is an integer that represents the index within data of the
first element of the queue (assuming the queue is not empty).

Linked List Data Structure
Visualize the Queue:

Singly Linked List
A singly linked list is a
concrete data structure
consisting of a sequence of
nodes, starting from a head
pointer
Each node stores
element
link to the next node
next
elem node
A B C D

head

Inserting at the Head
1. Allocate a new node
2. Insert new element
3. Have new node point to old
head
4. Update head to point to new
node

Removing at the Head
1. Update head to point
to next node in the
list
2. Allow garbage
collector to reclaim
the former first node

Inserting at the Tail
1. Allocate a new node
2. Insert new element
3. Have new node
point to null
4. Have old last node
point to new node
5. Update tail to point
to new node

Removing at the Tail
Removing at the tail
of a singly linked list
is not efficient!
There is no
constant-time way
to update the tail to
point to the previous
node

Linked Lists
Stack as a Linked List
We can implement a stack with a singly linked list
The top element is stored at the first node of the list
The space used is O(n) and each operation of the Stack ADT
takes O(1) time

t
nodes
elements

Linked Lists
Queue as a Linked List
We can implement a queue with a singly linked list
The front element is stored at the first node
The rear element is stored at the last node
The space used is O(n) and each operation of the Queue ADT
takes O(1) time
f
r

nodes
elements

Linked-List Queue in Python
Linked Lists 48

Doubly Linked List Data Struture

Doubly-Linked Lists
Doubly Linked List
• A doubly linked list provides a natural
implementation of the Node List ADT
• Nodes implement Position and store:
• element
• link to the previous node
• link to the next node
• Special trailer and header nodes
prev next
elem
trailer
header nodes/positions
elements
node
Visualize the Doubly linked List:

Insertion
• Insert a new node, q, between p and its successor.
A B X C
A B C
p
A B C
p
X
q
p q

Deletion
• Remove a node, p, from a doubly-linked list.
A B C D
p
A B C
D
p
A B C

data structures queue stack insert and delete time complexity

data structures queue stack insert and delete time complexity

Recommended

More Related Content

Similar to data structures queue stack insert and delete time complexity (20)

Recently uploaded (20)

data structures queue stack insert and delete time complexity

Editor's Notes