Object Oriented Programming COP3330 / CGS5409
|
|
- Gavin Holmes
- 6 years ago
- Views:
Transcription
1 Object Oriented Programming COP3330 / CGS5409
2 Intro to Data Structures Vectors Linked Lists Queues Stacks
3 C++ has some built-in methods of storing compound data in useful ways, like arrays and structs. Collectively known as Abstract Data Types, as they describe the nature of what is stored, along with the expected operations for accessing the data, without specifying the details of implementation
4 C++ classes allow a nice mechanism for implementing such data types Provides an interface (the public section) for the necessary operations The actual implementation details are internal and hidden.
5 Data structure that stores items of the same type, and is based on storage in an array By encapsulating an array into a class (a vector class), we can Use dynamic allocation to allow the internal array to be flexible in size Handle boundary issues of the array (error checking for out-of-bounds indices).
6 Advantages: Random access - i.e. quick locating of data if the index is known. Disadvantages: Inserts and Deletes are typically slow, since they may require shifting many elements to consecutive array slots
7 Collections of data items linked together with pointers, lined up "in a row". Typically a list of data of the same type, like an array, but storage is arranged differently. Made up of a collection of "nodes", which are created from a self-referential class (or struct).
8 Self-referential class: a class whose member data contains at least one pointer that points to an object of the same class type. Each node contains a piece of data, and a pointer to the next node. Nodes can be anywhere in memory (not restricted to consecutive slots, like in an array). Nodes generally allocated dynamically, so a linked list can grow to any size, theoretically (within the boundaries of the program's memory).
9 An alternative to array-based storage. Advantages: Inserts and Deletes are typically fast. Require only creation of a new node, and changing of a few pointers. Disadvantage: No random access. Possible to build indexing into a linked list class, but locating an element requires walking through the list. Notice that the advantages of the array (vector) are generally the disadvantages of the linked list, and vice versa
10 First In Last Out (FILO) Insertions and removals can occur from "top" position only Analogy - a stack of cafeteria trays. New trays are always placed on top. Trays also picked up from the top.
11 A stack class will have two primary operations: push -- adds an item onto the top of the stack pop -- removes the top item from the stack Typical application areas include compilers, operating systems, handling of program memory (nested function calls)
12 First In First Out (FIFO) Insertions at the "end" of the queue, and removals from the "front" of the queue. Analogy - waiting in line for a ride at an amusement park. Get in line at the end. First come, first serve.
13 A queue class will have two primary operations: enqueue -- adds an item into the queue (i.e. at the back of the line) dequeue -- removes an item from the queue (i.e. from the front of the line). Typical application areas include print job scheduling, operating systems (process scheduling).
14 Some abstract types, like Stacks and Queues, can be implemented with a vector or with a linked list. A stack can use a linked list as its underlying storage mechanism, for instance, but would limit the access to the list to just the "push" and "pop" concepts (insert and remove from one end).
15 A non-linear collection of data items, also linked together with pointers (like a linked list). Made up of self-referential nodes. In this case, each node may contain 2 or more pointers to other nodes.
16 Typical example: a binary tree Each node contains a data element, and two pointers, each of which points to another node. Very useful for fast searching and sorting of data, assuming the data is to be kept in some kind of order. Binary search - finds a path through the tree, starting at the "root", and each chosen path (left or right node) eliminates half of the stored values.
17 Creates a template doubly linked list of List() type, composed of Listnode() type nodes. Listnode.h -- Template ListNode class definition. List.h -- Template List class definition.
18 #ifndef LISTNODE_H #define LISTNODE_H template< typename T > class List; template< typename T > class ListNode { friend class List< T >; // make List a friend public: ListNode( const T & ); // constructor T getdata() const; // return data in node private: T data; // data ListNode< T > *nextptr; // next node in list };
19 // constructor template< typename T > ListNode< T >::ListNode( const T &info ): data( info ), nextptr( 0 ) { } // end ListNode constructor // return copy of data in node template< typename T > T ListNode< T >::getdata() const { return data; } // end function getdata #endif
20 #ifndef LIST_H #define LIST_H #include <iostream> #include "Listnode.h" // ListNode class definition template< typename T > class List { public: List(); // constructor ~List(); // destructor void insertatfront( const T & ); void insertatback( const T & ); bool removefromfront( T & ); bool removefromback( T & ); bool isempty() const; void print() const; private: ListNode< T > *firstptr; // pointer to first node ListNode< T > *lastptr; // pointer to last node ListNode< T > *getnewnode( const T & ); };
21 // default constructor template< typename T > List< T >::List() : firstptr( 0 ), lastptr( 0 ) { } // end List constructor // destructor template< typename T > List< T >::~List() { if (!isempty() ) // List is not empty { cout << "Destroying nodes...\n"; ListNode< T > *currentptr = firstptr; ListNode< T > *tempptr; while ( currentptr!= 0 ) // delete remaining nodes { tempptr = currentptr; cout << tempptr->data << '\n'; currentptr = currentptr->nextptr; delete tempptr; } // end while } // end if cout << "All nodes destroyed\n\n"; } // end List destructor
22 / insert node at front of list template< typename T > void List< T >::insertatfront( const T &value ) { ListNode< T > *newptr = getnewnode( value ); // new node if ( isempty() ) // List is empty firstptr = lastptr = newptr; // new list has only one node else // List is not empty { newptr->nextptr = firstptr; // point new node to previous 1st node firstptr = newptr; // aim firstptr at new node } // end else } // end function insertatfront
23 // insert node at back of list template< typename T > void List< T >::insertatback( const T &value ) { ListNode< T > *newptr = getnewnode( value ); // new node if ( isempty() ) // List is empty firstptr = lastptr = newptr; // new list has only one node else // List is not empty { lastptr->nextptr = newptr; // update previous last node lastptr = newptr; // new last node } // end else } // end function insertatback
24 // delete node from front of list template< typename T > bool List< T >::removefromfront( T &value ) { if ( isempty() ) // List is empty return false; // delete unsuccessful else { ListNode< T > *tempptr = firstptr; // hold tempptr to delete if ( firstptr == lastptr ) firstptr = lastptr = 0; // no nodes remain after removal else firstptr = firstptr->nextptr; // point to previous 2nd node value = tempptr->data; // return data being removed delete tempptr; // reclaim previous front node return true; // delete successful } // end else } // end function removefromfront
25 // delete node from back of list template< typename T > bool List< T >::removefromback( T &value ) { if ( isempty() ) // List is empty return false; // delete unsuccessful else { ListNode< T > *tempptr = lastptr; // hold tempptr to delete if ( firstptr == lastptr ) // List has one element firstptr = lastptr = 0; // no nodes remain after removal else { ListNode< T > *currentptr = firstptr; while ( currentptr->nextptr!= lastptr ) // locate second-to-last element currentptr = currentptr->nextptr; // move to next node lastptr = currentptr; // remove last node currentptr->nextptr = 0; // this is now the last node } // end else value = tempptr->data; // return value from old last node delete tempptr; // reclaim former last node return true; // delete successful } // end else } // end function removefromback
26 // is List empty? template< typename T > bool List< T >::isempty() const { return firstptr == 0; } // end function isempty // return pointer to newly allocated node template< typename T > ListNode< T > *List< T >::getnewnode( const T &value ) { return new ListNode< T >( value ); } // end function getnewnode
27 // display contents of List template< typename T > void List< T >::print() const { if ( isempty() ) { // List is empty cout << "The list is empty\n\n"; return; } // end if ListNode< T > *currentptr = firstptr; cout << "The list is: "; while ( currentptr!= 0 ) { // get element dat cout << currentptr->data << ' '; currentptr = currentptr->nextptr; } // end while cout << "\n\n"; } // end function print #endif
28
Bilişim Enstitüsü ++ Bilişim Enstitüsü ++ Bilişim Enstitüsü ++ Bilişim Enstitüsü ++ Bilişim Enstitüsü ++ Bilişim Enstitüsü ++ Bilişim Enstitüsü
Bilişim Enstitüsü ++ Bilişim Enstitüsü ++ Bilişim Enstitüsü ++ Bilişim Enstitüsü ++ Bilişim Enstitüsü ++ Bilişim Enstitüsü ++ Bilişim Enstitüsü 1 C LECTURE 12 ++ Data Structures 2 Data Structures 17.1
More informationIS 0020 Program Design and Software Tools
1 IS 0020 Program Design and Software Tools Templates Lecture 10 March 23, 2004 Introduction 2 Templates Function templates Specify entire range of related (overloaded) functions Function-template specializations
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 informationCpt S 122 Data Structures. Course Review FINAL. Nirmalya Roy School of Electrical Engineering and Computer Science Washington State University
Cpt S 122 Data Structures Course Review FINAL Nirmalya Roy School of Electrical Engineering and Computer Science Washington State University Final When: Wednesday (12/12) 1:00 pm -3:00 pm Where: In Class
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 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 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 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 information1 // Fig. 6.13: time2.cpp 2 // Member-function definitions for class Time. 3 #include <iostream> Outline. 4 5 using std::cout; 6 7 #include <iomanip>
CISC11 Introduction to Computer Science Dr. McCoy Lecture 20 November, 2009. Using Default Arguments with Constructors Constructors Can specify default arguments Default constructors Defaults all arguments
More informationIntroduction to Data Structures. Systems Programming
Introduction to Data Structures Systems Programming Intro to Data Structures Self-referential Structures Dynamic Memory Allocation A Simple malloc Example Linear Lists Linked Lists Insertion Example Linked
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 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 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 informationCOP4530 Data Structures, Algorithms and Generic Programming Recitation 4 Date: September 14/18-, 2008
COP4530 Data Structures, Algorithms and Generic Programming Recitation 4 Date: September 14/18-, 2008 Lab topic: 1) Take Quiz 4 2) Discussion on Assignment 2 Discussion on Assignment 2. Your task is to
More informationCMSC 341. Deques, Stacks and Queues 9/22/04 1
CMSC 341 Deques, Stacks and Queues 9/22/04 1 The Double-Ended Queue ADT The double ended queue is referred to as a Deque (rhymes with check ) Restricted List add to the end remove from the end add to the
More information1 Short Answer (7 Points Each)
1 Short Answer (7 Points Each) 1. Given the following function, what operations will need to be overloaded in the class T for this code to compile? template T square(t n) { return n * n; } The
More information! A data type for which: ! An ADT may be implemented using various. ! Examples:
Stacks and Queues Unit 6 Chapter 19.1-2,4-5 CS 2308 Fall 2018 Jill Seaman 1 Abstract Data Type A data type for which: - only the properties of the data and the operations to be performed on the data are
More informationWentworth 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
More informationCh. 18: ADTs: Stacks and Queues. Abstract Data Type
Ch. 18: ADTs: Stacks and Queues CS 2308 Fall 2011 Jill Seaman Lecture 18 1 Abstract Data Type A data type for which: - only the properties of the data and the operations to be performed on the data are
More informationCMSC 341 Lecture 6 Templates, Stacks & Queues. Based on slides by Shawn Lupoli & Katherine Gibson at UMBC
CMSC 341 Lecture 6 Templates, Stacks & Queues Based on slides by Shawn Lupoli & Katherine Gibson at UMBC Today s Topics Data types in C++ Overloading functions Templates How to implement them Possible
More informationChapter 12 - Templates
Chapter 12 - Templates O utline 12.1 Introd uction 12.2 Function Te m plate s 12.3 Ove rload ing Te m plate Functions 12.4 Class Te m p late s 12.5 Class Te m plate s and Non-type Param e te rs 12.6 Te
More informationCpt S 122 Data Structures. Templatized Stack
Cpt S 122 Data Structures Templatized Stack Nirmalya Roy School of Electrical Engineering and Computer Science Washington State University Test # 2 Jia XU (Lab Section 3) Xiaoyu Zhang (Lab Section 3) Anh
More informationChapter 17: Linked Lists
Chapter 17: Linked Lists 17.1 Introduction to the Linked List ADT Introduction to the Linked List ADT Linked list: set of data structures (nodes) that contain references to other data structures list head
More informationLinked List using a Sentinel
Linked List using a Sentinel Linked List.h / Linked List.h Using a sentinel for search Created by Enoch Hwang on 2/1/10. Copyright 2010 La Sierra University. All rights reserved. / #include
More informationADT: 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
More informationCOMP26120: Linked List in C (2018/19) Lucas Cordeiro
COMP26120: Linked List in C (2018/19) Lucas Cordeiro lucas.cordeiro@manchester.ac.uk Linked List Lucas Cordeiro (Formal Methods Group) lucas.cordeiro@manchester.ac.uk Office: 2.28 Office hours: 10-11 Tuesday,
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 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 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 informationDefinition of Stack. 5 Linked Structures. Stack ADT Operations. ADT Stack Operations. A stack is a LIFO last in, first out structure.
5 Linked Structures Definition of Stack Logical (or ADT) level: A stack is an ordered group of homogeneous items (elements), in which the removal and addition of stack items can take place only at the
More informationCMSC 341 Lecture 6 STL, Stacks, & Queues. Based on slides by Lupoli, Dixon & Gibson at UMBC
CMSC 341 Lecture 6 STL, Stacks, & Queues Based on slides by Lupoli, Dixon & Gibson at UMBC Templates 2 Common Uses for Templates Some common algorithms that easily lend themselves to templates: Swap what
More information"apple" "grape" "grape" "grape" "apple"
Test 1: CPS 100 Owen Astrachan and Dee Ramm February 21, 1997 Name: Honor code acknowledgment (signature) Problem 1 Problem 2 Problem 3 Problem 4 Problem 5 Problem 6 TOTAL: value 10 pts. 9 pts. 21 pts.
More informationChapter 17: Linked Lists
Chapter 17: Linked Lists Copyright 2009 Pearson Education, Inc. Copyright Publishing as Pearson 2009 Pearson Addison-Wesley Education, Inc. Publishing as Pearson Addison-Wesley 17.1 Introduction to the
More informationQueue Implementations
Queue Implementations 1 Circular Queues buffer of fixed capacity improvements and cost estimates 2 Deques the double ended queue queue as double linked circular list MCS 360 Lecture 17 Introduction to
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 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 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 informationPROBLEM 1 : (Vocabulary: 8 points) For each of the words/phrases below, circle the denition that is the best description as it pertains in the context
Test 1: CPS 100 Owen Astrachan February 12, 1996 Name: Honor code acknowledgement (signature) Problem 1 Problem 2 Problem 3 Problem 4 Extra TOTAL: value 8 pts. 18 pts. 13 pts. 16 pts. 6 pts. 57 pts. grade
More informationCSCE 110 PROGRAMMING FUNDAMENTALS
CSCE 110 PROGRAMMING FUNDAMENTALS WITH C++ Prof. Amr Goneid AUC Part 16. Linked Lists Prof. amr Goneid, AUC 1 Linked Lists Prof. amr Goneid, AUC 2 Linked Lists The Linked List Structure Some Linked List
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 informationUnit 4: Stacks and Queues
Unit 4: Stacks and Queues Engineering 4892: Data Structures Faculty of Engineering & Applied Science Memorial University of Newfoundland June 1, 2011 ENGI 4892 (MUN) Unit 4 June 1, 2011 1 / 24 1 Stacks
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 information! A data type for which: ! In fact, an ADT may be implemented by various. ! Examples:
Ch. 8: ADTs: Stacks and Queues Abstract Data Type A data type for which: CS 8 Fall Jill Seaman - only the properties of the data and the operations to be performed on the data are specific, - not concerned
More informationCSCE 110 PROGRAMMING FUNDAMENTALS
CSCE 110 PROGRAMMING FUNDAMENTALS WITH C++ Prof. Amr Goneid AUC Part 15. Dictionaries (1): A Key Table Class Prof. amr Goneid, AUC 1 Dictionaries(1): A Key Table Class Prof. Amr Goneid, AUC 2 A Key Table
More informationADTs: Stacks and Queues
Introduction to the Stack ADTs: Stack: a data structure that holds a collection of elements of the same type. - The elements are accessed according to LIFO order: last in, first out - No random access
More informationIntroduction to the C programming language
Introduction to the C programming language From C to C++: Stack and Queue Giuseppe Lipari http://retis.sssup.it/~lipari Scuola Superiore Sant Anna Pisa February 23, 2010 Outline 1 From struct to classes
More informationShort 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
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 informationIntroduction to the C programming language
Introduction to the C programming language From C to C++: Stack and Queue Giuseppe Lipari http://retis.sssup.it/~lipari Scuola Superiore Sant Anna Pisa February 23, 2010 Outline 1 From struct to classes
More informationLists. linking nodes. constructors. chasing pointers. MCS 360 Lecture 11 Introduction to Data Structures Jan Verschelde, 17 September 2010.
1 2 3 MCS 360 Lecture 11 Introduction to Data Structures Jan Verschelde, 17 September 2010 1 2 3 efficient updates with lists At http://www.sgi.com/tech/stl/ is the Standard Template Library Programmer
More informationCS201 - 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
More informationCSE030 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
More informationPropedéutico de Programación
Propedéutico de Programación Coordinación de Ciencias Computacionales Semana 4, Tercera Parte Dra. Pilar Gómez Gil Versión 1.1 01.07.08 http://ccc.inaoep.mx/~pgomez/cursos/programacion/ Capítulo 5 ADT
More informationMultiple choice questions. Answer on Scantron Form. 4 points each (100 points) Which is NOT a reasonable conclusion to this sentence:
Multiple choice questions Answer on Scantron Form 4 points each (100 points) 1. Which is NOT a reasonable conclusion to this sentence: Multiple constructors for a class... A. are distinguished by the number
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 informationContainers: Queue and List. Jordi Cortadella and Jordi Petit Department of Computer Science
Containers: Queue and List Jordi Cortadella and Jordi Petit Department of Computer Science Queue A container in which insertion is done at one end (the tail) and deletion is done at the other end (the
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 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 informationIntroduction to the Stack. Stacks and Queues. Stack Operations. Stack illustrated. elements of the same type. Week 9. Gaddis: Chapter 18
Stacks and Queues Week 9 Gaddis: Chapter 18 CS 5301 Fall 2015 Jill Seaman Introduction to the Stack Stack: a data structure that holds a collection of elements of the same type. - The elements are accessed
More informationStack and Queue. Stack:
Stack and Queue Stack: Abstract Data Type A stack is a container of objects that are inserted and removed according to the last-in first-out (LIFO) principle. In the pushdown stacks only two operations
More informationAn Introduction to Queues With Examples in C++
An Introduction to Queues With Examples in C++ Prof. David Bernstein James Madison University Computer Science Department bernstdh@jmu.edu Motivation Queues are very straightforward but are slightly more
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 informationName CPTR246 Spring '17 (100 total points) Exam 3
Name CPTR246 Spring '17 (100 total points) Exam 3 1. Linked Lists Consider the following linked list of integers (sorted from lowest to highest) and the changes described. Make the necessary changes in
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 informationB-Trees. nodes with many children a type node a class for B-trees. an elaborate example the insertion algorithm removing elements
B-Trees 1 B-Trees nodes with many children a type node a class for B-trees 2 manipulating a B-tree an elaborate example the insertion algorithm removing elements MCS 360 Lecture 35 Introduction to Data
More informationTrees can be used to store entire records from a database, serving as an in-memory representation of the collection of records in a file.
Large Trees 1 Trees can be used to store entire records from a database, serving as an in-memory representation of the collection of records in a file. Trees can also be used to store indices of the collection
More informationDDS Dynamic Search Trees
DDS Dynamic Search Trees 1 Data structures l A data structure models some abstract object. It implements a number of operations on this object, which usually can be classified into l creation and deletion
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 informationLinked Lists. Linked list: a collection of items (nodes) containing two components: Data Address (link) of the next node in the list
Linked Lists Introduction : Data can be organized and processed sequentially using an array, called a sequential list Problems with an array Array size is fixed Unsorted array: searching for an item is
More informationLinked Lists. Linked list: a collection of items (nodes) containing two components: Data Address (link) of the next node in the list
Linked Lists Introduction : Data can be organized and processed sequentially using an array, called a sequential list Problems with an array Array size is fixed Unsorted array: searching for an item is
More informationTemplates (again) Professor Hugh C. Lauer CS-2303, System Programming Concepts
Templates (again) 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 Walter
More informationChapter 5. ADTs Stack and Queue
Chapter 5 ADTs Stack and Queue Stacks of Coins and Bills Stacks of Boxes and Books TOP OF THE STACK TOP OF THE STACK Logical (or ADT) level: A stack is an ordered group of homogeneous items (elements),
More informationTop of the Stack. Stack ADT
Module 3: Stack ADT Dr. Natarajan Meghanathan Professor of Computer Science Jackson State University Jackson, MS 39217 E-mail: natarajan.meghanathan@jsums.edu Stack ADT Features (Logical View) A List that
More informationAN OVERVIEW OF C++ 1
AN OVERVIEW OF C++ 1 OBJECTIVES Introduction What is object-oriented programming? Two versions of C++ C++ console I/O C++ comments Classes: A first look Some differences between C and C++ Introducing function
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 informationdouble d0, d1, d2, d3; double * dp = new double[4]; double da[4];
All multiple choice questions are equally weighted. You can generally assume that code shown in the questions is intended to be syntactically correct, unless something in the question or one of the answers
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 informationC++ Templates. David Camp
C++ Templates David Camp C Marcos #define () #define min(i, j) (((i) < (j))? (i) : (j)) #define max(i, j) (((i) > (j))? (i) : (j)) #define RADTODEG(x)
More informationPROBLEM 1 : (Vocabulary: 8 points) For each of the words/phrases below, circle the denition that is the best description as it pertains in the context
Test 1: CPS 100 Owen Astrachan October 5, 1994 Name: Honor code acknowledgement (signature) Problem 1 Problem 2 Problem 3 Problem 4 Problem 5 TOTAL: value 8 pts. 6 pts. 14 pts. 10 pts. 14 pts. 52 pts.
More informationCS 112 Introduction to Computing II. Wayne Snyder Computer Science Department Boston University
CS 112 Introduction to Computing II Wayne Snyder Department Boston University Today Introduction to Linked Lists Stacks and Queues using Linked Lists Next Time Iterative Algorithms on Linked Lists Reading:
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 informationUniversity of Illinois at Urbana-Champaign Department of Computer Science. First Examination
University of Illinois at Urbana-Champaign Department of Computer Science First Examination CS 225 Data Structures and Software Principles Spring 2007 7p-9p, Thursday, March 1 Name: NetID: Lab Section
More informationEECE.3220: Data Structures Spring 2017
EECE.3220: Data Structures Spring 2017 Lecture 14: Key Questions February 24, 2017 1. Describe the characteristics of an ADT to store a list. 2. What data members would be necessary for a static array-based
More informationMore Group HW. #ifndef Stackh #define Stackh. #include <cstdlib> using namespace std;
More Group HW The following code is contained in the file ex1stck.h. Fill in the blanks with the C++ statement(s) that will correctly finish the method. Each blank may be filled in with more than one statement.
More informationCS 270 Algorithms. Oliver Kullmann. Binary search. Lists. Background: Pointers. Trees. Implementing rooted trees. Tutorial
Week 7 General remarks Arrays, lists, pointers and 1 2 3 We conclude elementary data structures by discussing and implementing arrays, lists, and trees. Background information on pointers is provided (for
More informationCS302 - Data Structures using C++
CS302 - Data Structures using C++ Topic: Queues and Priority Queues Kostas Alexis Implementations of the ADT Queue Like stacks, queues can have Array-based or Link-based implementation Can also use implementation
More informationMotivation for Templates
Motivation for You want both: a list of Location objects a list of MazeMonster objects 1 How can you accomplish this by writing one LinkedList class? state all the ways you can think of doing this state
More informationA linear-list Data Structure where - addition of elements to and - removal of elements from are restricted to the first element of the list.
A linear-list Data Structure where - addition of elements to and - removal of elements from are restricted to the first element of the list. the first element of the list a new element to (the Top of)
More informationUniversity of Illinois at Urbana-Champaign Department of Computer Science. First Examination
University of Illinois at Urbana-Champaign Department of Computer Science First Examination CS 225 Data Structures and Software Principles Spring 2007 7p-9p, Thursday, March 1 Name: NetID: Lab Section
More informationExample Final Questions Instructions
Example Final Questions Instructions This exam paper contains a set of sample final exam questions. It is for practice purposes only. You ll most likely need longer than three hours to answer all the questions.
More informationTrees can be used to store entire records from a database, serving as an in-memory representation of the collection of records in a file.
Large Trees 1 Trees can be used to store entire records from a database, serving as an in-memory representation of the collection of records in a file. Trees can also be used to store indices of the collection
More informationQueue with Array Implementation
Queue with Array Implementation SCSJ2013 Data Structures & Algorithms Nor Bahiah Hj Ahmad & Dayang Norhayati A. Jawawi Faculty of Computing Objectives Queue concepts and applications. Queue structure and
More informationChapter 11. Abstract Data Types and Encapsulation Concepts
Chapter 11 Abstract Data Types and Encapsulation Concepts The Concept of Abstraction An abstraction is a view or representation of an entity that includes only the most significant attributes The concept
More informationData Structure. Recitation VII
Data Structure Recitation VII Recursion: Stack trace Queue Topic animation Trace Recursive factorial Executes factorial(4) Step 9: return 24 Step 8: return 6 factorial(4) Step 0: executes factorial(4)
More informationFirst Examination. CS 225 Data Structures and Software Principles Spring p-9p, Tuesday, February 19
Department of Computer Science First Examination CS 225 Data Structures and Software Principles Spring 2008 7p-9p, Tuesday, February 19 Name: NetID: Lab Section (Day/Time): This is a closed book and closed
More informationThe 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 informationCS 2150 Exam 1, Spring 2018 Page 1 of 6 UVa userid:
CS 2150 Exam 1, Spring 2018 Page 1 of 6 UVa userid: CS 2150 Exam 1 Name You MUST write your e-mail ID on EACH page and put your name on the top of this page, too. If you are still writing when pens down
More informationCpSc212 Goddard Notes Chapter 10. Linked Lists
CpSc212 Goddard Notes Chapter 10 Linked Lists 10.1 Links and Pointers The linked list is not an ADT in its own right; rather it is a way of implementing many data structures. It is designed to replace
More informationProgramsystemkonstruktion med C++: Övning 2. Karl Palmskog september 2010
Programsystemkonstruktion med C++: Övning 2 Karl Palmskog palmskog@kth.se september 2010 Specalfunktioner in classes Constructor constructors of a class initializes class members initial values can be
More informationDoubly-Linked Lists
Doubly-Linked Lists 4-02-2013 Doubly-linked list Implementation of List ListIterator Reading: Maciel, Chapter 13 HW#4 due: Wednesday, 4/03 (new due date) Quiz on Thursday, 4/04, on nodes & pointers Review
More information