Programming. Lists, Stacks, Queues
|
|
- Jack Dwain Wilkinson
- 5 years ago
- Views:
Transcription
1 Programming Lists, Stacks, Queues
2 Summary Linked lists Create and insert elements Iterate over all elements of the list Remove elements Doubly Linked Lists Circular Linked Lists Stacks Operations and implementation using linked lists Queues Operations and implementation using linked lists 2
3 Linked Lists Definition: A dynamic data structure that consists of a sequence of records where each element contains a link to the next record in the sequence Linked lists can be singly linked, doubly linked or circular. For now, the focus will be on singly linked list Every node has a payload and a link to the next node in the list The start (head) of the list is maintained in a separate variable End of the list is indicated by NULL (sentinel) Next: circular list, stack, queue, etc 3
4 Arrays vs Linked Lists Although storing the items of S in an array A seems to be an obvious idea, it has a severe problem: Inserting an item into A exceeds the size of A, which necessitates creating another array B with size S + 1, and copying all the items in A to B This incurs more than O(1) time linked-list array size dynamic fixed indexing O(n) O(1) inserting O(1) O(n) deleting O(1) O(n) 4
5 Linked List Definition typdef struct type payload; Node *next; Node; Node *head; /*Head pointer references the first node in the linked list.*/ List of integers: 5
6 Linked Lists Considerations Items of list are usually of the same type Generally obtained from malloc/calloc Each item points to next item Last item points to null Need head to point to first item! If head is NULL, the linked list is empty Payload of item may be almost anything A single member or multiple members Including struct, union, char * or other pointers Arrays of fixed size at compile time 6
7 Usage of Linked Lists Not massive amounts of data Linear search is okay Sorting not necessary Or sometimes not possible Need to add and delete data on the fly Even from middle of list Linked list is able to grow in size as needed Does not require the shifting of items during insertions and deletions Items often need to be added to or deleted from the header/tail of the list 7
8 Manual List Manipulation Creating two nodes which are connected via a pointer #include <stdio.h> typedef struct int element; Node *next; Node; int main(int argc, char **argv) Node n1, n2; n1.element = 1; n1.next = &n2; n2.element = 2; n2.next = NULL; return 0; 8
9 Linked List Typical Operations 9
10 Creating a Node of the Linked List An element to be inserted in the list must be created dynamically Node* node_alloc(int data) Node* p=(node*)malloc(sizeof(node)); if ( p!= NULL) p >element=data; p >next=null; return p; 10
11 Iterating Over all Elements of the List Reference a node member with the -> operator p->element; A traverse operation visits each node in the linked list A pointer variable cur keeps track of the current node for ( cur = head; cur! = NULL ; cur = cur >next ) printf("%d\n", cur->element); 11
12 Adding an Item to the Head of a List #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef struct int element; Node *next; Node; // add node with payload e to front of list head // and return pointer to new node at front of list Node *InsertHead(Node *head, int e) Node *newptr = (Node *) malloc(sizeof(node)); assert(newptr!= NULL); // crashes if false newptr->element = e; newptr->next = head; return newptr; int main(int argc, char **argv) Node *list = NULL; list = InsertHead(list, 1); list = InsertHead(list, 2); 12 return 0;
13 Inserting an Element in the Middle of the List To insert a node between two nodes newptr->next = cur; prev->next = newptr; 13
14 Inserting an Element at the End Inserting at the end of a linked list is NOT a special case if cur is NULL (last element points to null) newptr->next = cur; prev->next = newptr; 14
15 Where to Insert? Determining the point of insertion or deletion for a sorted linked list of objects (in this case ints) void sortedinsert(node** head_ref, Node* new_node) Node* current; /* Case for the head end */ if (*head_ref == NULL (*head_ref)->element >= new_node->element) new_node->next = *head_ref; *head_ref = new_node; else /* Locate the node before the point of insertion */ current = *head_ref; while (current->next!= NULL && current->next->element < new_node->element) current = current->next; new_node->next = current->next; current->next = new_node; 15
16 Finding an Element in a Sorted List Exaustive search: iterate over all list elements until the desired element is found returns a pointer for the element searched Optimized search: iterate until the element to search is less than the current position in the list When the cycle is interrupted it is evaluated if the end of list was found or if the element was found node* findsorted(node *head, int x) node *aux = head; while( (aux!= NULL) && (aux->element < x ) ) aux = aux->next; if( (aux!= NULL) && (aux ->element == x)) return aux; else return NULL; 16
17 Deleting a Node from a Linked List Deleting an interior node: prev->next=cur->next; Deleting the first node: head=head->next; Return deleted node to system: cur->next = NULL; free(cur); cur=null; 17
18 Deleting a Node from a Linked List 18
19 Arrays vs. Linked Lists Size Increasing the size of a resizable array can waste storage and time Storage requirements Array-based implementations require less memory than pointerbased ones Access time Array-based: constant access time Pointer-based: the time to access the i th node depends on i Insertion and deletions Array-based: require shifting of data Pointer-based: require a list traversal 19
20 Saving and Restoring a Linked List Use an external file to preserve a list Do not write pointers to a file, only data Recreate the list from the file by placing each item at the end of the list Use a tail pointer to facilitate adding nodes to the end of the list Treat the first insertion as a special case by setting the tail to head 20
21 Passing a Linked List to a Function A function with access to a linked list s head pointer has access to the entire list Pass the head pointer to a function as a reference argument 21
22 Dummy Head Nodes Always present, even when the linked list is empty Insertion and deletion algorithms initialize prev to reference the dummy head node, rather than NULL 22
23 Circular Linked Lists Last node references the first node Every node has a successor No node in a circular linked list contains NULL 23
24 Doubly Linked Lists Frequently, is necessary to traverse a sequence in BOTH directions efficiently Solution: Use doubly-linked list where each node has two pointers Each node points to both its predecessor and its successor Circular doubly linked list: prev pointer of the dummy head node points to the last node next reference of the last node points to the dummy head node No special cases for insertions and deletions 24
25 Doubly Linked Lists typedef struct listitem type payload; struct listitem *prev; struct listitem *next; Node; Node *head, *tail; head forward traversal Doubly Linked List. next x 1 x 4 prev x 2 x 3 backward traversal 25
26 Doubly Linked Lists with Dummy Nodes (a) A circular doubly linked list with a dummy head node (b) An empty list with a dummy head node 26
27 Doubly Linked Lists To delete the node to which cur points (cur->prev)->next = cur->next; (cur->next)->prev = cur->prev; To insert a new node pointed to by newptr before the node pointed to by cur newptr->next = cur; newptr->prev = cur->prev; cur->prev = newptr; newptr->prev->next = newptr; 27
28 Some Additional Considerations Tail Pointer: The list is not represented by a single head pointer. Instead the list is represented by a head pointer which points to the first node and a tail pointer which points to the last node. The tail pointer allows operations at the end of the list such as adding an end element or appending two lists. Head struct: Special header struct (a different type from the node type) which contains a head pointer, a tail pointer. 28
29 Other Kinds Of Data Structures Stack LIFO (Last In, First Out) Items added at beginning, removed from beginning Queue FIFO (First In, First Out) Items added at end Items removed from beginning 29
30 Stacks The stack is a very common data structure used in programs. A stack data structure behavior is similar to a stack in physical terms. Considering a stack of books... we may want to do the following: Place a book on the top... Take one off the top... See if the stack is empty... Pulling out the 3rd book from the stack cannot be done directly because it might fall over. Many application areas use stacks. Line editing, bracket matching, postfix calculation, function call stack 30
31 Stack Operations Stacks hold objects, usually all of the same type. The main property of a stack is that objects go on and come off of the top of the stack. The operations needed for an abstract stack are: Push: Places an object on the top of the stack. Pop: Removes an object from the top of the stack and returns that object. IsEmpty: Reports whether the stack is empty or not. Clear: Remove all items from stack Top: Returns the object at the top of the stack Because we think of stacks in terms of the physical analogy, stacks are draw vertically (so the top is really on top). 31
32 Sample Operation stack *S = (stack *) malloc(sizeof(stack)); push(s, a ); push(s, b ); s push(s, c ); d=top(s); pop(s); push(s, e ); pop(s); top d a b c CS 201 2/16/17
33 Implementation by Linked Lists 33
34 Implementation with Arrays Since a stack usually holds a bunch of items with the same type, it can be implemented as an array. To hold the contents of the stack it is needed: An integer top that holds the index of the element at the top of the stack. Big disadvantage: cannot grow in size 34
35 Defining and Creating a Stack of Ints #include <stdio.h> typedef struct stacknode int data; struct stacknode* next; node; /* init the stack */ node* init() return NULL; 35
36 Inserting an Element in the Stack /* * Push an element into stack using the follwing operations: * - allocate memory for the new node * - copy the data for the elment created * - insert the element in the top of the stack * - returns the new top */ node* push(node* top, int data) node* new_node = (node*)malloc(sizeof(node)); if(new_node == NULL) exit(exit_failure); new_node->data = data; new_node->next = top; return new_node; 36
37 Removing an Element from the Stack /* * pop an element from the stack: * - receives a pointer to store the value of the element to be removed * - returns the new top */ node* pop(node *top,int *element) node* tmp = top; *element = top->data; top = top->next; free(tmp); return top; /* * returns 1 if the stack is empty, otherwise returns 0 */ int empty(node* top) return top == NULL? 1 : 0; 37
38 Printing the Stack Contents /* * displays the stack content */ void display(node* top) node *current = top; if(current!= NULL) printf("stack: "); do printf("%d ",current->data); current = current->next; while (current!= NULL); printf("\n"); else printf("the Stack is empty\n"); 38
39 Queues In a queue insertion is done at one end whereas deletion is done at the other end. Usually implemented with linked lists, like stacks. Queues implement the FIFO (first-in first-out) policy. There are many applications for queues: Printer queues, Telecommunication queues, Simulations, Etc. dequeue enqueue 39
40 Operations on Queues The main operations needed for a queue are: Enqueue: insert an element in the back of the queue Dequeue: remove oldest element of the queue (front) and returns it IsEmpty: checks if the queue is empty Clear: makes the queue empty dequeue() enqueue(o) isempty() getfront() createqueue() 40
41 Sample Operations queue *Q = (queue *) malloc(sizeof(queue)); enqueue(q, a ); q enqueue(q, b ); enqueue(q, c ); d=getfront(q); dequeue(q); d front back enqueue(q, e ); a b c e dequeue(q); 41
42 Queues Implementation The queue can be implemented by linked lists or by arrays Array implementation: Number of elements in the queue, since not all the elements in the array may be storing elements. Index of the element at the front. Linked List implementation: Needs two pointers: one for the head and another for the tail 42
43 Defining and Creating a Queue #include <stdio.h> typedef struct queuenode int data; struct queuenode* next; node; typedef struct node *front; node *back; int size; queue; /* create an empty queue */ void create(queue *q) q->front = NULL; q->back = NULL; q->size = 0; 43
44 Inserting an Element in the Queue /* Returns queue size */ int queuesize(queue *q) return q->size; /* Enqueing the queue */ void enque(queue *q, int data) node *new_node; new_node = (node *)malloc(sizeof(node)); if (new_node == NULL) exit(exit_failure); new_node->data = data; 44 if (q->back == NULL) q->front = new_node; else q->back->next = new_node; q->back = new_node; q->size++;
45 Removing an Element to the Queue /* Dequeing the queue */ void deque(queue *q, int *data) queue *aux; 45 if(isempty(q)) printf("error: Attempting to remove from an empty queue\n"); exit(exit_failure); *data = q->front->data; aux = q->front; q->front = q->front->next; if(q->front == NULL) q->back = NULL; free(aux); q->size--; /* Display if queue is empty or not */ bool isempty() return (q->front == NULL);
46 Printing the Queue Elements /* displaying the queue elements */ void display(queue *q) node* aux = front; if (isempty(q)) printf("queue is empty"); return; while (aux!= back) printf("%d ", aux->data); aux = aux->next; printf("%d", aux->data); 46
47 Abstract Data Types A data structure and its operations can be packaged together into an entity called an abstract data type (ADT). Lists, stacks and queues are abstract data types Clean, simple interface between the ADT and the program(s) that use it. The lower-level implementation details of the data structure are hidden from view of the rest of the program. The implementation details can be changed without altering the ADT interface. Choose different files: File to hold the type and constant definitions (ADTTypes.h) File to hold the prototypes of the functions in the ADT s (public) interface (ADTInterface.h). File to hold the implementations of the public and private functions (ADTImplementation.h) 47
48 To Review Elemento de estudo fundamental para a aprendizagem de apontadores e estruturas dinâmicas: Apontadores e Estruturas de Dados Dinâmicas em C, Fernando Mira da Silva 48
The combination of pointers, structs, and dynamic memory allocation allow for creation of data structures
Data Structures in C C Programming and Software Tools N.C. State Department of Computer Science Data Structures in C The combination of pointers, structs, and dynamic memory allocation allow for creation
More informationLinked Lists in C and C++
Linked Lists in C and C++ Professor Hugh C. Lauer CS-2303, System Programming Concepts (Slides include materials from The C Programming Language, 2 nd edition, by Kernighan and Ritchie, Absolute C++, by
More informationLinked List. April 2, 2007 Programming and Data Structure 1
Linked List April 2, 2007 Programming and Data Structure 1 Introduction head A linked list is a data structure which can change during execution. Successive elements are connected by pointers. Last element
More informationCS11001/CS11002 Programming and Data Structures (PDS) (Theory: 3-1-0)
CS11001/CS11002 Programming and Data Structures (PDS) (Theory: 3-1-0) An interesting definition for stack element The stack element could be of any data type struct stackelement int etype; union int ival;
More information8. Fundamental Data Structures
172 8. Fundamental Data Structures Abstract data types stack, queue, implementation variants for linked lists, [Ottman/Widmayer, Kap. 1.5.1-1.5.2, Cormen et al, Kap. 10.1.-10.2] Abstract Data Types 173
More informationMULTIMEDIA COLLEGE JALAN GURNEY KIRI KUALA LUMPUR
STUDENT IDENTIFICATION NO MULTIMEDIA COLLEGE JALAN GURNEY KIRI 54100 KUALA LUMPUR FIFTH SEMESTER FINAL EXAMINATION, 2014/2015 SESSION PSD2023 ALGORITHM & DATA STRUCTURE DSEW-E-F-2/13 25 MAY 2015 9.00 AM
More information1 P age DS & OOPS / UNIT II
UNIT II Stacks: Definition operations - applications of stack. Queues: Definition - operations Priority queues - De que Applications of queue. Linked List: Singly Linked List, Doubly Linked List, Circular
More informationDiscussion 2C Notes (Week 3, January 21) TA: Brian Choi Section Webpage:
Discussion 2C Notes (Week 3, January 21) TA: Brian Choi (schoi@cs.ucla.edu) Section Webpage: http://www.cs.ucla.edu/~schoi/cs32 Abstraction In Homework 1, you were asked to build a class called Bag. Let
More informationLinear Structures. Linear Structure. Implementations. Array details. List details. Operations 4/18/2013
Linear Structure Linear Structures Chapter 4 CPTR 318 Every non-empty linear structure has A unique element called first A unique element called last Every element except last has a unique successor Every
More informationLecture Notes CPSC 122 (Fall 2014) Today Quiz 7 Doubly Linked Lists (Unsorted) List ADT Assignments Program 8 and Reading 6 out S.
Today Quiz 7 Doubly Linked Lists (Unsorted) List ADT Assignments Program 8 and Reading 6 out S. Bowers 1 of 11 Doubly Linked Lists Each node has both a next and a prev pointer head \ v1 v2 v3 \ tail struct
More informationLinear Structures. Linear Structure. Implementations. Array details. List details. Operations 2/10/2013
Linear Structure Linear Structures Chapter 4 CPTR 318 Every non-empty linear structure has A unique element called first A unique element called last Every element except last has a unique successor Every
More informationESc101: (Linear, Circular, Doubly) Linked Lists, Stacks, Queues, Trees. Introduction to Linked Lists
ESc101: (Linear, Circular, Doubly) Linked Lists, Stacks, Queues, Trees Instructor: Krithika Venkataramani Semester 2, 2011-2012 1 Introduction to Linked Lists Each bead connected to the next through a
More informationQueues. A queue is a special type of structure that can be used to maintain data in an organized way.
A queue is a special type of structure that can be used to maintain data in an organized way. This data structure is commonly implemented in one of two ways: as an array or as a linked list. In either
More informationLists, Stacks and Queues in C. CHAN Hou Pong, Ken CSCI2100A Data Structures Tutorial 4
Lists, Stacks and Queues in C CHAN Hou Pong, Ken CSCI2100A Data Structures Tutorial 4 Outline Structure Linked List Overview Implementation Stack Overview Implementation Queue Overview Implementation 2
More informationAlgorithms, Data Structures, and Problem Solving
Algorithms, Data Structures, and Problem Solving Masoumeh Taromirad Hamlstad University DT4002, Fall 2016 Container Concepts containers store data container operations: insertion retrieval removal iteration
More informationLists, Stacks, and Queues. (Lists, Stacks, and Queues ) Data Structures and Programming Spring / 50
Lists, Stacks, and Queues (Lists, Stacks, and Queues ) Data Structures and Programming Spring 2016 1 / 50 Abstract Data Types (ADT) Data type a set of objects + a set of operations Example: integer set
More information3. Fundamental Data Structures
3. Fundamental Data Structures CH08-320201: Algorithms and Data Structures 233 Data Structures Definition (recall): A data structure is a way to store and organize data in order to facilitate access and
More informationDATA STRUCTURE UNIT I
DATA STRUCTURE UNIT I 1. What is Data Structure? A data structure is a mathematical or logical way of organizing data in the memory that consider not only the items stored but also the relationship to
More informationC Data Structures Stacks. Stack. push Adds a new node to the top of the stack
1 12 C Data Structures 12.5 Stacks 2 Stack New nodes can be added and removed only at the top Similar to a pile of dishes Last-in, first-out (LIFO) Bottom of stack indicated by a link member to NULL Constrained
More informationData Structures. Outline. Introduction Linked Lists Stacks Queues Trees Deitel & Associates, Inc. All rights reserved.
Data Structures Outline Introduction Linked Lists Stacks Queues Trees Introduction dynamic data structures - grow and shrink during execution Linked lists - insertions and removals made anywhere Stacks
More informationAshish Gupta, Data JUET, Guna
Introduction In general, Queue is line of person waiting for their turn at some service counter like ticket window at cinema hall, at bus stand or at railway station etc. The person who come first, he/she
More informationCS11001/CS11002 Programming and Data Structures (PDS) (Theory: 3-1-0)
CS11001/CS11002 Programming and Data Structures (PDS) (Theory: 3-1-0) The queue ADT A queue is like a "natural" queue of elements. It is an ordered list in which all insertions occur at one end called
More informationCpt S 122 Data Structures. Data Structures
Cpt S 122 Data Structures Data Structures Nirmalya Roy School of Electrical Engineering and Computer Science Washington State University Topics Introduction Self Referential Structures Dynamic Memory Allocation
More informationLinked List in Data Structure. By Prof. B J Gorad, BECSE, M.Tech CST, PHD(CSE)* Assistant Professor, CSE, SITCOE, Ichalkaranji,Kolhapur, Maharashtra
Linked List in Data Structure By Prof. B J Gorad, BECSE, M.Tech CST, PHD(CSE)* Assistant Professor, CSE, SITCOE, Ichalkaranji,Kolhapur, Maharashtra Linked List Like arrays, Linked List is a linear data
More informationCome to the PASS workshop with your mock exam complete. During the workshop you can work with other students to review your work.
It is most beneficial to you to write this mock midterm UNDER EXAM CONDITIONS. This means: Complete the mock final in 170 minutes. Work on your own. Keep your notes and textbook closed. Attempt every question.
More informationThe time and space are the two measure for efficiency of an algorithm.
There are basically six operations: 5. Sorting: Arranging the elements of list in an order (either ascending or descending). 6. Merging: combining the two list into one list. Algorithm: The time and space
More informationFrequently asked Data Structures Interview Questions
Frequently asked Data Structures Interview Questions Queues Data Structure Interview Questions How is queue different from a stack? The difference between stacks and queues is in removing. In a stack we
More informationInsertions and removals follow the Fist-In First-Out rule: Insertions: at the rear of the queue Removals: at the front of the queue
Queues CSE 2011 Fall 2009 9/28/2009 7:56 AM 1 Queues: FIFO Insertions and removals follow the Fist-In First-Out rule: Insertions: at the rear of the queue Removals: at the front of the queue Applications,
More informationComputer Science 210 Data Structures Siena College Fall Topic Notes: Linear Structures
Computer Science 210 Data Structures Siena College Fall 2018 Topic Notes: Linear Structures The structures we ve seen so far, Vectors/ArrayLists and linked list variations, allow insertion and deletion
More informationProgramming in C. Lecture Tiina Niklander. Faculty of Science
Programming in C Lecture 3 17.9.2018 Tiina Niklander Faculty of Science Department of Computer Science 17.9.2018 1 Week 2 covers Pointer basics operators and address arithmetics as function argument Precedence
More informationCS6202 - PROGRAMMING & DATA STRUCTURES I Unit IV Part - A 1. Define Stack. A stack is an ordered list in which all insertions and deletions are made at one end, called the top. It is an abstract data type
More informationDepartment of Computer Science & Engineering Indian Institute of Technology Kharagpur. Practice Sheet #13
Department of Computer Science & Engineering Indian Institute of Technology Kharagpur Topic: Stack and Queue Practice Sheet #13 Date: 04-04-2017 1. Consider the following sequence of push and pop operations
More informationcsci 210: Data Structures Stacks and Queues
csci 210: Data Structures Stacks and Queues 1 Summary Topics Stacks and Queues as abstract data types ( ADT) Implementations arrays linked lists Analysis and comparison Applications: searching with stacks
More informationAbstract Data Types 1
Abstract Data Types 1 Purpose Abstract Data Types (ADTs) Lists Stacks Queues 2 Abstract Data Types (ADTs) ADT is a set of objects together with a set of operations. Abstract in that implementation of operations
More informationList, Stack and Queue Implementation
Roy Chan CSC2100B Data Structures Tutorial 2 (Version 2) January 21, 2009 1 / 39 1 CSC2100B Online Judge Score 2 Structure 3 Linked List Overview Implementation 4 Stack Overview Implementation 5 Queue
More informationCMSC Introduction to Algorithms Spring 2012 Lecture 7
CMSC 351 - Introduction to Algorithms Spring 2012 Lecture 7 Instructor: MohammadTaghi Hajiaghayi Scribe: Rajesh Chitnis 1 Introduction In this lecture we give an introduction to Data Structures like arrays,
More informationCS350 - Exam 1 (100 Points)
Spring 2013 Name CS350 - Exam 1 (100 Points) 1.(25 points) Stacks and Queues (a) (5) For the values 4, 8, 2, 5, 7, 3, 9 in that order, give a sequence of push() and pop() operations that produce the following
More informationDynamic Data Structures
Dynamic Data Structures We have seen that the STL containers vector, deque, list, set and map can grow and shrink dynamically. We now examine how some of these containers can be implemented in C++. To
More informationEC8393FUNDAMENTALS OF DATA STRUCTURES IN C Unit 3
UNIT 3 LINEAR DATA STRUCTURES 1. Define Data Structures Data Structures is defined as the way of organizing all data items that consider not only the elements stored but also stores the relationship between
More information5 Phases of Software Life Cycle
Quiz One Answer Key 5 Phases of Software Life Cycle Lecture: 5/12 Question: #1 Waterfall Model Nyhoff, ADTs, Data Structures and Problem Solving with C++, Second Edition, 2005 Pearson Education, Inc. All
More informationLecture No.04. Data Structures
Lecture No.04 Data Structures Josephus Problem #include "CList.cpp" void main(int argc, char *argv[]) { CList list; int i, N=10, M=3; for(i=1; i
More informationCpt S 122 Data Structures. Course Review Midterm Exam # 1
Cpt S 122 Data Structures Course Review Midterm Exam # 1 Nirmalya Roy School of Electrical Engineering and Computer Science Washington State University Midterm Exam 1 When: Friday (09/28) 12:10-1pm Where:
More informationCS 1114: Implementing Search. Last time. ! Graph traversal. ! Two types of todo lists: ! Prof. Graeme Bailey.
CS 1114: Implementing Search! Prof. Graeme Bailey http://cs1114.cs.cornell.edu (notes modified from Noah Snavely, Spring 2009) Last time! Graph traversal 1 1 2 10 9 2 3 6 3 5 6 8 5 4 7 9 4 7 8 10! Two
More informationUNIT-2 Stack & Queue
UNIT-2 Stack & Queue 59 13. Stack A stack is an Abstract Data Type (ADT), commonly used in most programming languages. It is named stack as it behaves like a real-world stack, for example a deck of cards
More informationAshish Gupta, Data JUET, Guna
Categories of data structures Data structures are categories in two classes 1. Linear data structure: - organized into sequential fashion - elements are attached one after another - easy to implement because
More informationLinked Lists and other Dynamic Data Structures
Linked Lists and other Dynamic Data Structures Arrays Fixed in size Allocated in advance within a contiguous memory block Look-up is fast Resizing and Deleting is hard (reallocate and copy) Dynamic Data
More informationStack & Queue on Self-Referencing Structures
C Programming 1 Stack & Queue on Self-Referencing Structures C Programming 2 Representation of Stack struct stack { int data ; struct stack *next ; ; typedef struct stacknode node, *stack ; C Programming
More informationStack & Queue on Self-Referencing Structures
PDS: CS 11002 Computer Sc & Engg: IIT Kharagpur 1 Stack & Queue on Self-Referencing Structures PDS: CS 11002 Computer Sc & Engg: IIT Kharagpur 2 Representation of Stack struct stack { int data ; struct
More informationOutline. Computer programming. Usage of time and date functions. Date and Time: time.h. Date and Time: time.h. Time functions:
Outline Computer programming "An expert is a man who has made all the mistakes which can be made, in a narrow field." Niels Bohr Working with time I/O redirection Variable length argument lists Command
More informationAbstract Data Types. CptS 223 Advanced Data Structures. Larry Holder School of Electrical Engineering and Computer Science Washington State University
Abstract Data Types CptS 223 Advanced Data Structures Larry Holder School of Electrical Engineering and Computer Science Washington State University 1 Purpose Abstract Data Types (ADTs) Lists Stacks Queues
More informationProcedural Programming & Fundamentals of Programming
Procedural Programming & Fundamentals of Programming Lecture 4 - Summer Semester 2018 & Joachim Zumbrägel Writing a computer program is only one step in the Program Development Process 2 1 What we know
More informationLargest Online Community of VU Students
WWW.VUPages.com WWW.VUTUBE.EDU.PK http://forum.vupages.com Largest Online Community of VU Students MIDTERM EXAMINATION SEMESTER FALL 2003 CS301-DATA STRUCTURE Total Marks:86 Duration: 60min Instructions
More informationComputer programming. "An expert is a man who has made all the mistakes which can be made, in a narrow field." Niels Bohr
Computer programming "An expert is a man who has made all the mistakes which can be made, in a narrow field." Niels Bohr 1 Outline Working with time I/O redirection Variable length argument lists Command
More informationAbstract Data Types 1
Abstract Data Types 1 Purpose Abstract Data Types (ADTs) Lists Stacks Queues 2 Primitive vs. Abstract Data Types Primitive DT: programmer ADT: programmer Interface (API) data Implementation (methods) Data
More informationData Structures in C. C Programming and Software Tools. N.C. State Department of Computer Science
Data Structures in C C Programming and Software Tools N.C. State Department of Computer Science Data Structures in C The combination of pointers, structs, and dynamic memory allocation allows for creation
More informationSYSC 2006 CD. Come to the PASS workshop with your mock exam complete. During the workshop you can work with other students to review your work.
It is most beneficial to you to write this mock midterm UNDER EXAM CONDITIONS. This means: Complete the mock final in 180 minutes. Work on your own. Keep your notes and textbook closed. Attempt every question.
More informationDepartment of Electrical and Computer Engineering The University of Texas at Austin
Department of Electrical and Computer Engineering The University of Texas at Austin EE 312, Spring 2015 Aater Suleman, Instructor Owais Khan, Chirag Sakhuja, TAs Exam 1, March 4, 2015 Name: Problem 1 (20
More information[CSE10200] Programming Basis ( 프로그래밍기초 ) Chapter 9. Seungkyu Lee. Assistant Professor, Dept. of Computer Engineering Kyung Hee University
[CSE10200] Programming Basis ( 프로그래밍기초 ) Chapter 9 Seungkyu Lee Assistant Professor, Dept. of Computer Engineering Kyung Hee University CHAPTER 9 Pointers #1~2 Pointer int main () { int a; int b; int c;
More informationl Determine if a number is odd or even l Determine if a number/character is in a range - 1 to 10 (inclusive) - between a and z (inclusive)
Final Exam Exercises Chapters 1-7 + 11 Write C++ code to: l Determine if a number is odd or even CS 2308 Fall 2016 Jill Seaman l Determine if a number/character is in a range - 1 to 10 (inclusive) - between
More informationDATA STRUCUTRES. A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently.
DATA STRUCUTRES A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently. An algorithm, which is a finite sequence of instructions, each of which
More informationData Structure Series
Data Structure Series This series is actually something I started back when I was part of the Sweet.Oblivion staff, but then some things happened and I was no longer able to complete it. So now, after
More informationSolution for Data Structure
Solution for Data Structure May 2016 INDEX Q1 a 2-3 b 4 c. 4-6 d 7 Q2- a 8-12 b 12-14 Q3 a 15-18 b 18-22 Q4- a 22-35 B..N.A Q5 a 36-38 b N.A Q6- a 39-42 b 43 1 www.brainheaters.in Q1) Ans: (a) Define ADT
More informationCS301 - Data Structures Glossary By
CS301 - Data Structures Glossary By Abstract Data Type : A set of data values and associated operations that are precisely specified independent of any particular implementation. Also known as ADT Algorithm
More informationChapter 18: Stacks And Queues
Chapter 18: Stacks And Queues 18.1 Introduction to the Stack ADT Introduction to the Stack ADT Stack: a LIFO (last in, first out) data structure Examples: plates in a cafeteria return addresses for function
More informationCP2 Revision. theme: dynamic datatypes & data structures
CP2 Revision theme: dynamic datatypes & data structures structs can hold any combination of datatypes handled as single entity struct { }; ;
More informationIntroduction to Data Structures and Algorithms
Introduction to Data Structures and Algorithms Data Structure is a way of collecting and organising data in such a way that we can perform operations on these data in an effective way. Data Structures
More informationCS32 Discussion Week 3
CS32 Discussion Week 3 Muhao Chen muhaochen@ucla.edu http://yellowstone.cs.ucla.edu/~muhao/ 1 Outline Doubly Linked List Sorted Linked List Reverse a Linked List 2 Doubly Linked List A linked list where
More informationAll the above operations should be preferably implemented in O(1) time. End of the Queue. Front of the Queue. End Enqueue
Module 4: Queue ADT Dr. Natarajan Meghanathan Professor of Computer Science Jackson State University Jackson, MS 39217 E-mail: natarajan.meghanathan@jsums.edu Queue ADT Features (Logical View) A List that
More informationSolution: The examples of stack application are reverse a string, post fix evaluation, infix to postfix conversion.
1. What is the full form of LIFO? The full form of LIFO is Last In First Out. 2. Give some examples for stack application. The examples of stack application are reverse a string, post fix evaluation, infix
More information15. Stacks and Queues
COMP1917 15s2 15. Stacks and Queues 1 COMP1917: Computing 1 15. Stacks and Queues Reading: Moffat, Section 10.1-10.2 Overview Stacks Queues Adding to the Tail of a List Efficiency Issues Queue Structure
More informationLinked Lists
Linked Lists 2-17-2005 Opening Discussion What did we talk about last class? Do you have any code to show? Do you have any questions about the assignment? Can you tell me what a linked list is and what
More informationInformation Science 2
Information Science 2 - Basic Data Structures- Week 02 College of Information Science and Engineering Ritsumeikan University Today s class outline l Basic data structures: Definitions and implementation
More informationApplied Programming and Computer Science, DD2325/appcs15 PODF, Programmering och datalogi för fysiker, DA7011
Applied Programming and Computer Science, DD2325/appcs15 PODF, Programmering och datalogi för fysiker, DA7011 Autumn 2015 Lecture 5, C programming: Abstract Data Types A. Maki, C. Edlund Abstract Data
More informationChapter 19: Program Design. Chapter 19. Program Design. Copyright 2008 W. W. Norton & Company. All rights reserved.
Chapter 19 Program Design 1 Introduction Most full-featured programs are at least 100,000 lines long. Although C wasn t designed for writing large programs, many large programs have been written in C.
More informationCS24 Week 4 Lecture 2
CS24 Week 4 Lecture 2 Kyle Dewey Overview Linked Lists Stacks Queues Linked Lists Linked Lists Idea: have each chunk (called a node) keep track of both a list element and another chunk Need to keep track
More informationStacks and Queues. CSE 373 Data Structures Lecture 6
Stacks and Queues CSE 373 Data Structures Lecture 6 Readings and References Reading Sections 3.3 and 3.4 10/11/02 Stacks and Queues - Lecture 6 2 Stacks A list for which Insert and Delete are allowed only
More informationENEE150 Final Exam Review
ENEE150 Final Exam Review Topics: Pointers -- pointer definitions & initialization -- call-by-reference and Call-by-value -- pointer with arrays -- NULL pointer, void pointer, and pointer to pointer Strings
More informationBasic Data Structures (Version 7) Name:
Prerequisite Concepts for Analysis of Algorithms Basic Data Structures (Version 7) Name: Email: Concept: mathematics notation 1. log 2 n is: Code: 21481 (A) o(log 10 n) (B) ω(log 10 n) (C) Θ(log 10 n)
More informationAlgorithms and Data Structures
Algorithms and Data Structures CMPSC 465 LECTURE 10 Abstract Data Types Queues Adam Smith 1 Data Structures So far in this class: designing algorithms Inputs and outputs were specified, we wanted to design
More informationChapter 18: Stacks And Queues. Pearson Education, Inc. Publishing as Pearson Addison-Wesley
Chapter 18: Stacks And Queues Copyright 2009 Pearson Education, Inc. Copyright Publishing as Pearson 2009 Addison-Wesley Pearson Education, Inc. Publishing as Pearson Addison-Wesley 18.1 Introduction to
More information+ Abstract Data Types
Linked Lists Abstract Data Types An Abstract Data Type (ADT) is: a set of values a set of operations Sounds familiar, right? I gave a similar definition for a data structure. Abstract Data Types Abstract
More informationCS61, Fall 2012 Section 2 Notes
CS61, Fall 2012 Section 2 Notes (Week of 9/24-9/28) 0. Get source code for section [optional] 1: Variable Duration 2: Memory Errors Common Errors with memory and pointers Valgrind + GDB Common Memory Errors
More informationmalloc(), calloc(), realloc(), and free()
1 next CITS2002 CITS2002 schedule Dynamic data structures Initially, we focused on scalar and array variables, whose size is known at compile-time. More recently, we've focused on arrays of values, whose
More informationMIDTERM EXAMINATION Spring 2010 CS301- Data Structures
MIDTERM EXAMINATION Spring 2010 CS301- Data Structures Question No: 1 Which one of the following statement is NOT correct. In linked list the elements are necessarily to be contiguous In linked list the
More informationCS 231 Data Structures and Algorithms Fall DDL & Queue Lecture 20 October 22, Prof. Zadia Codabux
CS 231 Data Structures and Algorithms Fall 2018 DDL & Queue Lecture 20 October 22, 2018 Prof. Zadia Codabux 1 Agenda Mid Semester Analysis Doubly Linked List Queue 2 Administrative None 3 Doubly Linked
More informationDNHI Homework 3 Solutions List, Stacs and Queues
Solutions List, Stacs and Queues Problem 1 Given the IntegerQueue ADT below state the return value and show the content of the, initially empty, queue of Integer objects after each of the following operations.
More information! Mon, May 5, 2:00PM to 4:30PM. ! Closed book, closed notes, clean desk. ! Comprehensive (covers entire course) ! 30% of your final grade
Final Exam Review Final Exam Mon, May 5, 2:00PM to 4:30PM CS 2308 Spring 2014 Jill Seaman Closed book, closed notes, clean desk Comprehensive (covers entire course) 30% of your final grade I recommend
More informationLinked lists. Insert Delete Lookup Doubly-linked lists. Lecture 6: Linked Lists
Linked lists Insert Delete Lookup Doubly-linked lists Lecture 6: Linked Lists Object References When you declare a variable of a non-primitive type you are really declaring a reference to that object String
More informationDynamic Memory Management. Bin Li Assistant Professor Dept. of Electrical, Computer and Biomedical Engineering University of Rhode Island
Dynamic Memory Management Bin Li Assistant Professor Dept. of Electrical, Computer and Biomedical Engineering University of Rhode Island 1 Dynamic Memory Allocation Dynamic memory allocation is used to
More informationChapter 18: Stacks And Queues
Chapter 18: Stacks And Queues 18.1 Introduction to the Stack ADT Introduction to the Stack ADT Stack a LIFO (last in, first out) data structure Examples plates in a cafeteria return addresses for function
More informationQueue Linked List Implementation
SCJ2013 Data Structure & Algorithms Queue Linked List Implementation Nor Bahiah Hj Ahmad Queue Implementation Link List Pointer Based Implementation Can be implemented using linear linked list or circular
More informationCS 216 Exam 1 Fall SOLUTION
CS 216 Exam 1 Fall 2004 - SOLUTION Name: Lab Section: Email Address: Student ID # This exam is closed note, closed book. You will have an hour and fifty minutes total to complete the exam. You may NOT
More informationSequence Abstract Data Type
1 Sequence Abstract Data Type Table of Contents Introduction.. 1 Objects for the sequence data type.. 2 The sequence as an object. 2.1 Sequence components. 2.2 Operations on sequences 3 Enquiry operations..
More informationAlgorithms and Data Structures
Algorithms and Data Structures CSE 465 LECTURE 9 Abstract Data Types Queues Sofya Raskhodnikova and Adam Smith 1 Data Structures So far in this class: designing algorithms Inputs and outputs were specified,
More informationProcedural Programming
Exercise 6 (SS 2016) 04.07.2015 What will I learn in the 6. exercise Math functions Dynamic data structures (linked Lists) Exercise(s) 1 Home exercise 4 (3 points) Write a program which is able to handle
More information#06 More Structures LIFO FIFO. Contents. Queue vs. Stack 3. Stack Operations. Pop. Push. Stack Queue Hash table
Contents #06 More Structures -07 FUNDAMENTAL PROGRAMMING I Stack Queue Hash table DEPARTMENT OF COMPUTER ENGINEERING, PSU v. Queue vs. Stack Stack Operations IN IN OUT Push: add an item to the top Pop:
More informationLargest Online Community of VU Students
WWW.VUPages.com http://forum.vupages.com WWW.VUTUBE.EDU.PK Largest Online Community of VU Students MIDTERM EXAMINATION SEMESTER FALL 2003 CS301-DATA STRUCTURE Total Marks:86 Duration: 60min Instructions
More informationLINKED LIST IMPLEMENTATION USING C LANGUAGE: A REVIEW
LINKED LIST IMPLEMENTATION USING C LANGUAGE: A REVIEW Ekta Nehra Assistant Professor (Extn.), C.R.M jat college, Hisar, Haryana, (India) ABSTRACT This paper describes about linear data structure i.e. linked
More information.:: UNIT 4 ::. STACK AND QUEUE
.:: UNIT 4 ::. STACK AND QUEUE 4.1 A stack is a data structure that supports: Push(x) Insert x to the top element in stack Pop Remove the top item from stack A stack is collection of data item arrange
More informationDS L9: Queues
Indian Institute of Science Bangalore, India भ रत य व ज ञ न स स थ न ब गल र, भ रत Department of Computational and Data Sciences DS286 2016-09-09 L9: Queues Yogesh Simmhan s i m m h a n @ c d s. i i s c.
More information