Stacks & Their Applications (Postfix/Infix)
|
|
|
- Blaze Hudson
- 7 years ago
- Views:
Transcription
1 Stacks & Their Applications (Postfix/Infix) College of Computing & Information Technology King Abdulaziz University CPCS-204 Data Structures I
2 Outline Stacks What are they and how they work Stack Applications Infix to Postfix conversion Evaluation of Postfix expressions Stacks & Their Applications page 2
3 Stacks An Overview Abstract Data Type (ADT): What is an Abstract Data Type? To answer this, let us ask the negative of this: What is NOT an Abstract Data Type (in JAVA)? int int is a built-in type in the JAVA language double double is a built-in type in the JAVA language There are certainly many others we can list These data types are already built into the language. Stacks & Their Applications page 3
4 Stacks An Overview Abstract Data Type (ADT): So again, what is an Abstract Data Type? It is a data type that is NOT built into the language (well, for our purposes, it isn t!) It is a data type that we will build We will specify what it is, how it is used, etc. It is often defined in terms of its behavior rather than its implemented representation Nice definition from Wikipedia: An abstract data type is defined indirectly, only by the operations that may be performed on it (i.e. behavior) Stacks & Their Applications page 4
5 Stacks An Overview Stacks: Stacks are an Abstract Data Type They are NOT built into JAVA We must define them and their behaviors So what is a stack? A data structure that stores information in the form of a stack. Consists of a variable number of homogeneous elements i.e. elements of the same type Stacks & Their Applications page 5
6 Stacks An Overview Stacks: Access Policy: The access policy for a stack is simple: the first element to be removed from the stack is the last element that was placed onto the stack The main idea is that the last item placed on to the stack is the first item removed from the stack Known as the Last in, First out access policy LIFO for short The classical example of a stack is cafeteria trays. New, clean trays are added to the top of the stack. and trays are also taken from the top So the last tray in is the first tray taken out Stacks & Their Applications page 6
7 Stacks An Overview Stacks: Basic Operations: PUSH: POP: This PUSHes an item on top of the stack This POPs off the top item in the stack and returns it Other important tidbit: The end of the stack, where PUSHes and POPs occur, is usually referred to as the TOP of the stack Stacks & Their Applications page 7
8 Stacks An Overview PUSH Operation: Element to be inserted into S 6 Top Top Stack S Stack S (before push) (after push) Stacks & Their Applications page 8
9 Stacks An Overview POP Operation: Element removed 6 Top Top (stack before pop) (stack after pop) Stacks & Their Applications page 9
10 Stacks An Overview Stacks: Other useful operations: isempty: Typically implemented as a boolean function Returns TRUE if no items are in the stacck isfull: top: Returns TRUE if no more items can be added to the stack In theory, a stack should NEVER become full Actual implementations do have limits on the number of elements a stack can store Simply returns the value at the top of the stack without actually popping the stack. Stacks & Their Applications page 10
11 Stacks An Overview Stacks: Other useful operations: Note: Each of those operations ACCESS the stack But they do NOT modify the stack A PUSH can only be done if the stack isn t full A POP can only be done on a non-empty stack Implementation of a stack: Can be done using both static and dynamic memory Array or a linked list Implemented as an array, the stack could possibly become full As a linked list, this is MUCH LESS LIKELY to occur We will cover detailed implementations NEXT TIME. Stacks & Their Applications page 11
12 Using Stacks So when is stack useful? When data needs to be stored and then retrieved in reverse order There are several examples/applications outside the scope of this class Be patient and they will come up For now, we go over two classical examples This examples help facilitate learning about stacks and their operations. Stacks & Their Applications page 12
13 Stack Application(s) Evaluating Arithmetic Expressions Consider the expression 5 * * 4 How do we evaluate this? DUH No, but seriously, think about what happens during the evaluation We multiply 5 and 3 to get 15, and then we add 2 to that result to get 17. Then we store that off in our head somewhere. We then multiply 6 and 4 to get 24 Lastly, we then retrieve the stored value (17) and add it to 24 to get the result 41. Stacks & Their Applications page 13
14 Stack Application(s) Evaluating Arithmetic Expressions Consider the expression 5 * * 4 That was only easy cuz we knowza some math and rules of precedence, etc. What if you didn t know those rules? Well, there s an easy way of writing out this sequence of events. It does seem weird at first glance but it works! 5 3 * * + you read this left to right the operators are ALWAYS in the correct evaluation order This notation is called postfix notation. Stacks & Their Applications page 14
15 Stack Application(s) Basically, there are 3 types of notations for expressions Infix: operator is between operands A + B Postfix: operator follows operands A B + Prefix: operator comes before operands + A B Again, in a postfix expression, operators are ALWAYS in correct evaluation order. Stacks & Their Applications page 15
16 Stack Application(s) Evaluation of infix expressions has 2 basic steps: Convert infix expression to a postfix expression. Evaluate the newly converted postfix expression. And guess what Stacks are useful in both of these steps Let s start with seeing how to actually evaluate that crazy looking expression Stacks & Their Applications page 16
17 Stack Application(s) Evaluating a Postfix Expression (A B +) Of course, we use a stack Each operator in a postfix expression refers to the previous two operands When you read an operand PUSH it onto the stack When you read an operator, it s associated operands are POPed off the stack The indicated operation (based on the operand) is performed on the two operators Result is PUSHed back onto the stack so it can be available for use as an operand for the next operator. Process stops when there are no more operators in expression Final result is obtained by popping off remaining value in stack. Stacks & Their Applications page 17
18 Stack Application(s) Evaluating a Postfix Expression Consider the simple expression: 5 * * 4 As mentioned, this converts to the following postfix expression: 5 3 * * + So follow the rules and evaluate this! Stacks & Their Applications page 18
19 5 3 * * + Step 1: We have an operand, 5. What do we do? The rule stated: When you encounter an operand, PUSH it onto the stack. So we PUSH 5 onto the stack. 5 Stacks & Their Applications page 19
20 5 3 * * + Step 2: PUSH 3 on the stack 3 5 Stacks & Their Applications page 20
21 5 3 * * + Step 3: We have an operator! What do we do? 1. POP the top two operands off the stack. 2. Perform the indicated operation. 3. PUSH the result back onto the stack So POP 3 and *3 = PUSH 15 back on the stack Stacks & Their Applications page 21
22 5 3 * * + Step 3: We have an operator! What do we do? 1. POP the top two operands off the stack. 2. Perform the indicated operation. 3. PUSH the result back onto the stack So POP 3 and *3 = PUSH 15 back on the stack Stacks & Their Applications page 22
23 5 3 * * + Step 4: PUSH 2 on the stack 2 15 Stacks & Their Applications page 23
24 5 3 * * + Step 5: We have an operator! What do we do? 1. POP the top two operands off the stack. 2. Perform the indicated operation. 3. PUSH the result back onto the stack So POP 2 and = PUSH 17 back on the stack Stacks & Their Applications page 24
25 5 3 * * + Step 5: We have an operator! What do we do? 1. POP the top two operands off the stack. 2. Perform the indicated operation. 3. PUSH the result back onto the stack So POP 2 and = PUSH 17 back on the stack Stacks & Their Applications page 25
26 5 3 * * + Step 6: PUSH 6 on the stack 6 17 Stacks & Their Applications page 26
27 5 3 * * + Step 7: PUSH 4 on the stack Stacks & Their Applications page 27
28 5 3 * * + Step 8: We have an operator! What do we do? 1. POP the top two operands off the stack. 2. Perform the indicated operation. 3. PUSH the result back onto the stack So POP 4 and * 4 = PUSH 24 back on the stack Stacks & Their Applications page 28
29 5 3 * * + Step 8: We have an operator! What do we do? 1. POP the top two operands off the stack. 2. Perform the indicated operation. 3. PUSH the result back onto the stack So POP 4 and * 4 = PUSH 24 back on the stack Stacks & Their Applications page 29
30 5 3 * * + Step 9: We have an operator! What do we do? 1. POP the top two operands off the stack. 2. Perform the indicated operation. 3. PUSH the result back onto the stack So POP 24 and = PUSH 41 back on the stack Stacks & Their Applications page 30
31 5 3 * * + Step 9: We have an operator! What do we do? 1. POP the top two operands off the stack. 2. Perform the indicated operation. 3. PUSH the result back onto the stack So POP 24 and = PUSH 41 back on the stack Stacks & Their Applications page 31
32 5 3 * * + Step 10: There are no more operators. So pop the final value off the stack. Result is We re Done! Stacks & Their Applications page 32
33 Brief Interlude: Human Stupidity Stacks & Their Applications page 33
34 Stack Application(s) Again, there are 2 steps to evaluate infix expressions. 1. Evaluate the postfix expression (once converted) Been there, done that (for those that were sleeping, that was the long previous example) 2. But before we can evaluate, we must first convert the infix exp. to a postfix exp. Infix: 5 * * 4 Postfix: 5 3 * * + How do we do this Stacks & Their Applications page 34
35 Stack Application(s) Converting Infix Exp. to Postfix Exp. Again, we use a stack But now, this is strictly an operator only stack Only the operators are stored on the stack Upon reading an operand, the operand is immediately placed into output list (printed out straight away). There are several rules on how this stack should be used But with an example, it should be easy to understand Stacks & Their Applications page 35
36 Stack Application(s) Converting Infix Exp. to Postfix Exp. Rules 1. Assume the operation is a legal one (meaning, it is possible to evaluate it). 2. Upon reading an operand, it is immediately placed into the output list (printed straight away). 3. Only the operators are placed in the stack. 4. To start, the stack is empty. The infix expression is read left to right. 5. The first operator read is pushed directly onto the stack. For all subsequent operators, the priority of the incoming-operator (the one being read) will be compared with the operator on the top of the stack. 6. If the priority of the incoming-operator is higher than the priority of the operator on the top of the stack, then the incoming-operator will be simply PUSHed on the stack. 7. If the priority of the incoming-operator is same or lower than the priority of the operator at the top of the stack, then the operator at top of the stack will be POPed and printed on the output expression. 8. The process is repeated if the priority of the incoming-operator is still same or lower than the next operator-in-the stack. 9. When a left parenthesis is encountered in the expression it is immediately pushed on the stack, as it has the highest priority. However, once it is inside the stack, all other operators are pushed on top of it, as its inside-stack priority is lowest. 10. When a right parenthesis is encountered, all operators up to the left parenthesis are popped from the stack and printed out. The left and right parentheses will be discarded. When all characters from the input infix expression have been read, the operators remaining inside the stack, are printed out in the order in which they are popped. Stacks & Their Applications page 36
37 Stack Application(s) Converting Infix Exp. to Postfix Exp. Rules One more thing, before we begin, we must know the order of precedence for the operators The priority is as follows, with the first being the top priority (highest precedence) 1. ( Left parenthesis inside the expression 2. * / ( Left parenthesis inside the stack The left parenthesis has the highest priority when it is read from the expression, but once it is on the stack, it assumes the lowest priority. Stacks & Their Applications page 37
38 5 * * 4 Step 1: 5 is an operand. It is placed directly onto output list. Resulting Postfix Expression: 5 Stacks & Their Applications page 38
39 5 * * 4 Step 2: * is an operator. The stack is empty; so PUSH * into the stack. Resulting Postfix Expression: 5 * Stacks & Their Applications page 39
40 5 * * 4 Step 3: 3 is an operand. It is placed directly onto output list. Resulting Postfix Expression: 5 3 * Stacks & Their Applications page 40
41 5 * * 4 Step 4: + is an operator. The stack is not empty; compare precedence of + to *. Resulting Postfix Expression: 5 3 * Stacks & Their Applications page 41
42 Stack Application(s) Converting Infix Exp. to Postfix Exp. Rules One more thing, before we begin, we must know the order of precedence for the operators The priority is as follows, with the first being the top priority (highest precedence) 1. ( Left parenthesis inside the expression 2. * / ( Left parenthesis inside the stack The left parenthesis has the highest priority when it is read from the expression, but once it is on the stack, it assumes the lowest priority. Stacks & Their Applications page 42
43 Stack Application(s) Converting Infix Exp. to Postfix Exp. Rules 1. Assume the operation is a legal one (meaning, it is possible to evaluate it). 2. Upon reading an operand, it is immediately placed into the output list (printed straight away). 3. Only the operators are placed in the stack. 4. To start, the stack is empty. The infix expression is read left to right. 5. The first operator read is pushed directly onto the stack. For all subsequent operators, the priority of the incoming-operator (the one being read) will be compared with the operator on the top of the stack. 6. If the priority of the incoming-operator is higher than the priority of the operator on the top of the stack, then the incoming-operator will be simply PUSHed on the stack. 7. If the priority of the incoming-operator is same or lower than the priority of the operator at the top of the stack, then the operator at top of the stack will be POPed and printed on the output expression. 8. The process is repeated if the priority of the incoming-operator is still same or lower than the next operator-in-the stack. 9. When a left parenthesis is encountered in the expression it is immediately pushed on the stack, as it has the highest priority. However, once it is inside the stack, all other operators are pushed on top of it, as its inside-stack priority is lowest. 10. When a right parenthesis is encountered, all operators up to the left parenthesis are popped from the stack and printed out. The left and right parentheses will be discarded. When all characters from the input infix expression have been read, the operators remaining inside the stack, are printed out in the order in which they are popped. Stacks & Their Applications page 43
44 5 * * 4 Step 4: + is an operator. The stack is not empty; compare precedence of + to *. + is lower priority than *. So we POP * and PUSH + onto the stack. + * Resulting Postfix Expression: 5 3 * Stacks & Their Applications page 44
45 5 * * 4 Step 5: 2 is an operand. It is placed directly onto output list. Resulting Postfix Expression: 5 3 * 2 + Stacks & Their Applications page 45
46 5 * * 4 Step 6: + is an operator. The stack is not empty; compare precedence of + to +. Resulting Postfix Expression: 5 3 * 2 + Stacks & Their Applications page 46
47 5 * * 4 Step 6: + is an operator. The stack is not empty; compare precedence of + to +. + is same priority as +. So we POP + and PUSH + onto the stack. + Resulting Postfix Expression: 5 3 * 2 + Stacks & Their Applications page 47
48 5 * * 4 Step 7: 6 is an operand. It is placed directly onto output list. Resulting Postfix Expression: 5 3 * Stacks & Their Applications page 48
49 5 * * 4 Step 8: * is an operator. The stack is not empty; compare precedence of * to +. Resulting Postfix Expression: 5 3 * Stacks & Their Applications page 49
50 Stack Application(s) Converting Infix Exp. to Postfix Exp. Rules One more thing, before we begin, we must know the order of precedence for the operators The priority is as follows, with the first being the top priority (highest precedence) 1. ( Left parenthesis inside the expression 2. * / ( Left parenthesis inside the stack The left parenthesis has the highest priority when it is read from the expression, but once it is on the stack, it assumes the lowest priority. Stacks & Their Applications page 50
51 Stack Application(s) Converting Infix Exp. to Postfix Exp. Rules 1. Assume the operation is a legal one (meaning, it is possible to evaluate it). 2. Upon reading an operand, it is immediately placed into the output list (printed straight away). 3. Only the operators are placed in the stack. 4. To start, the stack is empty. The infix expression is read left to right. 5. The first operator read is pushed directly onto the stack. For all subsequent operators, the priority of the incoming-operator (the one being read) will be compared with the operator on the top of the stack. 6. If the priority of the incoming-operator is higher than the priority of the operator on the top of the stack, then the incoming-operator will be simply PUSHed on the stack. 7. If the priority of the incoming-operator is same or lower than the priority of the operator at the top of the stack, then the operator at top of the stack will be POPed and printed on the output expression. 8. The process is repeated if the priority of the incoming-operator is still same or lower than the next operator-in-the stack. 9. When a left parenthesis is encountered in the expression it is immediately pushed on the stack, as it has the highest priority. However, once it is inside the stack, all other operators are pushed on top of it, as its inside-stack priority is lowest. 10. When a right parenthesis is encountered, all operators up to the left parenthesis are popped from the stack and printed out. The left and right parentheses will be discarded. When all characters from the input infix expression have been read, the operators remaining inside the stack, are printed out in the order in which they are popped. Stacks & Their Applications page 51
52 5 * * 4 Step 8: * is an operator. The stack is not empty; compare precedence of * to +. * is a higher priority than +. So we simply PUSH * onto the stack. * + Resulting Postfix Expression: 5 3 * Stacks & Their Applications page 52
53 5 * * 4 Step 9: 4 is an operand. It is placed directly onto output list. Resulting Postfix Expression: 5 3 * * + Stacks & Their Applications page 53
54 5 * * 4 Step 10: Infix exp. has been completely read. POP remaining operators that are in the stack. * + And now we re done. We have an equivalent postfix expression. Resulting Postfix Expression: 3 * * 5 + Stacks & Their Applications page 54
55 Stack Application(s) Two more examples: The contents of the operator stack at the indicated points in the infix expressions (points A, B and C) are shown below for each case Stacks & Their Applications page 55
56 Stack Application(s) Last example: The contents of the operator stack at the indicated points in the infix expressions (points A, B and C) are shown below for each case Stacks & Their Applications page 56
57 Stack Application(s) You now know how to: 1. Convert an Infix expression to a Postfix expression 2. And then evaluate that resulting expression Stacks & Their Applications page 57
58 Stack Application(s) WASN T THAT DANDY! Stacks & Their Applications page 58
59 Daily Demotivator Stacks & Their Applications page 59
60 Stacks & Their Applications (Postfix/Infix) College of Computing & Information Technology King Abdulaziz University CPCS-204 Data Structures I
Data Structures and Algorithms V22.0102. Otávio Braga
Data Structures and Algorithms V22.0102 Otávio Braga We use a stack When an operand is read, output it When an operator is read Pop until the top of the stack has an element of lower precedence Then push
7.1 Our Current Model
Chapter 7 The Stack In this chapter we examine what is arguably the most important abstract data type in computer science, the stack. We will see that the stack ADT and its implementation are very simple.
Introduction to Stacks
Introduction to Stacks What is a Stack Stack implementation using array. Stack implementation using linked list. Applications of Stack. What is a Stack? Stack is a data structure in which data is added
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
Module 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 non-primitive linear data structure in computer science. It is an ordered collection of items into which
DATA 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
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
Chapter 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
Last 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
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
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
Stacks. 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
PES Institute of Technology-BSC QUESTION BANK
PES Institute of Technology-BSC 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
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
Course: 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
Base Conversion written by Cathy Saxton
Base Conversion written by Cathy Saxton 1. Base 10 In base 10, the digits, from right to left, specify the 1 s, 10 s, 100 s, 1000 s, etc. These are powers of 10 (10 x ): 10 0 = 1, 10 1 = 10, 10 2 = 100,
Stacks. Data Structures and Data Types. Collections
Data Structures and Data Types 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, Queue, Graph,... Data
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
Introduction 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
Data 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 6-0: Stacks and
CSE373: Data Structures and Algorithms Lecture 1: Introduction; ADTs; Stacks/Queues. Linda Shapiro Spring 2016
CSE373: Data Structures and Algorithms Lecture 1: Introduction; ADTs; Stacks/Queues Linda Shapiro Registration We have 180 students registered and others who want to get in. If you re thinking of dropping
Basic Use of the TI-84 Plus
Basic Use of the TI-84 Plus Topics: Key Board Sections Key Functions Screen Contrast Numerical Calculations Order of Operations Built-In Templates MATH menu Scientific Notation The key VS the (-) Key Navigation
Multiplying Fractions
. Multiplying Fractions. OBJECTIVES 1. Multiply two fractions. Multiply two mixed numbers. Simplify before multiplying fractions 4. Estimate products by rounding Multiplication is the easiest of the four
MAX = 5 Current = 0 'This will declare an array with 5 elements. Inserting a Value onto the Stack (Push) -----------------------------------------
=============================================================================================================================== DATA STRUCTURE PSEUDO-CODE EXAMPLES (c) Mubashir N. Mir - www.mubashirnabi.com
1. 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
Outline. Computer Science 331. Stack ADT. Definition of a Stack ADT. Stacks. Parenthesis Matching. Mike Jacobson
Outline Computer Science 1 Stacks Mike Jacobson Department of Computer Science University of Calgary Lecture #12 1 2 Applications Array-Based Linked List-Based 4 Additional Information Mike Jacobson (University
CHAPTER 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
Chapter 5 Instructor's Manual
The Essentials of Computer Organization and Architecture Linda Null and Julia Lobur Jones and Bartlett Publishers, 2003 Chapter 5 Instructor's Manual Chapter Objectives Chapter 5, A Closer Look at Instruction
Chapter 2: Elements of Java
Chapter 2: Elements of Java Basic components of a Java program Primitive data types Arithmetic expressions Type casting. The String type (introduction) Basic I/O statements Importing packages. 1 Introduction
Administrative Issues
CSC 3210 Computer Organization and Programming Introduction and Overview Dr. Anu Bourgeois (modified by Yuan Long) Administrative Issues Required Prerequisites CSc 2010 Intro to CSc CSc 2310 Java Programming
Universidad 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
1 Description of The Simpletron
Simulating The Simpletron Computer 50 points 1 Description of The Simpletron In this assignment you will write a program to simulate a fictional computer that we will call the Simpletron. As its name implies
Data Structure and Algorithm I Midterm Examination 120 points Time: 9:10am-12:10pm (180 minutes), Friday, November 12, 2010
Data Structure and Algorithm I Midterm Examination 120 points Time: 9:10am-12:10pm (180 minutes), Friday, November 12, 2010 Problem 1. In each of the following question, please specify if the statement
St S a t ck a ck nd Qu Q eue 1
Stack and Queue 1 Stack Data structure with Last-In First-Out (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
Krishna Institute of Engineering & Technology, Ghaziabad Department of Computer Application MCA-213 : 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
CS104: Data Structures and Object-Oriented Design (Fall 2013) October 24, 2013: Priority Queues Scribes: CS 104 Teaching Team
CS104: Data Structures and Object-Oriented Design (Fall 2013) October 24, 2013: Priority Queues Scribes: CS 104 Teaching Team Lecture Summary In this lecture, we learned about the ADT Priority Queue. A
PROGRAMMING CONCEPTS AND EMBEDDED PROGRAMMING IN C, C++ and JAVA: Lesson-4: Data Structures: Stacks
PROGRAMMING CONCEPTS AND EMBEDDED PROGRAMMING IN C, C++ and JAVA: Lesson-4: Data Structures: Stacks 1 STACK A structure with a series of data elements with last sent element waiting for a delete operation.
Chapter 7D The Java Virtual Machine
This sub chapter discusses another architecture, that of the JVM (Java Virtual Machine). In general, a VM (Virtual Machine) is a hypothetical machine (implemented in either hardware or software) that directly
Analysis 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,
Graphing Calculator Workshops
Graphing Calculator Workshops For the TI-83/84 Classic Operating System & For the TI-84 New Operating System (MathPrint) LEARNING CENTER Overview Workshop I Learn the general layout of the calculator Graphing
Data Structures and Algorithms Lists
Data Structures and Algorithms Lists Chris Brooks Department of Computer Science University of San Francisco Department of Computer Science University of San Francisco p.1/19 5-0: Abstract Data Types An
Advanced Computer Architecture-CS501. Computer Systems Design and Architecture 2.1, 2.2, 3.2
Lecture Handout Computer Architecture Lecture No. 2 Reading Material Vincent P. Heuring&Harry F. Jordan Chapter 2,Chapter3 Computer Systems Design and Architecture 2.1, 2.2, 3.2 Summary 1) A taxonomy of
Computer Science 281 Binary and Hexadecimal Review
Computer Science 281 Binary and Hexadecimal Review 1 The Binary Number System Computers store everything, both instructions and data, by using many, many transistors, each of which can be in one of two
Stacks 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
X86-64 Architecture Guide
X86-64 Architecture Guide For the code-generation project, we shall expose you to a simplified version of the x86-64 platform. Example Consider the following Decaf program: class Program { int foo(int
Welcome to Basic Math Skills!
Basic Math Skills Welcome to Basic Math Skills! Most students find the math sections to be the most difficult. Basic Math Skills was designed to give you a refresher on the basics of math. There are lots
PSTricks. pst-ode. A PSTricks package for solving initial value problems for sets of Ordinary Differential Equations (ODE), v0.7.
PSTricks pst-ode A PSTricks package for solving initial value problems for sets of Ordinary Differential Equations (ODE), v0.7 27th March 2014 Package author(s): Alexander Grahn Contents 2 Contents 1 Introduction
Boolean Expressions, Conditions, Loops, and Enumerations. Precedence Rules (from highest to lowest priority)
Boolean Expressions, Conditions, Loops, and Enumerations Relational Operators == // true if two values are equivalent!= // true if two values are not equivalent < // true if left value is less than the
PROBLEMS (Cap. 4 - Istruzioni macchina)
98 CHAPTER 2 MACHINE INSTRUCTIONS AND PROGRAMS PROBLEMS (Cap. 4 - Istruzioni macchina) 2.1 Represent the decimal values 5, 2, 14, 10, 26, 19, 51, and 43, as signed, 7-bit numbers in the following binary
Common 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
Stack Allocation. Run-Time Data Structures. Static Structures
Run-Time Data Structures Stack Allocation Static Structures For static structures, a fixed address is used throughout execution. This is the oldest and simplest memory organization. In current compilers,
Class 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
Moving from CS 61A Scheme to CS 61B Java
Moving from CS 61A Scheme to CS 61B Java Introduction Java is an object-oriented language. This document describes some of the differences between object-oriented programming in Scheme (which we hope you
2) Write in detail the issues in the design of code generator.
COMPUTER SCIENCE AND ENGINEERING VI SEM CSE Principles of Compiler Design Unit-IV Question and answers UNIT IV CODE GENERATION 9 Issues in the design of code generator The target machine Runtime Storage
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
This 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
A single register, called the accumulator, stores the. operand before the operation, and stores the result. Add y # add y from memory to the acc
Other architectures Example. Accumulator-based machines A single register, called the accumulator, stores the operand before the operation, and stores the result after the operation. Load x # into acc
What is a Stack? Stacks and Queues. Stack Abstract Data Type. Java Interface for Stack ADT. Array-based Implementation
Stacks and Queues What is a Stack? Stores a set of elements in a particular order Accessed in Last-In In-First-Out (LIFO) fashion Real life examples: Pile of books PEZ dispenser Cup trays in cafeteria
STACKS,QUEUES, AND LINKED LISTS
STACKS,QUEUES, AND LINKED LISTS Stacks Queues Linked Lists Double-Ended Queues Case Study: A Stock Analysis Applet 1 Stacks Astack is a container of objects that are inserted and removed according to the
14 Stacks, Queues, And Linked Lists
14-1 Java Au Naturel by William C. Jones 14-1 14 Stacks, Queues, And Linked Lists Overview This chapter requires that you have a solid understanding of arrays (Chapter Seven) and have studied Exceptions
Course: 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
1 Introduction. 2 An Interpreter. 2.1 Handling Source Code
1 Introduction The purpose of this assignment is to write an interpreter for a small subset of the Lisp programming language. The interpreter should be able to perform simple arithmetic and comparisons
Atmiya 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
Data Structures UNIT III. Model Question Answer
Data Structures UNIT III Model Question Answer Q.1. Define Stack? What are the different primitive operations on Stack? Ans: Stack: A stack is a linear structure in which items may be added or removed
Outline. The Stack ADT Applications of Stacks Array-based implementation Growable array-based stack. Stacks 2
Stacks Outline The Stack ADT Applications of Stacks Array-based implementation Growable array-based stack Stacks 2 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure
Programming with Data Structures
Programming with Data Structures CMPSCI 187 Spring 2016 Please find a seat Try to sit close to the center (the room will be pretty full!) Turn off or silence your mobile phone Turn off your other internet-enabled
COMP 356 Programming Language Structures Notes for Chapter 4 of Concepts of Programming Languages Scanning and Parsing
COMP 356 Programming Language Structures Notes for Chapter 4 of Concepts of Programming Languages Scanning and Parsing The scanner (or lexical analyzer) of a compiler processes the source program, recognizing
LINEAR INEQUALITIES. less than, < 2x + 5 x 3 less than or equal to, greater than, > 3x 2 x 6 greater than or equal to,
LINEAR INEQUALITIES When we use the equal sign in an equation we are stating that both sides of the equation are equal to each other. In an inequality, we are stating that both sides of the equation are
Chapter One Introduction to Programming
Chapter One Introduction to Programming 1-1 Algorithm and Flowchart Algorithm is a step-by-step procedure for calculation. More precisely, algorithm is an effective method expressed as a finite list of
Linked 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
Instruction Set Architecture (ISA)
Instruction Set Architecture (ISA) * Instruction set architecture of a machine fills the semantic gap between the user and the machine. * ISA serves as the starting point for the design of a new machine
To convert an arbitrary power of 2 into its English equivalent, remember the rules of exponential arithmetic:
Binary Numbers In computer science we deal almost exclusively with binary numbers. it will be very helpful to memorize some binary constants and their decimal and English equivalents. By English equivalents
7. Solving Linear Inequalities and Compound Inequalities
7. Solving Linear Inequalities and Compound Inequalities Steps for solving linear inequalities are very similar to the steps for solving linear equations. The big differences are multiplying and dividing
1.4 Compound Inequalities
Section 1.4 Compound Inequalities 53 1.4 Compound Inequalities This section discusses a technique that is used to solve compound inequalities, which is a phrase that usually refers to a pair of inequalities
5. A full binary tree with n leaves contains [A] n nodes. [B] log n 2 nodes. [C] 2n 1 nodes. [D] n 2 nodes.
![5. A full binary tree with n leaves contains [A] n nodes. [B] log n 2 nodes. [C] 2n 1 nodes. [D] n 2 nodes.](/thumbs/40/21353779.jpg "5. 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
UIL Computer Science for Dummies by Jake Warren and works from Mr. Fleming
UIL Computer Science for Dummies by Jake Warren and works from Mr. Fleming 1 2 Foreword First of all, this book isn t really for dummies. I wrote it for myself and other kids who are on the team. Everything
1.00 Lecture 35. Data Structures: Introduction Stacks, Queues. Reading for next time: Big Java: 15.1-15.3. Data Structures
1.00 Lecture 35 Data Structures: Introduction Stacks, Queues Reading for next time: Big Java: 15.1-15.3 Data Structures Set of reusable classes used in algorithms, simulations, operating systems, applications
Name: Class: Date: 9. The compiler ignores all comments they are there strictly for the convenience of anyone reading the program.
Name: Class: Date: Exam #1 - Prep True/False Indicate whether the statement is true or false. 1. Programming is the process of writing a computer program in a language that the computer can respond to
Compilers I - Chapter 4: Generating Better Code
Compilers I - Chapter 4: Generating Better Code Lecturers: Paul Kelly (phjk@doc.ic.ac.uk) Office: room 304, William Penney Building Naranker Dulay (nd@doc.ic.ac.uk) Materials: Office: room 562 Textbook
CompuScholar, Inc. Alignment to Utah's Computer Programming II Standards
CompuScholar, Inc. Alignment to Utah's Computer Programming II Standards Course Title: TeenCoder: Java Programming Course ISBN: 978 0 9887070 2 3 Course Year: 2015 Note: Citation(s) listed may represent
DATA STRUCTURE - QUEUE
DATA STRUCTURE - QUEUE http://www.tutorialspoint.com/data_structures_algorithms/dsa_queue.htm Copyright tutorialspoint.com Queue is an abstract data structure, somewhat similar to stack. In contrast to
Recursion. Definition: o A procedure or function that calls itself, directly or indirectly, is said to be recursive.
Recursion Definition: o A procedure or function that calls itself, directly or indirectly, is said to be recursive. Why recursion? o For many problems, the recursion solution is more natural than the alternative
1 Classical Universal Computer 3
Chapter 6: Machine Language and Assembler Christian Jacob 1 Classical Universal Computer 3 1.1 Von Neumann Architecture 3 1.2 CPU and RAM 5 1.3 Arithmetic Logical Unit (ALU) 6 1.4 Arithmetic Logical Unit
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
JavaScript: Introduction to Scripting. 2008 Pearson Education, Inc. All rights reserved.
1 6 JavaScript: Introduction to Scripting 2 Comment is free, but facts are sacred. C. P. Scott The creditor hath a better memory than the debtor. James Howell When faced with a decision, I always ask,
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)
The HP 35s. Gene Wright
The HP 35s Gene Wright At last, the BIG ENTER key is back. It s as if HP did a LASTx and brought back the BIG ENTER key. Yes, this was a conscious choice by HP management and can be taken as a signal to
Lecture 2 Notes: Flow of Control
6.096 Introduction to C++ January, 2011 Massachusetts Institute of Technology John Marrero Lecture 2 Notes: Flow of Control 1 Motivation Normally, a program executes statements from first to last. The
Object Oriented Software Design
Object Oriented Software Design Introduction to Java - II Giuseppe Lipari http://retis.sssup.it/~lipari Scuola Superiore Sant Anna Pisa October 28, 2010 G. Lipari (Scuola Superiore Sant Anna) Introduction
Data Structure [Question Bank]
![Data Structure [Question Bank]](/thumbs/40/21355705.jpg "Data 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:
Sequential 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
Chapter 14: Boolean Expressions Bradley Kjell (Revised 10/08/08)
Chapter 14: Boolean Expressions Bradley Kjell (Revised 10/08/08) The if statements of the previous chapters ask simple questions such as count
Tom wants to find two real numbers, a and b, that have a sum of 10 and have a product of 10. He makes this table.
Sum and Product This problem gives you the chance to: use arithmetic and algebra to represent and analyze a mathematical situation solve a quadratic equation by trial and improvement Tom wants to find
3.3 Addition and Subtraction of Rational Numbers
3.3 Addition and Subtraction of Rational Numbers In this section we consider addition and subtraction of both fractions and decimals. We start with addition and subtraction of fractions with the same denominator.
Chapter 8: Bags and Sets
Chapter 8: Bags and Sets In the stack and the queue abstractions, the order that elements are placed into the container is important, because the order elements are removed is related to the order in which
Translating to Java. Translation. Input. Many Level Translations. read, get, input, ask, request. Requirements Design Algorithm Java Machine Language
Translation Translating to Java Introduction to Computer Programming The job of a programmer is to translate a problem description into a computer language. You need to be able to convert a problem description
Home 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) n-element vector start address + ielementsize 0 +1 +2 +3 +4... +n-1 start address continuous memory block static, if size is known at compile time dynamic,
Object Oriented Software Design
Object Oriented Software Design Introduction to Java - II Giuseppe Lipari http://retis.sssup.it/~lipari Scuola Superiore Sant Anna Pisa September 14, 2011 G. Lipari (Scuola Superiore Sant Anna) Introduction
COMP 250 Fall 2012 lecture 2 binary representations Sept. 11, 2012
Binary numbers The reason humans represent numbers using decimal (the ten digits from 0,1,... 9) is that we have ten fingers. There is no other reason than that. There is nothing special otherwise about
Accentuate the Negative: Homework Examples from ACE
Accentuate the Negative: Homework Examples from ACE Investigation 1: Extending the Number System, ACE #6, 7, 12-15, 47, 49-52 Investigation 2: Adding and Subtracting Rational Numbers, ACE 18-22, 38(a),