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


 Annis Cole
 2 years ago
 Views:
Transcription
1 Linked Lists, Stacks, Queues, Deques It s time for a chainge!
2 Learning Goals After this unit, you should be able to... Differentiate an abstraction from an implementation. Define and give examples of problems that can be solved using the abstract data types stacks, queues and deques. Compare and contrast the implementations of these abstract data types using linked lists and circular arrays in C++. Demonstrate how dynamic memory management is handled in C++ (e.g., allocation, deallocation, memory heap, runtime stack). Gain experience with pointers in C++ and their tradeoffs and risks (dangling pointers, memory leaks). Explain the difference between the complexity of a problem (sorting) and the complexity of a particular algorithm for solving that problem. Manipulate data in stacks, queues, and deques (irrespective of any implementation).
3 Linked Lists: an alternative to arrays Can you think of any limitations with the array data structure?
4 Another note on abstract Data Types (Public) interface specifications Language independent
5 Linked Lists: an alternative to arrays A Linked List is an abstract data type for representing lists as collections of linked items Instead of having an overall representation of the list, the ordering of the list is represented locally That is, the information about what element comes next in a list is stored as a pointer within the element object. No list object (element) knows about any other elements in the list, just the ones to which it is adjacent
6 Linked Lists: an abstraction This is a pictorial representation of a singly linked list Note that it is not necessarily represented contiguously in memory, nor in the order the elements occur in the list itself
7 Linked Lists: implementation Let s take a look at how this is represented in C++
8 struct hockey_player { int jersey_number; string name; hockey_player* next; };... hockey_player * head = NULL;... void insert(int num, string name) { hockey_player * temp; temp = new hockey_player; temp>jersey_number = num; temp>name = name; } temp>next = head; head = temp; }
9 Comparison of Worst Case Complexities (for n entries): Assume we have a head pointer (only) for the linked list below. (Later: would your answers change if we also had a tail pointer?) Operation Array Array Linked List Linked List (unordered) (ordered) (unordered) (ordered) Insert at start O(1) O(n) O(1) O(1) Insert at end O(1) O(1) O(1) O(1) Insert after current position O(1) O(n) O(1) O(1) Find (search for) a value O(n) O(n)/O(lgn) O(n) O(n) Delete at current position O(1) O(n) O(1) O(1)
10 Comparison of Worst Case Complexities (for n entries): Assume we have a head pointer (only) for the linked list below. (Later: would your answers change if we also had a tail pointer?) Operation Array Array Linked List Linked List (unordered) (ordered) (unordered) (ordered) Insert at start O(1) O(n) O(1) O(1) Insert at end O(1) O(1) O(1) O(1) Insert after current position O(1) O(n) O(1) O(1) Find (search for) a value O(n) O(n)/O(lgn) O(n) O(n) Delete at current position O(1) O(n) O(1) O(1)
11 Comparison of Worst Case Complexities (for n entries): Assume we have a head pointer (only) for the linked list below. (Later: would your answers change if we also had a tail pointer?) Operation Array Array Linked List Linked List (unordered) (ordered) (unordered) (ordered) Insert at start O(1) O(n) O(1) O(1) Insert at end O(1) O(1) O(1) O(1) Insert after current position O(1) O(n) O(1) O(1) Find (search for) a value O(n) O(n)/O(lgn) O(n) O(n) Delete at current position O(1) O(n) O(1) O(1)
12 Comparison of Worst Case Complexities (for n entries): Assume we have a head pointer (only) for the linked list below. (Later: would your answers change if we also had a tail pointer?) Operation Array Array Linked List Linked List (unordered) (ordered) (unordered) (ordered) Insert at start O(1) O(n) O(1) O(1) Insert at end O(1) O(1) O(1) O(1) Insert after current position O(1) O(n) O(1) O(1) Find (search for) a value O(n) O(n)/O(lgn) O(n) O(n) Delete at current position O(1) O(n) O(1) O(1)
13 Comparison of Worst Case Complexities (for n entries): Assume we have a head pointer (only) for the linked list below. (Later: would your answers change if we also had a tail pointer?) Operation Array Array Linked List Linked List (unordered) (ordered) (unordered) (ordered) Insert at start O(1) O(n) O(1) O(1) Insert at end O(1) O(1) O(1) O(1) Insert after current position O(1) O(n) O(1) O(1) Find (search for) a value O(n) O(n)/O(lgn) O(n) O(n) Delete at current position O(1) O(n) O(1) O(1)
14 Stacks A stack operates on the LIFO principle: Last In, First Out. Push and pop operations have reallife analogies: a stack of trays or plates in a cafeteria, Pez dispenser, etc. Software examples: supporting a Web browser s Back button, passing variables to functions, keeping track of function calls (e.g., recursion), storing local variables, etc. Some stack operations and their complexities:  push(item) (add to top)  pop() (take off top)  returntop() (without removing)  empty() (is stack empty?)  getsize() (how many in stack?)
15 A stack can be implemented using either an array or a linked list:
16 Queues A queue operates on the FIFO principle: First In, First Out Reallife analogies: lineup at a bank or supermarket Software examples: Web browser requests to a server Some queue operations and their complexities:  enqueue(item)  dequeue()  getfirst(item) (without removing)  empty() (is it empty?)  getsize() (how many?)
17 A queue can be implemented using either a circular array or a linked list:
18 DoublyLinked Lists In what ways does a doublylinked list differ from a singlylinked list, besides the presence of an extra pointer? What are the advantages and disadvantages?
19 Deques A deque (pronounced deck ) is a doubleended queue. It acts like a queue, but we can insert at either end, and remove from either end. Like a queue, a deque can be implemented using either an array or a linked list. It is really an abstraction of the queue and stack.
20 Learning Goals After this unit, you should be able to... Differentiate an abstraction from an implementation. Define and give examples of problems that can be solved using the abstract data types stacks, queues and deques. Compare and contrast the implementations of these abstract data types using linked lists and circular arrays in C++. Demonstrate how dynamic memory management is handled in C++ (e.g., allocation, deallocation, memory heap, runtime stack). Gain experience with pointers in C++ and their tradeoffs and risks (dangling pointers, memory leaks). Explain the difference between the complexity of a problem (sorting) and the complexity of a particular algorithm for solving that problem. Manipulate data in stacks, queues, and deques (irrespective of any implementation).
Arrays, SinglyLinked Lists, Stacks, Queues, DoublyLinked Lists, Deques
Arrays, SinglyLinked Lists, Stacks, Queues, DoublyLinked Lists, Deques Slide Set 5: Learning Goals Differentiate an abstraction from an implementation. Define and give examples of problems that can be
More informationDATA 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
More informationQuiz 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
More informationLinked Lists Linked Lists, Queues, and Stacks
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
More informationcsci 210: Data Structures Stacks and Queues
csci 210: Data Structures Stacks and Queues Summary Topics stacks and queues as abstract data types implementations arrays linked lists analysis and comparison application: searching with stacks and queues
More information1) 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
More informationData Structures and Algorithms Stacks and Queues
Data Structures and Algorithms Stacks and Queues Chris Brooks Department of Computer Science University of San Francisco Department of Computer Science University of San Francisco p.1/23 60: Stacks and
More informationWhat is a Stack? Stacks and Queues. Stack Abstract Data Type. Java Interface for Stack ADT. Arraybased Implementation
Stacks and Queues What is a Stack? Stores a set of elements in a particular order Accessed in LastIn InFirstOut (LIFO) fashion Real life examples: Pile of books PEZ dispenser Cup trays in cafeteria
More informationData 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
More informationMemory Management. Memory Areas and their use. Memory Manager Tasks: Free List Implementations. acquire release
Memory Management Memory Areas and their use Memory Manager Tasks: acquire release Free List Implementations Singly Linked List Doubly Linked List Buddy Systems Memory Management Memory areas: In languages
More informationLinked Lists introduction. Characteristics of Linked Lists. Programming Linked Lists
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!
More informationQuestions 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
More informationData Structure [Question Bank]
Unit I (Analysis of Algorithms) 1. What are algorithms and how they are useful? 2. Describe the factor on best algorithms depends on? 3. Differentiate: Correct & Incorrect Algorithms? 4. Write short note:
More informationDATA STRUCTURE  STACK
DATA STRUCTURE  STACK http://www.tutorialspoint.com/data_structures_algorithms/stack_algorithm.htm Copyright tutorialspoint.com A stack is an abstract data type ADT, commonly used in most programming
More informationQUEUES. Primitive Queue operations. enqueue (q, x): inserts item x at the rear of the queue q
QUEUES A queue is simply a waiting line that grows by adding elements to its end and shrinks by removing elements from the. Compared to stack, it reflects the more commonly used maxim in realworld, namely,
More information5. A full binary tree with n leaves contains [A] n nodes. [B] log n 2 nodes. [C] 2n 1 nodes. [D] n 2 nodes.
1. The advantage of.. is that they solve the problem if sequential storage representation. But disadvantage in that is they are sequential lists. [A] Lists [B] Linked Lists [A] Trees [A] Queues 2. The
More informationChapter 13. Pointers and Linked Lists
Chapter 13 Pointers and Linked Lists Overview 13.1 Nodes and Linked Lists 13.2 Stacks and Queues Slide 132 13.1 Nodes and Linked Lists Nodes and Linked Lists n A linked list is a list that can grow and
More informationUniversidad Carlos III de Madrid
Universidad Carlos III de Madrid Algorithms and Data Structures (ADS) Bachelor in Informatics Engineering Computer Science Department Lists, Stacks and Queues. Authors: Isabel Segura Bedmar April 2011
More informationThis lecture. Abstract data types Stacks Queues. ADTs, Stacks, Queues 1. 2004 Goodrich, Tamassia
This lecture Abstract data types Stacks Queues ADTs, Stacks, Queues 1 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: Data stored Operations
More informationrecursion, O(n), linked lists 6/14
recursion, O(n), linked lists 6/14 recursion reducing the amount of data to process and processing a smaller amount of data example: process one item in a list, recursively process the rest of the list
More informationBM267  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
More information1. The memory address of the first element of an array is called A. floor address B. foundation addressc. first address D.
1. The memory address of the first element of an array is called A. floor address B. foundation addressc. first address D. base address 2. The memory address of fifth element of an array can be calculated
More informationUNIVERSITI 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
More informationModule 2 Stacks and Queues: Abstract Data Types
Module 2 Stacks and Queues: Abstract Data Types A stack is one of the most important and useful nonprimitive linear data structure in computer science. It is an ordered collection of items into which
More informationSTACKS,QUEUES, AND LINKED LISTS
STACKS,QUEUES, AND LINKED LISTS Stacks Queues Linked Lists DoubleEnded Queues Case Study: A Stock Analysis Applet 1 Stacks Astack is a container of objects that are inserted and removed according to the
More informationAbstract 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
More informationCommon Data Structures
Data Structures 1 Common Data Structures Arrays (single and multiple dimensional) Linked Lists Stacks Queues Trees Graphs You should already be familiar with arrays, so they will not be discussed. Trees
More informationKrishna Institute of Engineering & Technology, Ghaziabad Department of Computer Application MCA213 : DATA STRUCTURES USING C
Tutorial#1 Q 1: Explain the terms data, elementary item, entity, primary key, domain, attribute and information? Also give examples in support of your answer? Q 2: What is a Data Type? Differentiate
More informationInternational Journal Of Engineering Research & Management Technology
International Journal Of Engineering Research & Management Technology ISSN: 23484039 September 2014 Volume 1, Issue5 Dynamic Implementation Using Linked List Karuna Department of Information and Technology
More informationData Structures. value. key. 5 Alpha. 3 Beta. 7 Gamma
Data Structures key value 5 Alpha 10 2 7 5 1 4 9 3 6 8 3 Beta 7 Gamma Sequence Associative e.g., CArrays, std::vector, std::deque, std::list e.g., CArrays, std::map, std::set, std::unordered_map Data
More informationData Structures and Algorithms
Data Structures and Algorithms Lecture 4 2016 Stacks and... 1/28 1 2 Circular Linked 3 Queue Syntax and Functions in C++ 4 Stacks and... 2/28 FIFO and LIFO Outline Data structures can be specialized versions
More informationAnnouncements. FINAL EXAM Monday May 21, 1:30pm Review Session. Wednesday May 16, 79pm
Announcements FINAL EXAM Monday May 21, 1:30pm Review Session Wednesday May 16, 79pm 1 Recitation 12 Root Finding, Sorting, Stacks, Queues 2 Outline Linked Lists Sorting Queues 3 Object References Let
More informationTIE20106 1 TIE20106 2
TIE20106 1 1 List structures In this chapter, a few simple data structures (stack and queue) that can be implemented with arrays and/or lists are covered. Two more complex structures based on lists are
More informationStacks, Queues and Linked Lists
Stacks, Queues and Linked Lists Adnan Aziz 1 Dynamic sets CLRS Part III, page 197 In mathematics, a set is a welldefined collection of elements (elements could be numbers, functions, geometric shapes);
More informationAnalysis of a Search Algorithm
CSE 326 Lecture 4: Lists and Stacks 1. Agfgd 2. Dgsdsfd 3. Hdffdsf 4. Sdfgsfdg 5. Tefsdgass We will review: Analysis: Searching a sorted array (from last time) List ADT: Insert, Delete, Find, First, Kth,
More information10CS35: 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
More informationMAX = 5 Current = 0 'This will declare an array with 5 elements. Inserting a Value onto the Stack (Push) 
=============================================================================================================================== DATA STRUCTURE PSEUDOCODE EXAMPLES (c) Mubashir N. Mir  www.mubashirnabi.com
More informationQueues and Stacks. Atul Prakash Downey: Chapter 15 and 16
Queues and Stacks Atul Prakash Downey: Chapter 15 and 16 Queues Queues occur in real life a lot. Queues at checkout Queues in banks In software systems: Queue of requests at a web servers Properties of
More informationC++ How to Program, 8/e by Pearson Education, Inc. All Rights Reserved.
C++ How to Program, 8/e 19922012 by Pearson Education, Inc. 19922012 by Pearson Education, Inc. 19922012 by Pearson Education, Inc. We ve studied fixedsize data structures such as onedimensional arrays
More information12 Abstract Data Types
12 Abstract Data Types 12.1 Source: 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).
More informationData Structures and Algorithms
Data Structures and Algorithms CS2452016S04 Stacks and Queues David Galles Department of Computer Science University of San Francisco 040: Abstract Data Types An Abstract Data Type is a definition of
More informationIntroduction to Data Structures and Algorithms
Introduction to Data Structures and Algorithms Chapter: Elementary Data Structures(1) Lehrstuhl Informatik 7 (Prof. Dr.Ing. Reinhard German) Martensstraße 3, 91058 Erlangen Overview on simple data structures
More informationSystem Software Prof. Dr. H. Mössenböck
System Software Prof. Dr. H. Mössenböck 1. Memory Management 2. Garbage Collection 3. Linkers and Loaders 4. Debuggers 5. Text Editors Marks obtained by endterm exam http://ssw.jku.at/misc/ssw/ 1. Memory
More informationMemory Allocation. Static Allocation. Dynamic Allocation. Memory Management. Dynamic Allocation. Dynamic Storage Allocation
Dynamic Storage Allocation CS 44 Operating Systems Fall 5 Presented By Vibha Prasad Memory Allocation Static Allocation (fixed in size) Sometimes we create data structures that are fixed and don t need
More informationSt S a t ck a ck nd Qu Q eue 1
Stack and Queue 1 Stack Data structure with LastIn FirstOut (LIFO) behavior In Out C B A B C 2 Typical Operations Pop on Stack Push isempty: determines if the stack has no elements isfull: determines
More informationStacks and queues. Algorithms and Data Structures, Fall 2011. Rasmus Pagh. Based on slides by Kevin Wayne, Princeton
Algorithms and Data Structures, Fall 2011 Stacks and queues Rasmus Pagh Based on slides by Kevin Wayne, Princeton Algorithms, 4 th Edition Robert Sedgewick and Kevin Wayne Copyright 2002 2011 Stacks and
More informationCHAPTER 4 ESSENTIAL DATA STRUCTRURES
CHAPTER 4 ESSENTIAL DATA STRUCTURES 72 CHAPTER 4 ESSENTIAL DATA STRUCTRURES In every algorithm, there is a need to store data. Ranging from storing a single value in a single variable, to more complex
More informationCS0213 DATA STRUCTURES AND ALGORITHM LAB USING C & C++ LABORATORY MANUAL II  CSE III  SEMESTER ACADEMIC YEAR:
CS0213 DATA STRUCTURES AND ALGORITHM LAB USING C & C++ LABORATORY MANUAL II  CSE III  SEMESTER ACADEMIC YEAR: 20122013 SCHOOL OF COMPUTER SCIENCE & ENGINEERING SRM UNIVERSITY, SRM NAGAR, KATTANKULATHUR603203.
More informationCourse: Programming II  Abstract Data Types. The ADT Stack. A stack. The ADT Stack and Recursion Slide Number 1
Definition Course: Programming II  Abstract Data Types The ADT Stack The ADT Stack is a linear sequence of an arbitrary number of items, together with access procedures. The access procedures permit insertions
More informationChapter 7: Queues and Deques
Chapter 7: Queues and Deques After the stack, the next simplest data abstraction is the queue. As with the stack, the queue can be visualized with many examples you are already familiar with from everyday
More informationData Structures. Level 6 C30151. www.fetac.ie. Module Descriptor
The Further Education and Training Awards Council (FETAC) was set up as a statutory body on 11 June 2001 by the Minister for Education and Science. Under the Qualifications (Education & Training) Act,
More informationLecture 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)
More information406 memory pool memory allocation handle memory deallocation dynamic storage allocation
406 Chap. 12 Lists and Arrays Revisited 12.4 Memory Management Most of the data structure implementations described in this book store and access objects all of the same size, such as integers stored in
More informationAlgorithms and Data Structures
Basic Data Structures Page 1 BFHTI: Softwareschule Schweiz Basic Data Structures Dr. CAS SD01 Basic Data Structures Page 2 Outline Data Structures and Abstract Data Types Linear Data Structures Implementing
More informationCpt S 223. School of EECS, WSU
Abstract Data Types 1 Topics Abstract Data Types (ADTs) Some basic ADTs: Lists Stacks Queues 2 Primitive Data Type vs. Abstract Data Types Primitive DT: ADT: programmer progra ammer Interface (API) e.g.,
More informationData Structure. Lecture 3
Data Structure Lecture 3 Data Structure Formally define Data structure as: DS describes not only set of objects but the ways they are related, the set of operations which may be applied to the elements
More informationQueues Outline and Required Reading: Queues ( 4.2 except 4.2.4) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic
Queues Outline and Required Reading: Queues ( 4. except 4..4) COSC, Fall 3, Section A Instructor: N. Vlajic Queue ADT Queue linear data structure organized according to firstin/firstout (FIFO) principle!
More informationOverview 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
More information2. Names, Scopes, and Bindings
2. Names, Scopes, and Bindings Binding, Lifetime, Static Scope, Encapsulation and Modules, Dynamic Scope Copyright 2010 by John S. Mallozzi Names Variables Bindings Binding time Language design issues
More informationIntroduction to Data Structures
Introduction to Data Structures Albert Gural October 28, 2011 1 Introduction When trying to convert from an algorithm to the actual code, one important aspect to consider is how to store and manipulate
More informationData 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
More informationStacks & Queues. Data structures and Algorithms
Stacks & Queues Data structures and Algorithms Acknowledgement: These slides are adapted from slides provided with Data Structures and Algorithms in C++ Goodrich, Tamassia and Mount (Wiley, 2004) Outline
More informationPES Institute of TechnologyBSC QUESTION BANK
PES Institute of TechnologyBSC Faculty: Mrs. R.Bharathi CS35: Data Structures Using C QUESTION BANK UNIT I BASIC CONCEPTS 1. What is an ADT? Briefly explain the categories that classify the functions
More informationStandard Version of Starting Out with C++, 4th Edition. Linked Lists. Copyright 2003 Scott/Jones Publishing
Standard Version of Starting Out with C++, 4th Edition Linked Lists Copyright 2003 Scott/Jones Publishing Topics Introduction to the Linked List ADT Linked List Operations A Linked List Template Variations
More informationCourse: Programming II  Abstract Data Types. The ADT Queue. (Bobby, Joe, Sue, Ellen) Add(Ellen) Delete( ) The ADT Queues Slide Number 1
Definition Course: Programming II  Abstract Data Types The ADT Queue The ADT Queue is a linear sequence of an arbitrary number of items, together with access procedures. The access procedures permit addition
More information22c:31 Algorithms. Ch3: Data Structures. Hantao Zhang Computer Science Department http://www.cs.uiowa.edu/~hzhang/c31/
22c:31 Algorithms Ch3: Data Structures Hantao Zhang Computer Science Department http://www.cs.uiowa.edu/~hzhang/c31/ Linear Data Structures Now we can now explore some convenient techniques for organizing
More informationList, Stack and Queue. Tom Chao Zhou CSC2100B Data Structures Tutorial 3
List, Stack and Queue Tom Chao Zhou CSC2100B Data Structures Tutorial 3 Outline Structure Linked List Overview Implementation Stack Overview Implementation Queue Overview Implementation Structure A collection
More informationSequential Data Structures
Sequential Data Structures In this lecture we introduce the basic data structures for storing sequences of objects. These data structures are based on arrays and linked lists, which you met in first year
More informationUniversity of Illinois at UrbanaChampaign Department of Computer Science. First Examination
University of Illinois at UrbanaChampaign Department of Computer Science First Examination CS 225 Data Structures and Software Principles Fall 2007 7p9p, Thursday, October 4 Name: NetID: Lab Section
More informationChapter 3: Restricted Structures Page 1
Chapter 3: Restricted Structures Page 1 1 2 3 4 5 6 7 8 9 10 Restricted Structures Chapter 3 Overview Of Restricted Structures The two most commonly used restricted structures are Stack and Queue Both
More informationCompiler Design Prof. Y. N. Srikant Department of Computer Science and Automation Indian Institute of Science, Bangalore
Compiler Design Prof. Y. N. Srikant Department of Computer Science and Automation Indian Institute of Science, Bangalore Module No. # 02 Lecture No. # 05 Runtime EnvironmentsPart 3 and Local Optimizations
More informationClass Overview. CSE 326: Data Structures. Goals. Goals. Data Structures. Goals. Introduction
Class Overview CSE 326: Data Structures Introduction Introduction to many of the basic data structures used in computer software Understand the data structures Analyze the algorithms that use them Know
More informationData Structure and Algorithm I Midterm Examination 120 points Time: 9:10am12:10pm (180 minutes), Friday, November 12, 2010
Data Structure and Algorithm I Midterm Examination 120 points Time: 9:10am12:10pm (180 minutes), Friday, November 12, 2010 Problem 1. In each of the following question, please specify if the statement
More information\Mankinds's progress is measured by the number of. Elementary data structures such as stacks, queues,
Elementary Data Structures \Mankinds's progress is measured by the number of things we can do without thinking." Elementary data structures such as stacks, queues, lists, and heaps will be the \oftheshelf"
More informationBSc (Hons) Business Information Systems, BSc (Hons) Computer Science with Network Security. & BSc. (Hons.) Software Engineering
BSc (Hons) Business Information Systems, BSc (Hons) Computer Science with Network Security & BSc. (Hons.) Software Engineering Cohort: BIS/05/FT BCNS/05/FT BSE/05/FT Examinations for 20052006 / Semester
More informationGlossary of Object Oriented Terms
Appendix E Glossary of Object Oriented Terms abstract class: A class primarily intended to define an instance, but can not be instantiated without additional methods. abstract data type: An abstraction
More information4.3 Stacks and Queues. Pushdown Stacks. Data Structures and Data Types. Collections
Data Structures and Data Types 4.3 Stacks and Queues Data types Set values. Set operations on those values. Some are built in to Java: int, double, char,... Most are not: Complex, Picture, Charge, Stack,
More informationStacks. 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
More informationNodeBased 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
More informationData Structures Using C++ 2E. Chapter 7 Stacks
Data Structures Using C++ 2E Chapter 7 Stacks Linked Implementation of Stacks Disadvantage of array (linear) stack representation Fixed number of elements can be pushed onto stack Solution Use pointer
More informationHome Page. Data Structures. Title Page. Page 1 of 24. Go Back. Full Screen. Close. Quit
Data Structures Page 1 of 24 A.1. Arrays (Vectors) nelement vector start address + ielementsize 0 +1 +2 +3 +4... +n1 start address continuous memory block static, if size is known at compile time dynamic,
More informationData 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
More informationShort 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
More informationAlgorithms and Abstract Data Types
Algorithms and Abstract Data Types Informally, algorithm means is a welldefined computational procedure that takes some value, or set of values, as input and produces some other value, or set of values,
More informationLast not not Last Last Next! Next! Line Line Forms Forms Here Here Last In, First Out Last In, First Out not Last Next! Call stack: Worst line ever!
ECE 551 C++ Programming, Data structures, and Algorithms Abstract Data Type: Stack Last In First Out (LIFO) 1 2 2 1 4 3 1 3 4 Stacks in Programming Worst line ever! 5 3 1 5 Stacks are not useful for waiting
More informationJava Software Structures
INTERNATIONAL EDITION Java Software Structures Designing and Using Data Structures FOURTH EDITION John Lewis Joseph Chase This page is intentionally left blank. Java Software Structures,International Edition
More informationCollections & Data Structures. CS 3: Computer Programming in Java
Collections & Data Structures CS 3: Computer Programming in Java Objectives The concept of a collection Separating the interface from the implementation Dynamic data structures Linked lists Queues and
More informationAtmiya Infotech Pvt. Ltd. Data Structure. By Ajay Raiyani. Yogidham, Kalawad Road, Rajkot. Ph : 572365, 576681 1
Data Structure By Ajay Raiyani Yogidham, Kalawad Road, Rajkot. Ph : 572365, 576681 1 Linked List 4 Singly Linked List...4 Doubly Linked List...7 Explain Doubly Linked list: ...7 Circular Singly Linked
More informationLecture 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
More informationData Structures in the Java API
Data Structures in the Java API Vector From the java.util package. Vectors can resize themselves dynamically. Inserting elements into a Vector whose current size is less than its capacity is a relatively
More informationTowards Relaxing STM. Christoph M. Kirsch, Michael Lippautz! University of Salzburg. EuroTM Workshop, April 2014
Towards Relaxing STM Christoph M. Kirsch, Michael Lippautz! University of Salzburg! EuroTM Workshop, April 2014 Problem linear scalability positive scalability good performance throughput (#transactions/time)
More informationUNIT1 PARTA UNIT2 PARTA
UNIT1 1. Define computer? 2. Discuss briefly about input and output devices? 3. What is a RAM? 4. What is arom? 5. What is a compiler? 6. Write about a linker? 7. List any 5 key wordsof c? 8. Illustrate
More informationChapter 4: Linked Lists
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
More informationData 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
More informationAlgorithms and Data Structures
Algorithms and Data Structures Lists and Arrays Marcin Sydow Web Mining Lab PJWSTK Marcin Sydow (Web Mining Lab PJWSTK) Algorithms and Data Structures 1 / 35 Topics covered by this lecture: Linked Lists
More informationKITES TECHNOLOGY COURSE MODULE (C, C++, DS)
KITES TECHNOLOGY 360 Degree Solution www.kitestechnology.com/academy.php info@kitestechnology.com technologykites@gmail.com Contact:  8961334776 9433759247 9830639522.NET JAVA WEB DESIGN PHP SQL, PL/SQL
More informationJava Memory and Intro to OOP
+ Java Memory and Intro to OOP + What is Java? Programming language Standard libraries ex. Math.random() Tools: compiler, runtime, others + What is the compiler? AKA javac A compiler is a program that
More informationStacks. The stack ADT Stack Implementation. Stack Examples. using arrays using generic linked lists using List ADT. EECS 268 Programming II 1
Stacks The stack ADT Stack Implementation using arrays using generic linked lists using List ADT Stack Examples 1 Stacks and Queues Linear data structures each item has specific first, next, and previous
More informationStacks. Stacks (and Queues) Stacks. q Stack: what is it? q ADT. q Applications. q Implementation(s) CSCU9A3 1
Stacks (and Queues) 1 Stacks Stack: what is it? ADT Applications Implementation(s) 2 CSCU9A3 1 Stacks and ueues A stack is a very important data structure in computing science. A stack is a seuence of
More informationAbstract Data Types. Chapter 2
Chapter 2 Abstract Data Types The second idea at the core of computer science, along with algorithms, is data. In a modern computer, data consists fundamentally of binary bits, but meaningful data is organized
More information