Data Structures and Algorithms for Engineers
|
|
|
- Edmund Hudson
- 5 years ago
- Views:
Transcription
1 Data Structures and Algorithms for Engineers David Vernon Carnegie Mellon University Africa Data Structures and Algorithms for Engineers 1 Carnegie Mellon University Africa
2 Lecture 8 Containers and Dictionaries Containers Dictionaries List ADT Array implementation Linked list implementation Data Structures and Algorithms for Engineers 2 Carnegie Mellon University Africa
3 Containers and Dictionaries Containers are data structures that permit storage and retrieval of data items independent of content Dictionaries are data structures that retrieve data based on key values (i.e. content) Data Structures and Algorithms for Engineers 3 Carnegie Mellon University Africa
4 Containers and Dictionaries Containers are distinguished by the particular retrieval order they support In the case of stacks and queues, the retrieval order depends on the insertion order Data Structures and Algorithms for Engineers 4 Carnegie Mellon University Africa
5 Containers and Dictionaries Stack: supports retrieval by last-in, first-out (LIFO) order Push(x, S) Insert item x at the top of a stack S Pop (S) Return (and remove) the top item of a stack S Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
6 Containers and Dictionaries Queue: support retrieval by first-in, first-out (FIFO) order Enqueue(x, Q) Insert item x at the back of a queue Q Dequeue (Q) Return (and remove) the the front item from a queue Q Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
7 Containers and Dictionaries Dictionaries permits access to data items by content You put an item into a dictionary so that you can find it when you need it Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
8 Containers and Dictionaries Main dictionary operations are Search(D, k) Given a search key k, return a pointer to the element in dictionary D whose key value is k, if one exists Insert(D, x) Given a data item x, add it to the dictionary D Delete(D, x) Given a pointer to a given data item x in the dictionary D, remove it from D Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
9 Containers and Dictionaries Some dictionary data structures also efficiently support other useful operations Max(D) Retrieve the item with the largest key from D Min(D) Retrieve the item with the smallest key from D These operations allows the dictionary to serve as a priority queue; more on this later Data Structures and Algorithms for Engineers 9 Carnegie Mellon University Africa
10 Containers and Dictionaries Some dictionary data structures also efficiently support other useful operations Predecessor(D, x) Retrieve the item from D whose key is immediately before x in sorted order Successor(D, x) Retrieve the item from D whose key is immediately afterx in sorted order These operations enable us to iterate through the elements of the data structure Data Structures and Algorithms for Engineers 10 Carnegie Mellon University Africa
11 Containers and Dictionaries We have defined these container and dictionary operations in an abstract manner, without reference to their implementation or the implementation of the structure itself There are many implementation options Unsorted arrays Sorted arrays Singly-linked lists Doubly-linked lists Binary search trees Balanced binary search trees Hash tables Heaps Data Structures and Algorithms for Engineers 11 Carnegie Mellon University Africa
12 Lists Data Structures and Algorithms for Engineers 12 Carnegie Mellon University Africa
13 Lists A list is an ordered sequence of zero or more elements of a given type a 1, a 2, a 3, a n a i is of type elementtype a i precedes a i+1 a i+1 succeeds or follows a i If n=0 the list is empty: a null list The position of a i is i Data Structures and Algorithms for Engineers 13 Carnegie Mellon University Africa
14 Lists List element w (w is of type windowtype: w could be, but is not necessarily, the integer sequence position of the element in the list) Element of type elementtype Data Structures and Algorithms for Engineers 14 Carnegie Mellon University Africa
15 LIST: An ADT specification of a list type Let L denote all possible values of type LIST (i.e. lists of elements of type elementtype) Let E denote all possible values of type elementtype Let B denote the set of Boolean values true and false Let W denote the set of values of type windowtype Data Structures and Algorithms for Engineers 15 Carnegie Mellon University Africa
16 LIST Operations Syntax of ADT Definition: Operation: What_You_Pass_It What_It_Returns : Data Structures and Algorithms for Engineers 16 Carnegie Mellon University Africa
17 LIST Operations Declare: L : The function value of Declare(L) is an empty list alternative syntax: LIST L Data Structures and Algorithms for Engineers 17 Carnegie Mellon University Africa
18 LIST Operations End: L W : The function End(L) returns the position after the last element in the list (i.e. the value of the function is the window position after the last element in the list) Data Structures and Algorithms for Engineers 18 Carnegie Mellon University Africa
19 LIST Operations Empty: L L x W : The function Empty causes the list to be emptied and it returns position End(L) Data Structures and Algorithms for Engineers 19 Carnegie Mellon University Africa
20 LIST Operations IsEmpty: L B : The function value IsEmpty(L) is true if L is empty; otherwise it is false Data Structures and Algorithms for Engineers 20 Carnegie Mellon University Africa
21 LIST Operations First: L W : The function value First(L) is the window position of the first element in the list; if the list is empty, it has the value End(L) Data Structures and Algorithms for Engineers 21 Carnegie Mellon University Africa
22 Next: L x W W : LIST Operations The function value Next(w,L) is the window position of the next successive element in the list; if we are already at the end of the list then the value of Next(w,L) is End(L); if the value of w is End(L), then the operation is undefined Data Structures and Algorithms for Engineers 22 Carnegie Mellon University Africa
23 LIST Operations Next(w,L) Data Structures and Algorithms for Engineers 23 Carnegie Mellon University Africa
24 LIST Operations Previous: L x W W : The function value Previous(w, L) is the window position of the previous element in the list; if we are already at the beginning of the list (w=first(l)), then the value is undefined Data Structures and Algorithms for Engineers 24 Carnegie Mellon University Africa
25 LIST Operations Previous(w,L) Data Structures and Algorithms for Engineers 25 Carnegie Mellon University Africa
26 LIST Operations Last: L W : The function value Last(L) is the window position of the last element in the list; if the list is empty, it has the value End(L) Data Structures and Algorithms for Engineers 26 Carnegie Mellon University Africa
27 LIST Operations Insert: E x L x W L x W : Insert(e, w, L) Insert an element e at position w in the list L, moving elements at w and following positions to the next higher position a 1, a 2, a n a 1, a 2,, a w-1, e, a w,, a n Data Structures and Algorithms for Engineers 27 Carnegie Mellon University Africa
28 LIST Operations If w = End(L) then a 1, a 2, a n a 1, a 2,, a n, e The window w is moved over the new element e The function value is the list with the element inserted Data Structures and Algorithms for Engineers 28 Carnegie Mellon University Africa
29 LIST Operations Insert(e,w,L) Data Structures and Algorithms for Engineers 29 Carnegie Mellon University Africa
30 LIST Operations Insert(e,w,L) Data Structures and Algorithms for Engineers 30 Carnegie Mellon University Africa
31 LIST Operations Delete: L x W L x W : Delete(w, L) Delete the element at position w in the list L a 1, a 2, a n a 1, a 2,, a w-1, a w+1,, a n If w = End(L) then the operation is undefined The function value is the list with the element deleted Data Structures and Algorithms for Engineers 31 Carnegie Mellon University Africa
32 LIST Operations Delete(w,L) Data Structures and Algorithms for Engineers 32 Carnegie Mellon University Africa
33 LIST Operations Examine: L x W E : The function value Examine(w, L) is the value of the element at position w in the list; if we are already at the end of the list (i.e. w = End(L)), then the value is undefined Data Structures and Algorithms for Engineers 33 Carnegie Mellon University Africa
34 LIST Operations Declare(L) End(L) Empty(L) IsEmpty(L) First(L) Next(w,L) Previous(w,L) Last(L) Insert(e,w,L) Delete(w,L) Examine(w,L) returns listtype returns windowtype returns windowtype returns Boolean returns windowtype returns windowtype returns windowtype returns windowtype returns listtype returns listtype returns elementtype Data Structures and Algorithms for Engineers 34 Carnegie Mellon University Africa
35 LIST Operations Insert(e,w,L) returns listtype Delete(w,L) returns listtype Examine(w,L) returns elementtype Data Structures and Algorithms for Engineers 35 Carnegie Mellon University Africa
36 LIST Operations Example of List manipulation w = End(L) empty list Data Structures and Algorithms for Engineers 36 Carnegie Mellon University Africa
37 LIST Operations Example of List manipulation w = End(L) Insert(e,w, L) Data Structures and Algorithms for Engineers 37 Carnegie Mellon University Africa
38 LIST Operations Example of List manipulation w = End(L) Insert(e,w, L) Insert(e,w, L) Data Structures and Algorithms for Engineers 38 Carnegie Mellon University Africa
39 LIST Operations Example of List manipulation w = End(L) Insert(e,w, L) Insert(e,w, L) Insert(e,Last(L), L) Data Structures and Algorithms for Engineers 39 Carnegie Mellon University Africa
40 LIST Operations Example of List manipulation w = Next(Last(L),L) Data Structures and Algorithms for Engineers 40 Carnegie Mellon University Africa
41 LIST Operations Example of List manipulation w = Next(Last(L),L) Insert(e,w,L) Data Structures and Algorithms for Engineers 41 Carnegie Mellon University Africa
42 LIST Operations Example of List manipulation w = Next(Last(L),L) Insert(e,w,L) w = Previous(w,L) Data Structures and Algorithms for Engineers 42 Carnegie Mellon University Africa
43 LIST Operations Example of List manipulation w = Next(Last(L),L) Insert(e,w,L) w = Previous(w,L) Delete(w,L) Data Structures and Algorithms for Engineers 43 Carnegie Mellon University Africa
44 ADT Specification The key idea is that we have not specified how the lists are to be implemented, merely their values and the operations of which they can be operands This old idea of data abstraction is one of the key features of object-oriented programming C++ is a particular implementation of this object-oriented methodology Data Structures and Algorithms for Engineers 44 Carnegie Mellon University Africa
45 ADT Implementation Of course, we still have to implement this ADT specification The choice of implementation will depend on the requirements of the application Data Structures and Algorithms for Engineers 45 Carnegie Mellon University Africa
46 ADT Implementation We will look at two implementations Array implementation uses a static data-structure reasonable if we know in advance the maximum of elements in the list Pointer implementation Also known as a linked-list implementation uses dynamic data-structure best if we don t know in advance the of elements in the list (or if it varies significantly) overhead in space: the pointer fields Data Structures and Algorithms for Engineers 46 Carnegie Mellon University Africa
47 LIST: Array Implementation We will do this in two steps: the implementation (or representation) of the four constituents datatypes of the ADT: list elementtype Boolean Windowtype the implementation of each of the ADT operations Data Structures and Algorithms for Engineers 47 Carnegie Mellon University Africa
48 LIST: Array Implementation 0 First element Second element List Last Last element Integer index Empty Max_list_size - 1 Data Structures and Algorithms for Engineers 48 Carnegie Mellon University Africa
49 LIST: Array Implementation type elementtype type LIST type Boolean type windowtype Data Structures and Algorithms for Engineers 49 Carnegie Mellon University Africa
50 LIST: Array Implementation /* array implementation of LIST ADT */ #include <stdio.h> #include <math.h> #include <.h> #define MAX_LIST_SIZE 100 #define FALSE 0 #define TRUE 1 typedef struct { int ; char *; } ELEMENT_TYPE; Data Structures and Algorithms for Engineers 50 Carnegie Mellon University Africa
51 LIST: Array Implementation typedef struct { int last; ELEMENT_TYPE a[max_list_size]; } LIST_TYPE; typedef int WINDOW_TYPE; last M_L_S-1 Data Structures and Algorithms for Engineers 51 Carnegie Mellon University Africa
52 LIST: Array Implementation /** position following last element in a list ***/ WINDOW_TYPE end(list_type *list) { } return(list->last+1); list M_L_S-1 list->last+1 3 Data Structures and Algorithms for Engineers 52 Carnegie Mellon University Africa
53 LIST: Array Implementation /*** empty a list ***/ WINDOW_TYPE empty(list_type *list) { list->last = -1; return(end(list)); } list M_L_S-1 list->last+1 0 Data Structures and Algorithms for Engineers 53 Carnegie Mellon University Africa
54 LIST: Array Implementation /*** test to see if a list is empty ***/ int is_empty(list_type *list) { } if (list->last == -1) return(true); else return(false) list M_L_S-1 Data Structures and Algorithms for Engineers 54 Carnegie Mellon University Africa
55 LIST: Array Implementation /*** position at first element in a list ***/ WINDOW_TYPE first(list_type *list) { } if (is_empty(list) == FALSE) { return(0); else return(end(list)); list M_L_S-1 list->last+1 3 Data Structures and Algorithms for Engineers 55 Carnegie Mellon University Africa
56 LIST: Array Implementation /*** position at next element in a list ***/ WINDOW_TYPE next(window_type w, LIST_TYPE *list) { } if (w == last(list)) { return(end(list)); else if (w == end(list)) { error( can t find next after end of list ); } else { return(w+1); } Data Structures and Algorithms for Engineers 56 Carnegie Mellon University Africa
57 LIST: Array Implementation list M_L_S-1 w list M_L_S-1 w+1 Data Structures and Algorithms for Engineers 57 Carnegie Mellon University Africa
58 LIST: Array Implementation /*** position at previous element in a list ***/ WINDOW_TYPE previous(window_type w, LIST_TYPE *list) { } if (w!= first(list)) { return(w-1); else { error( can t find previous before first element of list ); } return(w); Data Structures and Algorithms for Engineers 58 Carnegie Mellon University Africa
59 LIST: Array Implementation list M_L_S-1 w list M_L_S-1 w-1 Data Structures and Algorithms for Engineers 59 Carnegie Mellon University Africa
60 LIST: Array Implementation /*** position at last element in a list ***/ WINDOW_TYPE last(list_type *list) { return(list->last); } list M_L_S-1 list->last 2 Data Structures and Algorithms for Engineers 60 Carnegie Mellon University Africa
61 LIST: Array Implementation /*** insert an element in a list ***/ LIST_TYPE *insert(element_type e, WINDOW_TYPE w, int i; LIST_TYPE *list) { if (list->last >= MAX_LIST_SIZE-1) { error( Can t insert - list is full ); } else if ((w > list->last + 1) (w < 0)) { error( Position does not exist ); } else { /* insert it shift all after w to the right */ Data Structures and Algorithms for Engineers 61 Carnegie Mellon University Africa
62 LIST: Array Implementation for (i=list->last; i>= w; i--) { } list->a[i+1] = list->a[i]; list->a[w] = e; list->last = list->last + 1; } } return(list); Data Structures and Algorithms for Engineers 62 Carnegie Mellon University Africa
63 LIST: Array Implementation list list M_L_S-1 w M_L_S-1 w Data Structures and Algorithms for Engineers 63 Carnegie Mellon University Africa
64 LIST: Array Implementation list list M_L_S-1 w M_L_S-1 w Data Structures and Algorithms for Engineers 64 Carnegie Mellon University Africa
65 LIST: Array Implementation list list M_L_S-1 w M_L_S-1 w Data Structures and Algorithms for Engineers 65 Carnegie Mellon University Africa
66 LIST: Array Implementation list list M_L_S-1 w M_L_S-1 w Data Structures and Algorithms for Engineers 66 Carnegie Mellon University Africa
67 LIST: Array Implementation /*** delete an element from a list ***/ LIST_TYPE *delete(window_type w, LIST_TYPE *list) { } int i; if ((w > list->last) (w < 0)) { } error( Position does not exist ); else { } /* delete it shift all after w to the left */ list->last = list->last - 1; for (i=w; i < list->last; i++) { list->a[i] = list->a[i+1]; } return(list); Data Structures and Algorithms for Engineers 67 Carnegie Mellon University Africa
68 LIST: Array Implementation list list M_L_S-1 w M_L_S-1 w Data Structures and Algorithms for Engineers 68 Carnegie Mellon University Africa
69 LIST: Array Implementation list list M_L_S-1 w M_L_S-1 w Data Structures and Algorithms for Engineers 69 Carnegie Mellon University Africa
70 LIST: Array Implementation /*** retrieve an element from a list ***/ ELEMENT_TYPE retrieve(window_type w, LIST_TYPE *list) { if ( (w < 0)) (w > list->last)) { /* list is empty */ } error( Position does not exist ); } else { } return(list->a[w]); Data Structures and Algorithms for Engineers 70 Carnegie Mellon University Africa
71 LIST: Array Implementation list M_L_S-1 w list->a[4]. 1 Data Structures and Algorithms for Engineers 71 Carnegie Mellon University Africa
72 LIST: Array Implementation /*** print all elements in a list ***/ int print(list_type *list) { } WINDOW_TYPE w; ELEMENT_TYPE e; printf( Contents of list: \n ); w = first(list); while (w!= end(list)) { } e = retrieve(w, list); printf( %d %s\n, e., e.); w = next(w, list); printf( ---\n ); return(0); Data Structures and Algorithms for Engineers 72 Carnegie Mellon University Africa
73 LIST: Array Implementation /*** error handler: print message passed as argument and take appropriate action ***/ int error(char *s) { } printf( Error: %s\n, s); exit(0); Data Structures and Algorithms for Engineers 73 Carnegie Mellon University Africa
74 LIST: Array Implementation /*** assign values to an element ***/ int assign_element_values(element_type *e, int, char s[]){ e-> = (char *) malloc(sizeof(char)* (strlen(s)+1)); strcpy(e->, s); e-> = ; } Data Structures and Algorithms for Engineers 74 Carnegie Mellon University Africa
75 LIST: Array Implementation /*** main application routine ***/ WINDOW_TYPE w; ELEMENT_TYPE e; LIST_TYPE list; int i; empty(&list); print(&list); assign_element_values(&e, 1, String A ); w = first(&list); insert(e, w, &list); print(&list); Data Structures and Algorithms for Engineers 75 Carnegie Mellon University Africa
76 LIST: Array Implementation assign_element_values(&e, 2, String B ); insert(e, w, &list); print(&list); assign_element_values(&e, 3, String C ); insert(e, last(&list), &list); print(&list); assign_element_values(&e, 4, String D ); w = next(last(&list), &list); insert(e, w, &list); print(&list); Data Structures and Algorithms for Engineers 76 Carnegie Mellon University Africa
77 LIST: Array Implementation w = previous(w, &list); delete(w, &list); print(&list); } Data Structures and Algorithms for Engineers 77 Carnegie Mellon University Africa
78 LIST: Array Implementation Key points: we have implemented all list manipulation operations with dedicated access functions we never directly access the data-structure when using it but we always use the access functions Why? Data Structures and Algorithms for Engineers 78 Carnegie Mellon University Africa
79 LIST: Array Implementation Key points: greater security: localized control and more resilient software maintenance data hiding: the implementation of the data-structure is hidden from the user and so we can change the implementation and the user will never know Data Structures and Algorithms for Engineers 79 Carnegie Mellon University Africa
80 LIST: Array Implementation Possible problems with the implementation: have to shift elements when inserting and deleting (i.e. insert and delete are O(n)) have to specify the maximum size of the list at compile time Data Structures and Algorithms for Engineers 80 Carnegie Mellon University Africa
Data Structures and Algorithms for Engineers
04-630 Data Structures and Algorithms for Engineers David Vernon Carnegie Mellon University Africa vernon@cmu.edu www.vernon.eu Data Structures and Algorithms for Engineers 1 Carnegie Mellon University
Data Structures and Algorithms for Engineers
04-630 Data Structures and Algorithms for Engineers David Vernon Carnegie Mellon University Africa vernon@cmu.edu www.vernon.eu Data Structures and Algorithms for Engineers 1 Carnegie Mellon University
Data Structures and Algorithms for Engineers
04-630 Data Structures and Algorithms for Engineers David Vernon Carnegie Mellon University Africa vernon@cmu.edu www.vernon.eu Data Structures and Algorithms for Engineers 1 Carnegie Mellon University
Algorithms and Data Structures CS-CO-412
Algorithms and Data Structures CS-CO-412 David Vernon Professor of Informatics University of Skövde Sweden david@vernon.eu www.vernon.eu Algorithms and Data Structures 1 Copyright D. Vernon 2014 Trees
Linked 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
Cpt 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
Lecture 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
Short Notes of CS201
#includes: Short Notes of CS201 The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with < and > if the file is a system
CS201 - Introduction to Programming Glossary By
CS201 - Introduction to Programming Glossary By #include : The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with
8. 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
Data Structures and Algorithms for Engineers
0-630 Data Structures and Algorithms for Engineers David Vernon Carnegie Mellon University Africa vernon@cmu.edu www.vernon.eu Data Structures and Algorithms for Engineers 1 Carnegie Mellon University
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING B.E SECOND SEMESTER CS 6202 PROGRAMMING AND DATA STRUCTURES I TWO MARKS UNIT I- 2 MARKS
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING B.E SECOND SEMESTER CS 6202 PROGRAMMING AND DATA STRUCTURES I TWO MARKS UNIT I- 2 MARKS 1. Define global declaration? The variables that are used in more
MULTIMEDIA 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
Week 6. Data structures
1 2 3 4 5 n Week 6 Data structures 6 7 n 8 General remarks We start considering Part III Data Structures from CLRS. As a first example we consider two special of buffers, namely stacks and queues. Reading
Data Structures and Algorithms for Engineers
04-630 Data Structures and Algorithms for Engineers David Vernon Carnegie Mellon University Africa vernon@cmu.edu www.vernon.eu Data Structures and Algorithms for Engineers 1 Carnegie Mellon University
Solution 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
1 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
The smallest element is the first one removed. (You could also define a largest-first-out priority queue)
Priority Queues Priority queue A stack is first in, last out A queue is first in, first out A priority queue is least-first-out The smallest element is the first one removed (You could also define a largest-first-out
Data Structures and Algorithms for Engineers
04-630 Data Structures and Algorithms for Engineers David Vernon Carnegie Mellon University Africa vernon@cmu.edu www.vernon.eu Data Structures and Algorithms for Engineers 1 Carnegie Mellon University
Lists, 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
Lecture Notes on Memory Management
Lecture Notes on Memory Management 15-122: Principles of Imperative Computation Frank Pfenning Lecture 22 November 11, 2010 1 Introduction Unlike C0 and other modern languages like Java, C#, or ML, C requires
Cpt 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:
1) What is the primary purpose of template functions? 2) Suppose bag is a template class, what is the syntax for declaring a bag b of integers?
Review for Final (Chapter 6 13, 15) 6. Template functions & classes 1) What is the primary purpose of template functions? A. To allow a single function to be used with varying types of arguments B. To
CS6202 - 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
Lists. CITS2200 Data Structures and Algorithms. Topic 9
CITS2200 Data Structures and Algorithms Topic 9 Lists Why lists? List windows Specification Block representation Singly linked representation Performance comparisons Reading: Lambert and Osborne, Sections
Preface... (vii) CHAPTER 1 INTRODUCTION TO COMPUTERS
Contents Preface... (vii) CHAPTER 1 INTRODUCTION TO COMPUTERS 1.1. INTRODUCTION TO COMPUTERS... 1 1.2. HISTORY OF C & C++... 3 1.3. DESIGN, DEVELOPMENT AND EXECUTION OF A PROGRAM... 3 1.4 TESTING OF PROGRAMS...
CSE030 Fall 2012 Final Exam Friday, December 14, PM
CSE030 Fall 2012 Final Exam Friday, December 14, 2012 3-6PM Write your name here and at the top of each page! Name: Select your lab session: Tuesdays Thursdays Paper. If you have any questions or need
Lecture 7: Data Structures. EE3490E: Programming S1 2017/2018 Dr. Đào Trung Kiên Hanoi Univ. of Science and Technology
Lecture 7: Data Structures 1 Introduction: dynamic array Conventional array in C has fix number of elements Dynamic array is array with variable number of elements: actually a pointer and a variable indicating
ADT: Design & Implementation
CPSC 250 Data Structures ADT: Design & Implementation Dr. Yingwu Zhu Abstract Data Type (ADT) ADT = data items + operations on the data Design of ADT Determine data members & operations Implementation
Data Structure using C++ Lecture 04. Data Structures and algorithm analysis in C++ Chapter , 3.2, 3.2.1
Data Structure using C++ Lecture 04 Reading Material Data Structures and algorithm analysis in C++ Chapter. 3 3.1, 3.2, 3.2.1 Summary Infix to Postfix Example 1: Infix to Postfix Example 2: Postfix Evaluation
Reg. No. : Question Paper Code : 27157
WK 3 Reg. No. : Question Paper Code : 27157 B.E./B.Tech. DEGREE EXAMINATION, NOVEMBER/DECEMBER 2015. Time : Three hours Second Semester Computer Science and Engineering CS 6202 PROGRAMMING AND DATA STRUCTURES
CSE 250 Final Exam. Fall 2013 Time: 3 hours. Dec 11, No electronic devices of any kind. You can open your textbook and notes
CSE 250 Final Exam Fall 2013 Time: 3 hours. Dec 11, 2013 Total points: 100 14 pages Please use the space provided for each question, and the back of the page if you need to. Please do not use any extra
l 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
.:: 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
FINALTERM EXAMINATION Fall 2009 CS301- Data Structures Question No: 1 ( Marks: 1 ) - Please choose one The data of the problem is of 2GB and the hard
FINALTERM EXAMINATION Fall 2009 CS301- Data Structures Question No: 1 The data of the problem is of 2GB and the hard disk is of 1GB capacity, to solve this problem we should Use better data structures
Programming Abstractions
Programming Abstractions C S 1 0 6 B Cynthia Lee Topics: Priority Queue Linked List implementation Sorted Unsorted Heap structure implementation TODAY S TOPICS NOT ON THE MIDTERM 2 Some priority queue
INITIALISING POINTER VARIABLES; DYNAMIC VARIABLES; OPERATIONS ON POINTERS
INITIALISING POINTER VARIABLES; DYNAMIC VARIABLES; OPERATIONS ON POINTERS Pages 792 to 800 Anna Rakitianskaia, University of Pretoria INITIALISING POINTER VARIABLES Pointer variables are declared by putting
1 P a g e A r y a n C o l l e g e \ B S c _ I T \ C \
![1 P a g e A r y a n C o l l e g e \ B S c _ I T \ C \](/thumbs/95/126495363.jpg "1 P a g e A r y a n C o l l e g e \ B S c _ I T \ C \")
BSc IT C Programming (2013-2017) Unit I Q1. What do you understand by type conversion? (2013) Q2. Why we need different data types? (2013) Q3 What is the output of the following (2013) main() Printf( %d,
EC8393FUNDAMENTALS 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
MID TERM MEGA FILE SOLVED BY VU HELPER Which one of the following statement is NOT correct.
MID TERM MEGA FILE SOLVED BY VU HELPER Which one of the following statement is NOT correct. In linked list the elements are necessarily to be contiguous In linked list the elements may locate at far positions
List, Stack, and Queues
List, Stack, and Queues R. J. Renka Department of Computer Science & Engineering University of North Texas 02/24/2010 3.1 Abstract Data Type An Abstract Data Type (ADT) is a set of objects with a set of
ECE 2035 Programming HW/SW Systems Fall problems, 5 pages Exam Three 28 November 2012
Instructions: This is a closed book, closed note exam. Calculators are not permitted. If you have a question, raise your hand and I will come to you. Please work the exam in pencil and do not separate
CSCE 110 PROGRAMMING FUNDAMENTALS. Prof. Amr Goneid AUC
CSCE 110 PROGRAMMING FUNDAMENTALS WITH C++ Prof. Amr Goneid AUC Part 13. Abstract Data Types (ADT s) Prof. amr Goneid, AUC 1 Data Modeling and ADTs Prof. Amr Goneid, AUC 2 Data Modeling and ADTs Data Modeling
Containers: Stack. Jordi Cortadella and Jordi Petit Department of Computer Science
Containers: Stack Jordi Cortadella and Jordi Petit Department of Computer Science The Stack ADT A stack is a list of objects in which insertions and deletions can only be performed at the top of the list.
Matriculation number:
Department of Informatics Prof. Dr. Michael Böhlen Binzmühlestrasse 14 8050 Zurich Phone: +41 44 635 4333 Email: boehlen@ifi.uzh.ch AlgoDat Repetition Exam Spring 2018 18.05.2018 Name: Matriculation number:
Containers: Stack. The Stack ADT. The Stack ADT. The Stack ADT
Containers: Stack The Stack ADT A stack is a list of objects in which insertions and deletions can only be performed at the top of the list. Also known as LIFO Last In, First Out) push insert an element
CS 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
CMSC 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,
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
Computer Science 9608 (Notes) Chapter: 4.1 Computational thinking and problem-solving
In Computer Science, an abstract data type (ADT) is a mathematical model for a certain data type or structures. This doesn t mean that the ADTs cannot be programmed. But that we must first understand them
Pointers, Dynamic Data, and Reference Types
Pointers, Dynamic Data, and Reference Types Review on Pointers Reference Variables Dynamic Memory Allocation The new operator The delete operator Dynamic Memory Allocation for Arrays 1 C++ Data Types simple
A. Year / Module Semester Subject Topic 2016 / V 2 PCD Pointers, Preprocessors, DS
Syllabus: Pointers and Preprocessors: Pointers and address, pointers and functions (call by reference) arguments, pointers and arrays, address arithmetic, character pointer and functions, pointers to pointer,initialization
About this exam review
Final Exam Review About this exam review I ve prepared an outline of the material covered in class May not be totally complete! Exam may ask about things that were covered in class but not in this review
MIDTERM 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
V.S.B ENGINEERING COLLEGE DEPARTMENT OF INFORMATION TECHNOLOGY I IT-II Semester. Sl.No Subject Name Page No. 1 Programming & Data Structures-I 2
V.S.B ENGINEERING COLLEGE DEPARTMENT OF INFORMATION TECHNOLOGY I IT-II Semester Sl.No Subject Name Page No. 1 Programming & Data Structures-I 2 CS6202 - PROGRAMMING & DATA STRUCTURES UNIT I Part - A 1.
CS PROGRAMMING & ATA STRUCTURES I. UNIT I Part - A
CS6202 - PROGRAMMING & ATA STRUCTURES I Question Bank UNIT I Part - A 1. What are Keywords? 2. What is the difference between if and while statement? 3. What is the difference between while loop and do
Implementing an abstract datatype. Linked lists and queues
Computer Programming Implementing an abstract datatype. Linked lists and queues Marius Minea marius@cs.upt.ro 19 December 2016 Review: compilation basics Briefly: Compiler translates source code to executable
Heaps in C. CHAN Hou Pong, Ken CSCI2100 Data Structures Tutorial 7
Heaps in C CHAN Hou Pong, Ken CSCI2100 Data Structures Tutorial 7 Review on Heaps A heap is implemented as a binary tree It satisfies two properties: MinHeap: parent = child]
Data 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
Chapter 9 STACK, QUEUE
Chapter 9 STACK, QUEUE 1 LIFO: Last In, First Out. Stacks Restricted form of list: Insert and remove only at front of list. Notation: Insert: PUSH Remove: POP The accessible element is called TOP. Stack
SEMANTIC ANALYSIS TYPES AND DECLARATIONS
SEMANTIC ANALYSIS CS 403: Type Checking Stefan D. Bruda Winter 2015 Parsing only verifies that the program consists of tokens arranged in a syntactically valid combination now we move to check whether
Programming. Lists, Stacks, Queues
Programming Lists, Stacks, Queues 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
CMPT 125: Practice Midterm Answer Key
CMPT 125, Spring 2017, Surrey Practice Midterm Answer Key Page 1 of 6 CMPT 125: Practice Midterm Answer Key Linked Lists Suppose you have a singly-linked list whose nodes are defined like this: struct
B.V. Patel Institute of Business Management, Computer & Information Technology, Uka Tarsadia University
Unit 1 Programming Language and Overview of C 1. State whether the following statements are true or false. a. Every line in a C program should end with a semicolon. b. In C language lowercase letters are
DATA 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
CS 241 Data Organization Binary Trees
CS 241 Data Organization Binary Trees Brooke Chenoweth University of New Mexico Fall 2017 Binary Tree: Kernighan and Ritchie 6.5 Read a file and count the occurrences of each word. now is the time for
Priority Queues. Lecture15: Heaps. Priority Queue ADT. Sequence based Priority Queue
Priority Queues (0F) Lecture: Heaps Bohyung Han CSE, POSTECH bhhan@postech.ac.kr Queues Stores items (keys) in a linear list or array FIFO (First In First Out) Stored items do not have priorities. Priority
Stacks and Queues. CSE Data Structures April 12, 2002
Stacks and Queues CSE 373 - Data Structures April 12, 2002 Readings and References Reading Section 3.3 and 3.4, Data Structures and Algorithm Analysis in C, Weiss Other References 12-Apr-02 CSE 373 - Data
Linear 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
Containers and genericity. A standardized naming scheme. Cursor properties. Lists. Adding a cell. A specific implementation: (singly) linked lists
Topics for this lecture Chair of Software Engineering Einführung in die Programmierung Introduction to Programming Containers and genericity Container operations Prof. Dr. Bertrand Meyer Lists October
CS301 - 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
ECE 2035 Programming HW/SW Systems Spring problems, 5 pages Exam Three 8 April Your Name (please print clearly)
Your Name (please print clearly) This exam will be conducted according to the Georgia Tech Honor Code. I pledge to neither give nor receive unauthorized assistance on this exam and to abide by all provisions
Lecture 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
Linked 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
DATA 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
Linear 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
Linear Data Structure
Linear Data Structure Definition A data structure is said to be linear if its elements form a sequence or a linear list. Examples: Array Linked List Stacks Queues Operations on linear Data Structures Traversal
CSE 12 Week Eight, Lecture One
CSE 12 Week Eight, Lecture One Heap: (The data structure, not the memory area) - A binary tree with properties: - 1. Parent s are greater than s. o the heap order - 2. Nodes are inserted so that tree is
Stack. 4. In Stack all Operations such as Insertion and Deletion are permitted at only one end. Size of the Stack 6. Maximum Value of Stack Top 5
What is Stack? Stack 1. Stack is LIFO Structure [ Last in First Out ] 2. Stack is Ordered List of Elements of Same Type. 3. Stack is Linear List 4. In Stack all Operations such as Insertion and Deletion
You must include this cover sheet. Either type up the assignment using theory5.tex, or print out this PDF.
15-122 Assignment 5 Page 1 of 11 15-122 : Principles of Imperative Computation Fall 2012 Assignment 5 (Theory Part) Due: Tuesday, October 30, 2012 at the beginning of lecture Name: Andrew ID: Recitation:
Procedural programming with C
Procedural programming with C Dr. C. Constantinides Department of Computer Science and Software Engineering Concordia University Montreal, Canada August 11, 2016 1 / 77 Functions Similarly to its mathematical
DATA STRUCTURE : A MCQ QUESTION SET Code : RBMCQ0305
Q.1 If h is any hashing function and is used to hash n keys in to a table of size m, where n
S.E. Sem. III [INFT] Data Structures & Analysis. Primitive Linear Non Linear
![S.E. Sem. III [INFT] Data Structures & Analysis. Primitive Linear Non Linear](/thumbs/88/115506064.jpg "S.E. Sem. III [INFT] Data Structures & Analysis. Primitive Linear Non Linear")
S.E. Sem. III [INFT] Data Structures & Analysis Time : 3 Hrs.] Prelim Paper Solution [Marks : 80 Q.1(a) Explain different types of data structures with examples. [5] Ans.: Types of Data Structure : Data
Abstract 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
Lecture Notes on Memory Management
Lecture Notes on Memory Management 15-122: Principles of Imperative Computation Frank Pfenning Lecture 21 April 5, 2011 1 Introduction Unlike C0 and other modern languages like Java, C#, or ML, C requires
1. Stack overflow & underflow 2. Implementation: partially filled array & linked list 3. Applications: reverse string, backtracking
Review for Test 2 (Chapter 6-10) Chapter 6: Template functions & classes 1) What is the primary purpose of template functions? A. To allow a single function to be used with varying types of arguments B.
CPSC 221: Algorithms and Data Structures Lecture #1: Stacks and Queues
CPSC 221: Algorithms and Data Structures Lecture #1: Stacks and Queues Alan J. Hu (Slides borrowed from Steve Wolfman) Be sure to check course webpage! http://www.ugrad.cs.ubc.ca/~cs221 1 Lab 1 is available.
Linked Lists and Abstract Data Structures A brief comparison
Linked Lists and Abstract Data A brief comparison 24 March 2011 Outline 1 2 3 4 Data Data structures are a key idea in programming It s just as important how you store the data as it is what you do to
Einführung in die Programmierung Introduction to Programming
Chair of Software Engineering Einführung in die Programmierung Introduction to Programming Prof. Dr. Bertrand Meyer Lecture 14: Container Data Structures Topics for this lecture Containers and genericity
Data 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
UNIT 6A Organizing Data: Lists Principles of Computing, Carnegie Mellon University
UNIT 6A Organizing Data: Lists Carnegie Mellon University 1 Data Structure The organization of data is a very important issue for computation. A data structure is a way of storing data in a computer so
MODULE 5: Pointers, Preprocessor Directives and Data Structures
MODULE 5: Pointers, Preprocessor Directives and Data Structures 1. What is pointer? Explain with an example program. Solution: Pointer is a variable which contains the address of another variable. Two
CP2 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 { }; ;
DATA STRUCTURES AND ALGORITHMS
DATA STRUCTURES AND ALGORITHMS UNIT 1 - LINEAR DATASTRUCTURES 1. Write down the definition of data structures? A data structure is a mathematical or logical way of organizing data in the memory that consider
III Data Structures. Dynamic sets
III Data Structures Elementary Data Structures Hash Tables Binary Search Trees Red-Black Trees Dynamic sets Sets are fundamental to computer science Algorithms may require several different types of operations
CSC148H Week 3. Sadia Sharmin. May 24, /20
CSC148H Week 3 Sadia Sharmin May 24, 2017 1/20 Client vs. Developer I For the first couple of weeks, we have played the role of class designer I However, you are also often in the opposite role: when a
Postfix (and prefix) notation
Postfix (and prefix) notation Also called reverse Polish reversed form of notation devised by mathematician named Jan Łukasiewicz (so really lü-kä-sha-vech notation) Infix notation is: operand operator
Wentworth Institute of Technology COMP201 Computer Science II Spring 2015 Derbinsky. Stacks and Queues. Lecture 11.
Lecture 11 1 More Data Structures In this lecture we will use a linked list to implement two abstract data types (ADT) An ADT provides the interface, or what a data structure does We can then use code
12 Abstract Data Types
12 Abstract Data Types 12.1 Foundations of Computer Science Cengage Learning Objectives After studying this chapter, the student should be able to: Define the concept of an abstract data type (ADT). Define
CS300 Final Review Questions 1
CS300 Final Review Questions 1 This is not a complete list of questions and topics, but a good sampling of questions that will help you study for the final. I strongly advise you to work through every