CS 11 - Lesson 9 PDF

Data Structures
Linked Lists
Stack
Queue
Introduction to Data Structures

CS 11 - Introduction to Computer Programming I
Jan Michael C. Yap

janmichaelyap@gmail.com
Department of Computer Science
University of the Philippines Diliman
JMC Yap CS 11 - Intro to Data Structures

Data Structures
Linked Lists
Stack
Queue
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Linked Lists
Stack
Queue
Topics
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Linked Lists
Stack
Queue
Data Types and Data Structures
A data type is a kind of data that variables may hold in a

programming language plus the operations automatically
provided
E.g. character, integer, and floating point

Data Structures
Linked Lists
Stack
Queue

provided
An abstract data type (ADT) is a set of data elements and
the set of operations defined on the data elements

Data Structures
Linked Lists
Stack
Queue

provided
Linked lists
Stack
Queue

Data Structures
Linked Lists
Stack
Queue

provided
Linked lists
Stack
Queue
A data structure is an implementation or realization of an
ADT in terms of language data types or other data structures
such that operations on the data structure are expressible in
terms of directly executable procedures

Data Structures
Linked Lists Background
Stack C implementation
Queue
Topics
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Queue
Topics
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Queue
Linked lists
Sequential or contiguous design
E.P. Quiwa, ”Data Structures”, Alexan Publishing

Data Structures
Queue
Linked lists
Sequential or contiguous design
Linked design

Data Structures
Queue
Topics
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Queue
Dynamic memory allocation: sizeof, malloc, free

Data Structures
Queue

sizeof operator: gets the required memory size (in bytes) to
represent data
sizeof(<data type>)
sizeof <expression>

Data Structures
Queue

represent data
sizeof(<data type>)
sizeof <expression>
malloc function: allocate memory with the specified amount
(in bytes) ;
(<data type> *) malloc(<size in bytes>)

Data Structures
Queue

represent data
sizeof(<data type>)
sizeof <expression>
(in bytes) ;
The (<data type> *) part is called explicit type casting.
More particularly, we are type casting the allocated memory
into a pointer with type <data type>

Data Structures
Queue

represent data
sizeof(<data type>)
sizeof <expression>
(in bytes) ;
The (<data type> *) part is called explicit type casting.
More particularly, we are type casting the allocated memory
into a pointer with type <data type>
free function: deallocates memory given to a particular
(pointer) variable
free(<pointer variable>)
Data Structures
Queue
Declaring and initializing a linked list

Data Structures
Queue
Declaring and initializing a linked list
/* The linked list we are implementing is a singly-linked list, to be exact. */

typedef struct Node {
int data;
struct Node *link;
} Node;
typedef struct Linked_List {

Node *head;
} Linked_List;
void initialize_list(Linked_List *list) {

list->head = NULL;
}
int is_list_empty(Linked_List *list) {

return (list->head == NULL);
}

Data Structures
Queue
Inserting into a linked list

Data Structures
Queue
Inserting into a linked list
/* Assume that we can only insert at the "right" end of the list. */
void insert_into_list(Linked_List *list, int x) {
Node *runner = list->head;
Node *node = (Node *) malloc (sizeof(Node));
if (node == NULL) {
printf("Sorry, the computer can no longer allocate memory.\n");
} else {
node->data = x;
node->link=NULL;
if (is_list_empty(list)) {
list->head = node;
} else {
while (runner->link != NULL) {
runner = runner->link;
}
runner->link = node;
}
}
}

Data Structures
Queue
Print contents of a linked list

Data Structures
Queue
Print contents of a linked list
void print_list(Linked_List *list) {

printf("List is empty.\n");;
} else {
printf("The contents of the list are:\n ");
while (runner != NULL) {
printf("%d ", runner->data);
}
printf("\n");
}
}

Data Structures
Queue
Destroy a linked list

Data Structures
Queue
Destroy a linked list
/* IMPORTANT! Since we allocated memory, we must also deallocate memory. */

void destroy_list(Linked_List *list) {
printf("List is empty.\n");;
} else {
while (list->head != NULL) {
list->head = list->head->link;
free(runner);
runner = list->head;
}
}
}

Data Structures
Queue
Sample main function
main() {
Linked_List list;
initialize_list(&list);
insert_into_list(&list, 1);
print_list(&list);
destroy_list(&list);
}

Data Structures
Queue
Topics
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Queue
Topics
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Queue
Stack

Data Structures
Queue
Topics
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Queue
Declaring and initializing a stack

Data Structures
Queue
Declaring and initializing a stack
typedef struct Stack_Node {

int data;
struct Stack_Node *link;
} Stack_Node;
typedef struct Stack {

Stack_Node *top;
} Stack;
void initialize_stack(Stack *stack) {

stack->top = NULL;
}
int is_stack_empty(Stack *stack) {

return (stack->top == NULL);
}

Data Structures
Queue
Inserting into a stack

Data Structures
Queue
Inserting into a stack
/* Insertion into a stack is termed as push. */

void push(Stack *stack, int x) {
Stack_Node *node = (Stack_Node *) malloc (sizeof(Stack_Node));
if (node == NULL) {
} else {
node->data = x;
node->link=NULL;
if (is_stack_empty(stack)) {
stack->top = node;
} else {
node->link = stack->top;
stack->top = node;
}
}
}

Data Structures
Queue
Deleting from a stack

Data Structures
Queue
Deleting from a stack
/* Deletion from a stack is termed as pop. */

void pop(Stack *stack) {
Stack_Node *node = stack->top;
int x;
printf("Stack is empty.\n");
} else {
stack->top = stack->top->link;
x = node->data;
free(node);
printf("%d was deleted from the stack.\n", x);
}
}

Data Structures
Queue
Print contents of a stack

Data Structures
Queue
Print contents of a stack
/* We print the contents of the stack from topmost to bottommost element. */

void print_stack(Stack *stack) {
Stack_Node *runner = stack->top;
printf("Stack is empty.\n");
} else {
printf("The contents of the stack, from topmost to bottommost, are:\n ");
}
printf("\n");
}
}

Data Structures
Queue
main() {
Stack stack;
initialize_stack(&stack);
push(&stack, -3);
push(&stack, -5);
push(&stack, 14);
push(&stack, 2);
print_stack(&stack);
pop(&stack);
pop(&stack);
pop(&stack);
pop(&stack);
pop(&stack);
}

Data Structures
Queue
Topics
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Queue
Topics
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Queue
Queue

Data Structures
Queue
Queue
The part of the queue where insertion is allowed is termed as

the rear.

Data Structures
Queue
Queue
The part of the queue where insertion is allowed is termed as

the rear.
The part of the queue where deletion is allowed is termed as
the front.

Data Structures
Queue
Topics
1 Data Structures
2 Linked Lists
Background
C implementation
3 Stack
Background
C implementation
4 Queue
Background
C implementation

Data Structures
Queue
Declaring and initializing a queue

Data Structures
Queue
Declaring and initializing a queue
typedef struct Queue_Node {

int data;
struct Queue_Node *link;
} Queue_Node;
typedef struct Queue {

Queue_Node *front;
Queue_Node *rear;
} Queue;
void initialize_queue(Queue *queue) {

queue->front = NULL;
queue->rear = NULL;
}
int is_queue_empty(Queue *queue) {

return (???);
}

Data Structures
Queue
Inserting into a queue

Data Structures
Queue
Inserting into a queue
/* Insertion into a queue is termed as enqueue. */

void enqueue(Queue *queue, int x) {
Queue_Node *node = (Queue_Node *) malloc (sizeof(Queue_Node));
if (node == NULL) {
} else {
node->data = x;
node->link=NULL;
if (is_queue_empty(queue)) {
queue->front = node;
queue->rear = node;
} else {
queue->rear->link = node;
queue->rear = node;
}
}
}

Data Structures
Queue
Deleting from a queue

Data Structures
Queue
Deleting from a queue
/* Deletion from a queue is termed as dequeue. */

void dequeue(Queue *queue) {
Queue_Node *node = queue->front;
int x;
printf("Queue is empty.\n");
} else {
queue->front = queue->front->link;
x = node->data;
free(node);
printf("%d was deleted from the queue.\n", x);
}
}

Data Structures
Queue
Print contents of a queue

Data Structures
Queue
Print contents of a queue
/* We print the contents of the queue from front to rear element. */

void print_queue(Queue *queue) {
Queue_Node *runner = queue->front;
printf("Queue is empty.\n");
} else {
printf("The contents of the queue, from front to rear, are:\n ");
}
printf("\n");
}
}

Data Structures
Queue

main() {
Queue queue;
initialize_queue(&queue);
enqueue(&queue, 22);
enqueue(&queue, -72);
enqueue(&queue, 5);
print_queue(&queue);
dequeue(&queue);
dequeue(&queue);
dequeue(&queue);
dequeue(&queue);
dequeue(&queue);
dequeue(&queue);
}
Data Structures
Linked Lists
Stack
Queue
END OF LESSON 9

CS 11 - Lesson 9 PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

CS 11 - Lesson 9 PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Data Structures

Introduction to Data Structures

Jan Michael C. Yap

JMC Yap CS 11 - Intro to Data Structures

JMC Yap CS 11 - Intro to Data Structures

JMC Yap CS 11 - Intro to Data Structures

Data Types and Data Structures

A data type is a kind of data that variables may hold in a

JMC Yap CS 11 - Intro to Data Structures

Data Types and Data Structures

A data type is a kind of data that variables may hold in a

JMC Yap CS 11 - Intro to Data Structures

Data Types and Data Structures

A data type is a kind of data that variables may hold in a

JMC Yap CS 11 - Intro to Data Structures

Data Types and Data Structures

A data type is a kind of data that variables may hold in a

JMC Yap CS 11 - Intro to Data Structures

JMC Yap CS 11 - Intro to Data Structures

JMC Yap CS 11 - Intro to Data Structures

Sequential or contiguous design

E.P. Quiwa, ”Data Structures”, Alexan Publishing

Sequential or contiguous design

E.P. Quiwa, ”Data Structures”, Alexan Publishing

JMC Yap CS 11 - Intro to Data Structures

Dynamic memory allocation: sizeof, malloc, free

JMC Yap CS 11 - Intro to Data Structures

Dynamic memory allocation: sizeof, malloc, free

JMC Yap CS 11 - Intro to Data Structures

Dynamic memory allocation: sizeof, malloc, free

JMC Yap CS 11 - Intro to Data Structures

Dynamic memory allocation: sizeof, malloc, free

JMC Yap CS 11 - Intro to Data Structures

Dynamic memory allocation: sizeof, malloc, free

Declaring and initializing a linked list

JMC Yap CS 11 - Intro to Data Structures

Declaring and initializing a linked list

/* The linked list we are implementing is a singly-linked list, to be exact. */

typedef struct Linked_List {

void initialize_list(Linked_List *list) {

int is_list_empty(Linked_List *list) {

JMC Yap CS 11 - Intro to Data Structures

Inserting into a linked list

JMC Yap CS 11 - Intro to Data Structures

Inserting into a linked list

JMC Yap CS 11 - Intro to Data Structures

Print contents of a linked list

JMC Yap CS 11 - Intro to Data Structures

Print contents of a linked list

void print_list(Linked_List *list) {

JMC Yap CS 11 - Intro to Data Structures

Destroy a linked list

JMC Yap CS 11 - Intro to Data Structures

Destroy a linked list

/* IMPORTANT! Since we allocated memory, we must also deallocate memory. */

JMC Yap CS 11 - Intro to Data Structures

Sample main function

JMC Yap CS 11 - Intro to Data Structures

JMC Yap CS 11 - Intro to Data Structures

JMC Yap CS 11 - Intro to Data Structures

E.P. Quiwa, ”Data Structures”, Alexan Publishing

JMC Yap CS 11 - Intro to Data Structures

Declaring and initializing a stack