Save this PDF as:

Size: px
Start display at page:

## Transcription

1 Linked Lists Ch 17 (Gaddis) Introduction to Linked Lists A data structure representing a A series of nodes chained together in sequence CS 3358 Summer I 2012 Jill Seaman - Each node points to one other node. A separate pointer (the ) points to the first item in the. The last element points to nothing () 1 2 Introduction to Linked Lists The nodes are dynamically allocated - The grows and shrinks as nodes are added/ removed. Linked s can easily insert a node between other nodes Linked s can easily delete a node from between other nodes Each node contains: Node Organization - data field may be organized as a structure, an object, etc. - a pointer that can point to another node data pointer 3 4

2 Empty List An empty contains 0 nodes. The points to (address 0) (There are no nodes, it s empty) Declaring the Linked List data type We will be defining a class for a linked data type that can store values of type double. The data type will describe the values (the s) and operations over those values. In order to define the values we must: - define a data type for the nodes - define a pointer variable () that points to the first node in the. 5 6 static int getobjectcount(); Declaring the Node data type Defining the Linked List variable Use a struct for the node type struct ListNode { double value; ListNode *next; ; (this is just a data type, no variables declared) next can hold the address of a ListNode. Define a pointer for the of the : ListNode * = ; It must be initialized to to signify the end of the. Now we have an empty linked : - it can also be - self-referential data structure 7 8 static int getobjectcount(); static int getobjectcount();

3 Using Linked List operations Equivalent to address 0 Used to specify end of the Use ONE of the following for : #include <iostream> #include <cstddef> to test a pointer for (these are equivalent): while (p)... <==> while (p!= )... if (!p)... <==> if (p == )... Basic operations: - create a new, empty - append a node to the end of the - insert a node within the - delete a node - display the linked - delete/destroy the - copy constructor (and operator=) 9 10 static int getobjectcount(); static int getobjectcount(); Linked List class declaration // file NumberList.h Linked List functions: constructor #include <cstddef> using namespace std; // for Constructor: sets up empty class NumberList { private: struct ListNode // the node data type { double value; // data struct ListNode *next; // ptr to next node ; ListNode *; // the public: NumberList(); NumberList(const NumberList & src); ~NumberList(); // file NumberList.cpp #include "NumberList.h" NumberList::NumberList() { = ; ; void appendnode(double); void insertnode(double); void deletenode(double); void displaylist(); 11 12

4 Linked List functions: appendnode Linked List functions: appendnode appendnode: adds new node to end of Algorithm: How to find the last node in the? Algorithm: Create a new node and store the data in it If the has no nodes (it s empty) Make point to the new node. Else Find the last node in the Make the last node point to the new node When defining operations, always consider special cases: Empty Make a pointer p point to the first element while (the node p points to) is not pointing to make p point to (the node p points to) is pointing to In C++: ListNode *p = ; while ((*p).next!= ) p = (*p).next; ListNode *p = ; while (p->next) p = p->next; First element, front of the (when pointer is involved) <==> p=p->next is like i++ ListNode *p = ; Linked List functions: appendnode Traversing a Linked List void NumberList::appendNode(double num) { ListNode *newnode; // To point to the new node // Create a new node and store the data in it newnode = new ListNode; newnode->value = num; newnode->next = ; // If empty, make point to new node if (!) = newnode; else { ListNode *nodeptr; // To move through the nodeptr = ; // initialize to start of // traverse to find last node while (nodeptr->next) //it s not last nodeptr = nodeptr->next; //make it pt to next // now nodeptr pts to last node // make last node point to newnode nodeptr->next = newnode; 15 Visit each node in a linked, to - display contents, sum data, test data, etc. Basic process: set a pointer to point to what points to while pointer is not process data of current node go to the next node by setting the pointer to the pointer field of the current node end while 16

5 Linked List functions: displaylist Driver to demo NumberList void NumberList::displayList() { ListNode *nodeptr; //ptr to traverse the // start nodeptr at the of the nodeptr = ; // while nodeptr pts to something (not ), continue while (nodeptr) { //Display the value in the current node cout << nodeptr->value << endl; ListDriver.cpp //ListDriver.cpp: using NumberList #include "NumberList.h" int main() { //Move to the next node nodeptr = nodeptr->next; Or the short version: void NumberList::displayList() { ListNode *nodeptr; for (nodeptr = ; nodeptr; nodeptr = nodeptr->next) cout << nodeptr->value << endl; 17 // Define the NumberList ; // Append some values to the.appendnode(2.5);.appendnode(7.9);.appendnode(); // Display the values in the..displaylist(); return 0; Output: Deleting a Node from a Linked List Deleting a node deletenode: removes node from, and deletes (deallocates) the removed node. Requires two pointers: - one to point to the node to be deleted - one to point to the node before the node to be deleted. previousnode nodeptr Change the pointer of the previous node to point to the node after the one to be deleted. previousnode previousnode->next = nodeptr->next; nodeptr Now just delete the nodeptr node Deleting 13 from the 19 20

6 Deleting a node After the node is deleted: previousnode delete nodeptr; nodeptr Delete Node Algorithm Delete the node containing num If is empty, exit If first node is num make p point to first node make point to second node delete p else use p to traverse the, until it points to num or --as p is advancing, make n point to the node before if (p is not ) make n s node point to what p s node points to delete p s node 22 Linked List functions: deletenode void NumberList::deleteNode(double num) { if (!) return; // empty, exit ListNode *nodeptr; // to traverse the if (->value == num) { // if first node is num nodeptr = ; = nodeptr->next; delete nodeptr; else { ListNode *previousnode; // trailing node pointer nodeptr = ; // traversal ptr, set to first node // skip nodes not equal to num, stop at last while (nodeptr && nodeptr->value!= num) { previousnode = nodeptr; // save it! nodeptr = nodeptr->next; // advance it if (nodeptr) { // num is found, set links + delete previousnode->next = nodeptr->next; delete nodeptr; 23 // else: end of, num not found in, do nothing Driver to demo NumberList ListDriver.cpp // set up the NumberList ;.appendnode(2.5);.appendnode(7.9);.appendnode();.displaylist(); Nice test case, checks all three cases cout << endl << "remove 7.9:" << endl;.deletenode(7.9);.displaylist(); cout << endl << "remove 8.9: " << endl;.deletenode(8.9);.displaylist(); cout << endl << "remove 2.5: " << endl;.deletenode(2.5);.displaylist(); Output: remove 7.9: 2.5 remove 8.9: 2.5 remove 2.5: 24

7 Destroying a Linked List The destructor must delete (deallocate) all nodes used in the To do this, use traversal to visit each node For each node, - save the address of the next node in a pointer - delete the node Linked List functions: destructor ~NumberList: deallocates all the nodes NumberList::~NumberList() { ListNode *nodeptr; // traversal ptr ListNode *nextnode; // saves the next node nodeptr = ; //start at of while (nodeptr) { nextnode = nodeptr->next; // save the next delete nodeptr; // delete current nodeptr = nextnode; // advance ptr Inserting a Node into a Linked List Requires two pointers: - pointer to point to the node after the insertion point - pointer to point to node before point of insertion New node is inserted between the nodes pointed at by these pointers Inserting a Node into a Linked List New node created, new position located: previousnode nodeptr The before and after pointers move in tandem as the is traversed to find the insertion point - Like delete newnode

8 Inserting a Node into a Linked List Insert Node Algorithm Insertion completed: newnode 17 previousnode nodeptr 29 Insert node in a certain position Create the new node, store the data in it If is empty, make point to new node, new node to null else use p to traverse the, until it points to node after insertion point or --as p is advancing, make n point to the node before if p points to first node (n is null) make point to new node new node to p s node else make n s node point to new node 30 make new node point to p s node Insert Node Algorithm Linked List functions: insertnode Note that the insertnode implementation that follows assumes that the is sorted. The insertion point is - immediately before the first node in the that has a value greater than the value being inserted or - at the end if the value is greater than all items in the. Not always applicable, but it is a good demonstration of inserting a node in the middle of a. 31 insertnode: inserts num into middle of void NumberList::insertNode(double num) { ListNode *newnode; // ptr to new node ListNode *nodeptr; // ptr to traverse ListNode *previousnode; // node previous to nodeptr //allocate new node newnode = new ListNode; newnode->value = num; // empty, insert at front if (!) { = newnode; newnode->next = ; //else is on the next slide... 32

9 Linked List functions: insertnode else { // initialize the two traversal ptrs nodeptr = ; previousnode = ; Driver to demo NumberList ListDriver.cpp // skip all nodes less than num while (nodeptr && nodeptr->value < num) { previousnode = nodeptr; // save nodeptr = nodeptr->next; // advance if (previousnode == ) { //insert before first = newnode; newnode->next = nodeptr; else { previousnode->next = newnode; newnode->next = nodeptr; //insert after previousnode int main() { // set up the NumberList ;.appendnode(2.5);.appendnode(7.9);.appendnode();.insertnode(10.5);.displaylist(); return 0; Output: What if num is bigger than all items in the? Copy Constructor Pointers + dynamic allocation => deep copy Don t copy any pointers Linked List functions: copy constructor NumberList::NumberList(const NumberList & src) { = ; // initialize empty Initialize to For each item in the src (in order) append item.value to this // traverse src, append its values to end of this ListNode *nodeptr; for (nodeptr=src.; nodeptr; nodeptr=nodeptr->next) { appendnode(nodeptr->value); 35 36

10 Chapter 17 in Weiss book Elegant implementation of linked s It uses a er node - empty node, immediately before the first node in the - eliminates need for most special cases - internal traversals must skip that node - not visible to users of the class 37 Chapter 17 in Weiss book It uses three separate classes (w/ friend access) - LListNode (value+next ptr) - LListItr (an iterator) - LList (the linked, with operations) What is an iterator? - a reference/ptr to a specific element in a specific - Operations: advance: make it point to next element retrieve: return the value it points to (dereference) isvalid: returns true if not (it points to an element) 38 Circular linked Linked List variations - last cell s next pointer points to the first element. Doubly linked Linked List variations - each node has two pointers, one to the next node and one to the previous node - points to first element, tail points to last. - can traverse in reverse direction by starting at the tail and using p=p->prev

### Chapter 13. Pointers and Linked Lists

Chapter 13 Pointers and Linked Lists Overview 13.1 Nodes and Linked Lists 13.2 Stacks and Queues Slide 13-2 13.1 Nodes and Linked Lists Nodes and Linked Lists n A linked list is a list that can grow and

Chapter 4: Linked Lists Data Abstraction & Problem Solving with C++ Fifth Edition by Frank M. Carrano Preliminaries Options for implementing an ADT List Array has a fixed size Data must be shifted during

### Data Structures Using C++ 2E. Chapter 5 Linked Lists

Data Structures Using C++ 2E Chapter 5 Linked Lists Test #1 Next Thursday During Class Cover through (near?) end of Chapter 5 Objectives Learn about linked lists Become aware of the basic properties of

Linked List as an ADT (cont d.) Default constructor Initializes list to an empty state Destroy the list Deallocates memory occupied by each node Initialize the list Reinitializes list to an empty state

### Data Structures Using C++ 2E. Chapter 5 Linked Lists

Data Structures Using C++ 2E Chapter 5 Linked Lists Doubly Linked Lists Traversed in either direction Typical operations Initialize the list Destroy the list Determine if list empty Search list for a given

C++ How to Program, 8/e 1992-2012 by Pearson Education, Inc. 1992-2012 by Pearson Education, Inc. 1992-2012 by Pearson Education, Inc. We ve studied fixed-size data structures such as one-dimensional arrays

Linked Lists Linked Lists, Queues, and Stacks CSE 10: Introduction to C Programming Fall 200 Dynamic data structure Size is not fixed at compile time Each element of a linked list: holds a value points

Unordered Linked Lists Derive class unorderedlinkedlist from the abstract class linkedlisttype Implement the operations search, insertfirst, insertlast, deletenode See code on page 292 Defines an unordered

### University 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 Fall 2007 7p-9p, Thursday, October 4 Name: NetID: Lab Section

### CS2 Final Study Guide

CS2 Final Study Guide - Know how to write an assignment operator, copy constructor and destructor for a simple class that has dynamically allocated memory. Trees 1. Define the following terms o binary

Chapter 7 Linked Lists In order to use linked lists, you need to learn how to allocate memory dynamically on the heap and you need to learn about objects. Recall that local variables are temporary which

### International Journal Of Engineering Research & Management Technology

International Journal Of Engineering Research & Management Technology ISSN: 2348-4039 September- 2014 Volume 1, Issue-5 Dynamic Implementation Using Linked List Karuna Department of Information and Technology

### Node-Based Structures Linked Lists: Implementation

Linked Lists: Implementation CS 311 Data Structures and Algorithms Lecture Slides Monday, March 30, 2009 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks CHAPPELLG@member.ams.org

### ! A particular way of storing and organizing data in. ! A data type having

Introduction to ADTs and C++ STL Abstract Data Types Standard Template Library CS 3358 Spring 2015 Jill Seaman Data Structure A particular way of storing and organizing data in a computer so that it can

### Review: arrays, pointers, structures (Chapter 1) Data Types. Review: Arrays. Data Types (C/C++) Data Type: CS 3358 Summer I 2012.

Review: arrays, pointers, structures (Chapter 1) Data Types Data Type: CS 3358 Summer I 2012 Jill Seaman set of values set of operations over those values example: Integer whole numbers, -32768 to 32767

### Lecture 6b Linked List Variations. Similar but not the same

Lecture 6b Linked List Variations Similar but not the same Linked List Variations: Overview The linked list implementation used in List ADT is known as Singly (Single) Linked List Each node has one pointer

### SYSTEMS PROGRAMMING C++ INTRODUCTION

Faculty of Computer Science / Institute of Systems Architecture / Operating Systems SYSTEMS PROGRAMMING C++ INTRODUCTION Alexander Warg WHY C++? C++ is the language that allows to express ideas from the

### ! instance variable: a member variable in a class. ! static variable: one variable shared among all. ! static member function:

Ch 14: More About Classes 14.1 Instance and Static Members instance variable: a member variable in a class. Each object (instance) has its own copy. CS 2308 Spring 2014 Jill Seaman 1 static variable: one

### CSCE 206: Structured Programming in C++

CSCE 206: Structured Programming in C++ 2016 Fall Exam 3 Friday, November 18, 2016 Total - 100 Points B Instructions: Total of 11 pages, including this cover and the last page. Before starting the exam,

### CSCE 206: Structured Programming in C++

CSCE 206: Structured Programming in C++ 2016 Fall Exam 3 Friday, November 18, 2016 Total - 100 Points A Instructions: Total of 11 pages, including this cover and the last page. Before starting the exam,

### Example 7. na20.nada.kth.se 883)./a.out y = y = y = y = #include <iostream.h> #include <math.

In the example above two functions are defined. Both increments the value of i by one, but fcn1 uses call-by-value as parameter passing mechanism and fcn2 uses call-by-reference. call-by-value means that

### Dynamic Memory Allocation using a Custom Implemented Single-Linked List

Dynamic Memory Allocation using a Custom Implemented Single-Linked List Anders Eiler April 8, 2013 1 Introduction The objective of this paper is to describe how to dynamically allocate memory at runtime

### Storage Classes CS 110B - Rule Storage Classes Page 18-1 \handouts\storclas

CS 110B - Rule Storage Classes Page 18-1 Attributes are distinctive features of a variable. Data type, int or double for example, is an attribute. Storage class is another attribute. There are four storage

### Language Examples of ADT: C++

Language Examples of ADT: C++ Based on C struct type and Simula 67 classes All of the class instances of a class share a single copy of the member functions Each instance of a class has its own copy of

### Object-Oriented Programming, Iouliia Skliarova

Object-Oriented Programming, Iouliia Skliarova Data types define the way you use the storage (memory) in the programs. By specifying a data type, you tell the sompiler how to create a particular piece

LINKED DATA STRUCTURES 1 Linked Lists A linked list is a structure in which objects refer to the same kind of object, and where: the objects, called nodes, are linked in a linear sequence. we keep a reference

### Lecture 12 Doubly Linked Lists (with Recursion)

Lecture 12 Doubly Linked Lists (with Recursion) In this lecture Introduction to Doubly linked lists What is recursion? Designing a node of a DLL Recursion and Linked Lists o Finding a node in a LL (recursively)

### Output: 12 18 30 72 90 87. struct treenode{ int data; struct treenode *left, *right; } struct treenode *tree_ptr;

50 20 70 10 30 69 90 14 35 68 85 98 16 22 60 34 (c) Execute the algorithm shown below using the tree shown above. Show the exact output produced by the algorithm. Assume that the initial call is: prob3(root)

### Pointer. Accessing address of a variable POINTER.

www.cppforschool.com Pointer Accessing address of a variable Computer s memory is organized as a linear collection of bytes. Every byte in the computer s memory has an address. Each variable in program

### Summary. Pre requisition. Content Details: 1. Basics in C++

Summary C++ Language is one of the approaches to provide object-oriented functionality with C like syntax. C++ adds greater typing strength, scoping and other tools useful in object-oriented programming

### Inheritance and Virtual Functions. Linked lists.

Inheritance and Virtual Functions. Linked lists. 26th CS427 Lecture 12.2, 11am, 22nd March 2012 CS427 Inheritance and Virtual Functions. Linked lists. 1/27 In today s class 1 Recall... Inheritance 2 Replacing

### Singly Linked Lists and Chains

Chapter 4 Linked Lists Lecture 7-1 Singly Linked Lists and Chains Representing Chains in C++ Template Class Chain Circular Lists Available Space Lists Linked Stacks and Queues Polynomials Equivalence Classes

### A binary search tree or BST is a binary tree that is either empty or in which the data element of each node has a key, and:

Binary Search Trees 1 The general binary tree shown in the previous chapter is not terribly useful in practice. The chief use of binary trees is for providing rapid access to data (indexing, if you will)

### Abstract Data Type. EECS 281: Data Structures and Algorithms. The Foundation: Data Structures and Abstract Data Types

EECS 281: Data Structures and Algorithms The Foundation: Data Structures and Abstract Data Types Computer science is the science of abstraction. Abstract Data Type Abstraction of a data structure on that

### Engineering Problem Solving with C++, Etter

Engineering Problem Solving with C++, Etter Chapter 7 Strings 12-11-13 1 Strings Character Strings The string Class. 2 C style strings functions defined in cstring CHARACTER STRINGS 3 C Style Character

Arrays, Singly-Linked Lists, Stacks, Queues, Doubly-Linked Lists, Deques Slide Set 5: Learning Goals Differentiate an abstraction from an implementation. Define and give examples of problems that can be

### Integrating the C++ Standard Template Library Into the Undergraduate Computer Science Curriculum

Integrating the C++ Standard Template Library Into the Undergraduate Computer Science Curriculum James P. Kelsh James.Kelsh@cmich.edu Roger Y. Lee lee@cps.cmich.edu Department of Computer Science Central

### 1. A linked list is a list of items, called nodes, in which the order of the nodes is determined by the address, called a link, stored in each node.

1138 Chapter 17: Linked Lists QUICK REVIEW 1. A linked list is a list of items, called nodes, in which the order of the nodes is determined by the address, called a link, stored in each node. 2. The pointer

### Overview of Data Structures

UNIT 3 Concrete Data Types Classification of Data Structures Concrete vs. Abstract Data Structures Most Important Concrete Data Structures Arrays Records Linked Lists Binary Trees Overview of Data Structures

### Final Exam Review. CS 1428 Fall Jill Seaman. Final Exam

Final Exam Review CS 1428 Fall 2011 Jill Seaman 1 Final Exam Friday, December 9, 11:00am to 1:30pm Derr 241 (here) Closed book, closed notes, clean desk Comprehensive (covers entire course) 25% of your

### Iterators. node UML diagram. function objects. MCS 360 Lecture 12 Introduction to Data Structures Jan Verschelde, 20 September 2010

Iterators s 1 s 2 MCS 360 Lecture 12 Introduction to Data Structures Jan Verschelde, 20 September 2010 Iterators s 1 s 2 Linked s s A linked list is a sequence of nodes connected by pointers. We distinguish

### Part I: 22 Multiple choice questions (2 points each)

Part I: 22 Multiple choice questions (2 points each) Answer all of the following questions. READ EACH QUESTION CAREFULLY. Fill the correct bubble on your mark-sense sheet. Each correct question is worth

### Basics of I/O Streams and File I/O

Basics of This is like a cheat sheet for file I/O in C++. It summarizes the steps you must take to do basic I/O to and from files, with only a tiny bit of explanation. It is not a replacement for reading

### COMP 356 Programming Language Structures Notes for Chapter 5 of Concepts of Programming Languages Names, Types and Scopes

Some definitions: COMP 356 Programming Language Structures Notes for Chapter 5 of Concepts of Programming Languages Names, Types and Scopes a name is a string of characters (a word) that represents a program

### CS1020E: DATA STRUCTURES AND ALGORITHMS I

CS1020E: DATA STRUCTURES AND ALGORITHMS I Tutorial 1 Basic C++, OOP Problem Solving (Week 3, starting 22 August 2016) 1. Evaluation Order (Note: You can use any other C++ code editor/compiler). Examine

### 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++

Answer the following 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++ 2) Which data structure is needed to convert infix notations to postfix notations? Stack 3) The

### A linear structure is an ordered (e.g., sequenced) arrangement of elements.

Lists, Stacks, and Queues 1 A linear structure is an ordered (e.g., sequenced) arrangement of elements. There are three common types of linear structures: list stack queue random insertion and deletion

Lecture 11 Doubly Linked Lists & Array of Linked Lists In this lecture Doubly linked lists Array of Linked Lists Creating an Array of Linked Lists Representing a Sparse Matrix Defining a Node for a Sparse

### Short Notes on Dynamic Memory Allocation, Pointer and Data Structure

Short Notes on Dynamic Memory Allocation, Pointer and Data Structure 1 Dynamic Memory Allocation in C/C++ Motivation /* a[100] vs. *b or *c */ Func(int array_size) double k, a[100], *b, *c; b = (double

### DATA STRUCTURES USING C

DATA STRUCTURES USING C QUESTION BANK UNIT I 1. Define data. 2. Define Entity. 3. Define information. 4. Define Array. 5. Define data structure. 6. Give any two applications of data structures. 7. Give

### BM267 - Introduction to Data Structures

BM267 - Introduction to Data Structures 3. Elementary Data Structures Ankara University Computer Engineering Department BLM267 1 Objectives Learn about elementary data structures - Data structures that

### Lecture: #9-10. Binary Trees

Lecture: #9-10 Binary Trees Topics 1. Definition and Application of Binary Trees 2. Binary Search Tree Operations 3. Template Considerations for Binary Search Trees 19-2 1. Definition and Application of

### C++ INTERVIEW QUESTIONS

C++ INTERVIEW QUESTIONS http://www.tutorialspoint.com/cplusplus/cpp_interview_questions.htm Copyright tutorialspoint.com Dear readers, these C++ Interview Questions have been designed specially to get

### Advanced C++ Exception Handling Topic #5

Advanced C++ Exception Handling Topic #5 CS202 5-1 CS202 5-2 Exception Handling Throwing an Exception Detecting an Exception Catching an Exception Examine an Example using Classes and Operator Overloading

### Questions 1 through 25 are worth 2 points each. Choose one best answer for each.

Questions 1 through 25 are worth 2 points each. Choose one best answer for each. 1. For the singly linked list implementation of the queue, where are the enqueues and dequeues performed? c a. Enqueue in

Linked Data Structures 17 17.1 NODES AND LINKED LISTS 733 Nodes 733 Linked Lists 738 Inserting a Node at the Head of a List 740 Pitfall: Losing Nodes 743 Inserting and Removing Nodes Inside a List 743

### An Incomplete C++ Primer. University of Wyoming MA 5310

An Incomplete C++ Primer University of Wyoming MA 5310 Professor Craig C. Douglas http://www.mgnet.org/~douglas/classes/na-sc/notes/c++primer.pdf C++ is a legacy programming language, as is other languages

### UNIVERSITI MALAYSIA SARAWAK KOTA SAMARAHAN SARAWAK PSD2023 ALGORITHM & DATA STRUCTURE

STUDENT IDENTIFICATION NO UNIVERSITI MALAYSIA SARAWAK 94300 KOTA SAMARAHAN SARAWAK FAKULTI SAINS KOMPUTER & TEKNOLOGI MAKLUMAT (Faculty of Computer Science & Information Technology) Diploma in Multimedia

### Comp 245 Data Structures. Stacks

Comp 245 Data Structures Stacks What is a Stack? A LIFO (last in, first out) structure Access (storage or retrieval) may only take place at the TOP NO random access to other elements within the stack An

### Data Structures, Sample Test Questions for the Material after Test 2, with Answers

Data Structures, Sample Test Questions for the Material after Test 2, with Answers 1. Recall the public interfaces of classes List and ListIterator: typedef int ListItemType; class ListIterator{ public:

### Algorithms and Data Structures Written Exam Proposed SOLUTION

Algorithms and Data Structures Written Exam Proposed SOLUTION 2005-01-07 from 09:00 to 13:00 Allowed tools: A standard calculator. Grading criteria: You can get at most 30 points. For an E, 15 points are

### Chapter 2: Problem Solving Using C++

Chapter 2: Problem Solving Using C++ 1 Objectives In this chapter, you will learn about: Modular programs Programming style Data types Arithmetic operations Variables and declaration statements Common

Chapter 4 Linked Lists 4.1 Singly Linked lists Or Chains The representation of simple data structure using an array and a sequential mapping has the property: u Successive nodes of the data object are

A Linked List Example http://gd.tuwien.ac.at/languages/c/programming-bbrown/c_094.htm /* linked list example */ #include #include #include #include #include

### Tutorial 16 Shopping List Application: Introducing Pointers, References and Dynamic Data Structures

Tutorial 16 Shopping List Application: Introducing Pointers, References and Dynamic Data Structures Outline 16.1 Test-Driving the Shopping List Application 16.2 Introducing Pointers 16.3 Pointer Operators

### Two-Way Lists (Doubly Linked Lists)

Two-Way Lists (Doubly Linked Lists) Let's encapsulate linked lists as we did the Vector class. First we'll define a typical node in our list: struct Node { Node *prev; Node *next; double value; ; // previous

### C++ Mini-Course. Part 1: Mechanics Part 2: Basics Part 3: References Part 4: Const Part 5: Inheritance Part 6: Libraries Part 7: Conclusion. C Rulez!

C++ Mini-Course Part 1: Mechanics Part 2: Basics Part 3: References Part 4: Const Part 5: Inheritance Part 6: Libraries Part 7: Conclusion C Rulez! C++ Rulez! C++ Mini-Course Part 1: Mechanics C++ is a

### Stacks. Linear data structures

Stacks Linear data structures Collection of components that can be arranged as a straight line Data structure grows or shrinks as we add or remove objects ADTs provide an abstract layer for various operations

### Lecture 4 Notes: Arrays and Strings

6.096 Introduction to C++ January 10, 2011 Massachusetts Institute of Technology John Marrero Lecture 4 Notes: Arrays and Strings 1 Arrays So far we have used variables to store values in memory for later

### Quiz 4 Solutions EECS 211: FUNDAMENTALS OF COMPUTER PROGRAMMING II. 1 Q u i z 4 S o l u t i o n s

Quiz 4 Solutions Q1: What value does function mystery return when called with a value of 4? int mystery ( int number ) { if ( number

### C++FA 5.1 PRACTICE MID-TERM EXAM

C++FA 5.1 PRACTICE MID-TERM EXAM This practicemid-term exam covers sections C++FA 1.1 through C++FA 1.4 of C++ with Financial Applications by Ben Van Vliet, available at www.benvanvliet.net. 1.) A pointer

### ! A class in C++ is similar to a structure. ! A class contains members: - variables AND. - public: accessible outside the class.

Classes and Objects Week 5 Gaddis:.2-.12 14.3-14.4 CS 5301 Fall 2015 Jill Seaman The Class! A class in C++ is similar to a structure.! A class contains members: - variables AND - functions (often called

### CS271: Data Structures. Binary Search Trees

CS271: Data Structures Binary Search Trees This project has three parts: an implementation of a binary search tree class, a testing plan, and an experiment in tree height. 1. PART 1 Implement a binary

### 10CS35: Data Structures Using C

CS35: Data Structures Using C QUESTION BANK REVIEW OF STRUCTURES AND POINTERS, INTRODUCTION TO SPECIAL FEATURES OF C OBJECTIVE: Learn : Usage of structures, unions - a conventional tool for handling a

### Introduction to C++ Programming

Introduction to C++ Programming 1 Outline Introduction to C++ Programming A Simple Program: Printing a Line of Text Another Simple Program: Adding Two Integers Memory Concepts Arithmetic Decision Making:

### Curriculum Map. Discipline: Computer Science Course: C++

Curriculum Map Discipline: Computer Science Course: C++ August/September: How can computer programs make problem solving easier and more efficient? In what order does a computer execute the lines of code

### Chapter 6 Repetition

Chapter 6 Repetition 6-1 Repetition in C++ The final control/logic structure is repetition: Repetition repeating a block of code until a condition is met There are three repetition statements available

To extend understanding of pointers by using them to create dynamic data structures Understand when to use a Linked List Be able to create a Linked List in C understand internals be able to program them!

### Compsci210 tutorial. C++ File IO

Compsci210 tutorial C++ File IO Input/Output with files It s important and has many applications: Copy files. Generate many files from a list of contacts. Search, replace strings in text files. C++ provides

### Which of the following is the correct operator to compare two variables? A. := B. = C. equal D. ==

Group 1 Question 1. What is the correct value to return to the operating system upon the successful completion of a program? A. -1 B. 1 C. 0 D. Programs do not return a value. Question 2. What is the only

### Binary Search Trees (BST)

Binary Search Trees (BST) 1. Hierarchical data structure with a single pointer to node 2. Each node has at most two child nodes (a left and a right child) 3. Nodes are organized by the Binary Search property:

15 Pointers and Linked Lists 15.1 Nodes and Linked Lists 828 Nodes 828 Linked Lists 834 Inserting a Node at the Head of a List 835 Pitfall:Losing Nodes 839 Searching a Linked List 840 Pointers as Iterators

### FORM 1 (Please put your name, section # (10am- 001/2pm-002, and form # on the scantron!!!!) CS 161 Exam I:

FORM 1 (Please put your name, section # (10am- 001/2pm-002, and form # on the scantron!!!!) CS 161 Exam I: True (A)/False(B) (2 pts each): 1. The following statement is legal: cout >> Hello, my name is

### A pointer is a variable that stores the address of another variable, stored at an address in computer memory Hence, it points to another variable

Pointers 1 Pointers A pointer is a variable that stores the address of another variable, stored at an address in computer memory Hence, it points to another variable Purpose: Basis for implementing linked

### CmpSci 187: Programming with Data Structures Spring 2015

CmpSci 187: Programming with Data Structures Spring 2015 Lecture #12 John Ridgway March 10, 2015 1 Implementations of Queues 1.1 Linked Queues A Linked Queue Implementing a queue with a linked list is

### Data Structures and Data Manipulation

Data Structures and Data Manipulation What the Specification Says: Explain how static data structures may be used to implement dynamic data structures; Describe algorithms for the insertion, retrieval

### Data Structures. Topic #4

Topic #4 Today s Agenda Stack and Queue ADTs What are they Like Ordered Lists, are position oriented Use of Data Structures for Stacks and Queues arrays (statically & dynamically allocated) linear linked

### Linked Lists, Stacks, Queues, Deques. It s time for a chainge!

Linked Lists, Stacks, Queues, Deques It s time for a chainge! Learning Goals After this unit, you should be able to... Differentiate an abstraction from an implementation. Define and give examples of problems

Linked Lists and Iterators Chapter 4 Click to proceed How To View This Presentation This presentation is arranged in outline format. To view the slides in proper order For each slide Read the entire slide

### D06 PROGRAMMING with JAVA

Cicles Formatius de Grau Superior Desenvolupament d Aplicacions Informàtiques D06 PROGRAMMING with JAVA Ch20 Data Structures I PowerPoint presentation, created by Angel A. Juan - ajuanp(@)gmail.com, for

### Practice Problems (Midterm)

ECE-250 Algorithms and Data Structures (Winter 2012) Practice Problems (Midterm) Disclaimer: Please do keep in mind that this problem set does not reflect the exact topics or the fractions of each of the

### Engineering Problem Solving with C++, Etter/Ingber

Engineering Problem Solving with C++, Etter/Ingber Chapter 3 Control Structures 1 Control structures Algorithm Development Conditional Expressions Selection Statements Repetition Statements Structuring

### 1. Relational database accesses data in a sequential form. (Figures 7.1, 7.2)

Chapter 7 Data Structures for Computer Graphics (This chapter was written for programmers - option in lecture course) Any computer model of an Object must comprise three different types of entities: 1.

### Introduction to C. Memory Model. Instructor: Yin Lou 02/04/2011. Introduction to C CS 2022, Spring 2011, Lecture 6

Introduction to C Memory Model Instructor: Yin Lou 02/04/2011 Recap: Pointers int *ptr; Pointers are variables that store memory address of other variables Type of variable pointed to depends on type of

### BHARATHIAR UNIVERSITY: COIMBATORE CENTRE FOR COLLABORATION OF INDUSTRY AND INSTITUTIONS(CCII) CERTIFICATE IN ADVANCED PROGRAMMING C++ LANGUAGE

Certificate in Advanced Programming - C++ Language Page 1 of 7 BHARATHIAR UNIVERSITY: COIMBATORE 641046 CENTRE FOR COLLABORATION OF INDUSTRY AND INSTITUTIONS(CCII) CERTIFICATE IN ADVANCED PROGRAMMING C++

### Algorithms and Data Structures

Algorithms and Data Structures Part 2: Data Structures PD Dr. rer. nat. habil. Ralf-Peter Mundani Computation in Engineering (CiE) Summer Term 2016 Overview general linked lists stacks queues trees 2 2