Concise Notes on Data Structures and Algorithms

Total Page:16

File Type:pdf, Size:1020Kb

Concise Notes on Data Structures and Algorithms Concise Notes on Data Structures and Algorithms Ruby Edition Christopher Fox James Madison University 2011 Contents 1 IntroductIon 1 What Are Data Structures and Algorithms? . 1 Structure of the Book . 3 The Ruby Programming Language . 3 Review Questions . 3 Exercises . 4 Review Question Answers . 4 2 BuIlt-In types 5 Simple and Structured Types . 5 Types in Ruby . 5 Symbol: A Simple Type in Ruby . 5 Review Questions . 9 Exercises . 9 Review Question Answers . 9 3 ArrAys 10 Introduction . 10 Varieties of Arrays . 10 Arrays in Ruby . 11 Review Questions . 12 Exercises . 12 Review Question Answers . 13 4 AssertIons 14 Introduction . 14 Types of Assertions . 14 Assertions and Abstract Data Types . 15 Using Assertions . 15 Assertions in Ruby . 16 Review Questions . 17 Exercises . 17 Review Question Answers . 19 5 containers 20 Introduction . 20 Varieties of Containers . 20 1 Contents A Container Taxonomy . 20 Interfaces in Ruby . 21 Exercises . 22 Review Question Answers . 23 6 stAcks 24 Introduction . 24 The Stack ADT . 24 The Stack Interface . 25 Using Stacks—An Example . 25 Contiguous Implementation of the Stack ADT . 26 Linked Implementation of the Stack ADT . 27 Summary and Conclusion . 28 Review Questions . 28 Exercises . 29 Review Question Answers . 29 7 Queues 31 Introduction . 31 The Queue ADT . 31 The Queue Interface . 31 Using Queues—An Example . 32 Contiguous Implementation of the Queue ADT . 32 Linked Implementation of the Queue ADT . 34 Summary and Conclusion . 35 Review Questions . 35 Exercises . 35 Review Question Answers . 36 8 stAcks And recursIon 37 Introduction . 37 Balanced Brackets . 38 Infix, Prefix, and Postfix Expressions . 39 Tail Recursive Algorithms . 44 Summary and Conclusion . 44 Review Questions . 45 Exercises . 45 Review Question Answers . 45 2 Contents 9 collectIons 47 Introduction . 47 Iteration Design Alternatives . 47 The Iterator Design Pattern . 48 Iteration in Ruby . 49 Collections, Iterators, and Containers . 50 Summary and Conclusion . 51 Review Questions . 52 Exercises . 52 Review Question Answers . 52 10 lIsts 54 Introduction . 54 The List ADT . 54 The List Interface . 55 Using Lists—An Example . 55 Contiguous Implementation of the List ADT . 56 Linked Implementation of the List ADT . 56 Implementing Lists in Ruby . 58 Summary and Conclusion . 58 Review Questions . 58 Exercises . 58 Review Question Answers . 59 11 AnAlyzIng AlgorIthms 61 Introduction . 61 Measuring the Amount of Work Done . 61 Which Operations to Count . 62 Best, Worst, and Average Case Complexity . 63 Review Questions . 65 Exercises . 66 Review Question Answers . 66 12 FunctIon growth rAtes 68 Introduction . 68 Definitions and Notation . 68 Establishing the Order of Growth of a Function . 69 Applying Orders of Growth . 70 Summary and Conclusion . 70 iii Contents Review Questions . 70 Exercises . 70 Review Question Answers . 71 13 BAsIc sortIng AlgorIthms 72 Introduction . 72 Bubble Sort . 72 Selection Sort . 73 Insertion Sort . 74 Shell Sort . 76 Summary and Conclusion . 77 Review Questions . 78 Exercises . 78 Review Question Answers . 78 14 recurrences 80 Introduction . 80 Setting Up Recurrences . 80 Review Questions . 83 Exercises . 83 Review Question Answers . 84 15: merge sort And QuIcksort 85 Introduction . 85 Merge Sort . 85 Quicksort . 87 Summary and Conclusion . 91 Review Questions . 91 Exercises . 91 Review Question Answers . 92 16 trees, heAps, And heApsort 93 Introduction . 93 Basic Terminology . 93 Binary Trees . ..
Recommended publications
  • Device Tree 101
    Device Tree 101 Device Tree 101 Organized in partnership with ST February 9, 2021 Thomas Petazzoni embedded Linux and kernel engineering [email protected] © Copyright 2004-2021, Bootlin. Creative Commons BY-SA 3.0 license. Corrections, suggestions, contributions and translations are welcome! - Kernel, drivers and embedded Linux - Development, consulting, training and support - https://bootlin.com 1/56 Who is speaking ? I Thomas Petazzoni I Chief Technical Officer at Bootlin I Joined in 2008, employee #1 I Embedded Linux & Linux kernel engineer, open-source contributor I Author of the Device Tree for Dummies talk in 2013/2014 I Buildroot co-maintainer I Linux kernel contributor: ≈ 900 contributions I Member of Embedded Linux Conference (Europe) program committee I Based in Toulouse, France - Kernel, drivers and embedded Linux - Development, consulting, training and support - https://bootlin.com 2/56 Agenda I Bootlin introduction I STM32MP1 introduction I Why the Device Tree ? I Basic Device Tree syntax I Device Tree inheritance I Device Tree specifications and bindings I Device Tree and Linux kernel drivers I Common properties and examples - Kernel, drivers and embedded Linux - Development, consulting, training and support - https://bootlin.com 3/56 Bootlin I In business since 2004 I Team based in France I Serving customers worldwide I 18% revenue from France I 44% revenue from EU except France I 38% revenue outside EU I Highly focused and recognized expertise I Embedded Linux I Linux kernel I Embedded Linux build systems I Activities
    [Show full text]
  • Slide Set 17 for ENCM 339 Fall 2015
    Slide Set 17 for ENCM 339 Fall 2015 Steve Norman, PhD, PEng Electrical & Computer Engineering Schulich School of Engineering University of Calgary Fall Term, 2015 SN's ENCM 339 Fall 2015 Slide Set 17 slide 2/46 Contents Data structures Abstract data types Linked data structures A singly-linked list type in C++ Operations and implementation of SLListV1 The Big 3 for a linked-list class Ordered linked lists SN's ENCM 339 Fall 2015 Slide Set 17 slide 3/46 Outline of Slide Set 17 Data structures Abstract data types Linked data structures A singly-linked list type in C++ Operations and implementation of SLListV1 The Big 3 for a linked-list class Ordered linked lists SN's ENCM 339 Fall 2015 Slide Set 17 slide 4/46 Data structures In discussion of programming, the term data structure means a collection of data items, organized to support some of the following goals: I fast insertion or removal of data items I fast access to data items I fast searching for the location of a particular data item, if the item is in the collection I maintaining items in some kind of sorted order I keeping the memory footprint of the collection as small as possible There are design trade-offs|no single data structure design is best for all of the above goals. SN's ENCM 339 Fall 2015 Slide Set 17 slide 5/46 Here are two kinds of data structures that everybody in this course should be familiar with: I arrays I C and C++ structure objects We're about to study a kind of data structure called a linked list.
    [Show full text]
  • Threads Chapter 4
    Threads Chapter 4 Reading: 4.1,4.4, 4.5 1 Process Characteristics ● Unit of resource ownership - process is allocated: ■ a virtual address space to hold the process image ■ control of some resources (files, I/O devices...) ● Unit of dispatching - process is an execution path through one or more programs ■ execution may be interleaved with other process ■ the process has an execution state and a dispatching priority 2 Process Characteristics ● These two characteristics are treated independently by some recent OS ● The unit of dispatching is usually referred to a thread or a lightweight process ● The unit of resource ownership is usually referred to as a process or task 3 Multithreading vs. Single threading ● Multithreading: when the OS supports multiple threads of execution within a single process ● Single threading: when the OS does not recognize the concept of thread ● MS-DOS support a single user process and a single thread ● UNIX supports multiple user processes but only supports one thread per process ● Solaris /NT supports multiple threads 4 Threads and Processes 5 Processes Vs Threads ● Have a virtual address space which holds the process image ■ Process: an address space, an execution context ■ Protected access to processors, other processes, files, and I/O Class threadex{ resources Public static void main(String arg[]){ ■ Context switch between Int x=0; processes expensive My_thread t1= new my_thread(x); t1.start(); ● Threads of a process execute in Thr_wait(); a single address space System.out.println(x) ■ Global variables are
    [Show full text]
  • Lecture 10: Introduction to Openmp (Part 2)
    Lecture 10: Introduction to OpenMP (Part 2) 1 Performance Issues I • C/C++ stores matrices in row-major fashion. • Loop interchanges may increase cache locality { … #pragma omp parallel for for(i=0;i< N; i++) { for(j=0;j< M; j++) { A[i][j] =B[i][j] + C[i][j]; } } } • Parallelize outer-most loop 2 Performance Issues II • Move synchronization points outwards. The inner loop is parallelized. • In each iteration step of the outer loop, a parallel region is created. This causes parallelization overhead. { … for(i=0;i< N; i++) { #pragma omp parallel for for(j=0;j< M; j++) { A[i][j] =B[i][j] + C[i][j]; } } } 3 Performance Issues III • Avoid parallel overhead at low iteration counts { … #pragma omp parallel for if(M > 800) for(j=0;j< M; j++) { aa[j] =alpha*bb[j] + cc[j]; } } 4 C++: Random Access Iterators Loops • Parallelization of random access iterator loops is supported void iterator_example(){ std::vector vec(23); std::vector::iterator it; #pragma omp parallel for default(none) shared(vec) for(it=vec.begin(); it< vec.end(); it++) { // do work with it // } } 5 Conditional Compilation • Keep sequential and parallel programs as a single source code #if def _OPENMP #include “omp.h” #endif Main() { #ifdef _OPENMP omp_set_num_threads(3); #endif for(i=0;i< N; i++) { #pragma omp parallel for for(j=0;j< M; j++) { A[i][j] =B[i][j] + C[i][j]; } } } 6 Be Careful with Data Dependences • Whenever a statement in a program reads or writes a memory location and another statement reads or writes the same memory location, and at least one of the two statements writes the location, then there is a data dependence on that memory location between the two statements.
    [Show full text]
  • The Problem with Threads
    The Problem with Threads Edward A. Lee Electrical Engineering and Computer Sciences University of California at Berkeley Technical Report No. UCB/EECS-2006-1 http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-1.html January 10, 2006 Copyright © 2006, by the author(s). All rights reserved. Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission. Acknowledgement This work was supported in part by the Center for Hybrid and Embedded Software Systems (CHESS) at UC Berkeley, which receives support from the National Science Foundation (NSF award No. CCR-0225610), the State of California Micro Program, and the following companies: Agilent, DGIST, General Motors, Hewlett Packard, Infineon, Microsoft, and Toyota. The Problem with Threads Edward A. Lee Professor, Chair of EE, Associate Chair of EECS EECS Department University of California at Berkeley Berkeley, CA 94720, U.S.A. [email protected] January 10, 2006 Abstract Threads are a seemingly straightforward adaptation of the dominant sequential model of computation to concurrent systems. Languages require little or no syntactic changes to sup- port threads, and operating systems and architectures have evolved to efficiently support them. Many technologists are pushing for increased use of multithreading in software in order to take advantage of the predicted increases in parallelism in computer architectures.
    [Show full text]
  • Fast Sequential Summation Algorithms Using Augmented Data Structures
    Fast Sequential Summation Algorithms Using Augmented Data Structures Vadim Stadnik [email protected] Abstract This paper provides an introduction to the design of augmented data structures that offer an efficient representation of a mathematical sequence and fast sequential summation algorithms, which guarantee both logarithmic running time and logarithmic computational cost in terms of the total number of operations. In parallel summation algorithms, logarithmic running time is achieved by high linear computational cost with a linear number of processors. The important practical advantage of the fast sequential summation algorithms is that they do not require supercomputers and can run on the cheapest single processor systems. Layout 1. Motivation 2. Parallel Summation Algorithms 3. Choice of Data Structure 4. Geometric Interpretation 5. Representation of Sequence 6. Fast Sequential Summation Algorithms 7. Mean Value and Standard Deviation 8. Other Data Structures 1. Motivation The original version of the fast sequential summation algorithms described here was implemented in C++ using data structures that support interfaces of STL containers [1]. These interesting and important algorithms can be implemented in many other programming languages. This discussion provides an introduction to the design of data structures, which significantly improve performance of summation algorithms. The fast summation algorithms have been developed by applying the method of augmenting data structures [2]. This powerful method can be used to solve a wide range of problems. It helps design advanced data structures that support more efficient algorithms than basic data structures. The main disadvantage of this method is its complexity, which makes the use of this method difficult in practice.
    [Show full text]
  • Linked List Data Structure
    Linked List Data Structure Static and Dynamic data structures A static data structure is an organization of collection of data that is fixed in size. as memory ,(مسبقا") This results in the maximum size needing to be known in advance cannot be reallocated at a later. Arrays are example of static data structure. A dynamic data structure , where in with the latter the size of the structure can dynamically grow or shrink in size as needed. Linked lists are example of dynamic data structure. Linked Lists Like arrays, Linked List is a linear data structure. Unlike arrays, linked list elements are not stored at contiguous location; the elements are linked using pointers. It consists of group of nodes in a sequence which is divided in two parts. Each node consists of its own data and the address of the next node and forms a chain. Linked Lists are used to create trees and graphs. What are different between linked lists and arrays? Arrays Linked lists Have a pre-determined fixed No fixed size; grow one element at a time size Array items are store Element can be stored at any place contiguously Easy access to any element in No easy access to i-th element , need to hop through all previous constant time elements start from start Size = n x sizeof(element) Size = n x sizeof (element) + n x sizeof(reference) Insertion and deletion at Insertion and deletion are simple and faster particular position is complex(shifting) Only element store Each element must store element and pointer to next element (extra memory for storage pointer).
    [Show full text]
  • Modifiable Array Data Structures for Mesh Topology
    Modifiable Array Data Structures for Mesh Topology Dan Ibanez Mark S Shephard February 27, 2016 Abstract Topological data structures are useful in many areas, including the various mesh data structures used in finite element applications. Based on the graph-theoretic foundation for these data structures, we begin with a generic modifiable graph data structure and apply successive optimiza- tions leading to a family of mesh data structures. The results are compact array-based mesh structures that can be modified in constant time. Spe- cific implementations for finite elements and graphics are studied in detail and compared to the current state of the art. 1 Introduction An unstructured mesh simulation code relies heavily on multiple core capabili- ties to deal with the mesh itself, and the range of features available at this level constrain the capabilities of the simulation as a whole. As such, the long-term goal towards which this paper contributes is the development of a mesh data structure with the following capabilities: 1. The flexibility to deal with evolving meshes 2. A highly scalable implementation for distributed memory computers 3. The ability to represent any of the conforming meshes typically used by Finite Element (FE) and Finite Volume (FV) methods 4. Minimize memory use 5. Maximize locality of storage 6. The ability to parallelize work inside supercomputer nodes with hybrid architecture such as accelerators This paper focuses on the first five goals; the sixth will be the subject of a future publication. In particular, we present a derivation for a family of structures with these properties: 1 1.
    [Show full text]
  • CUDA Binary Utilities
    CUDA Binary Utilities Application Note DA-06762-001_v11.4 | September 2021 Table of Contents Chapter 1. Overview..............................................................................................................1 1.1. What is a CUDA Binary?...........................................................................................................1 1.2. Differences between cuobjdump and nvdisasm......................................................................1 Chapter 2. cuobjdump.......................................................................................................... 3 2.1. Usage......................................................................................................................................... 3 2.2. Command-line Options.............................................................................................................5 Chapter 3. nvdisasm.............................................................................................................8 3.1. Usage......................................................................................................................................... 8 3.2. Command-line Options...........................................................................................................14 Chapter 4. Instruction Set Reference................................................................................ 17 4.1. Kepler Instruction Set.............................................................................................................17
    [Show full text]
  • Lithe: Enabling Efficient Composition of Parallel Libraries
    BERKELEY PAR LAB Lithe: Enabling Efficient Composition of Parallel Libraries Heidi Pan, Benjamin Hindman, Krste Asanović [email protected] {benh, krste}@eecs.berkeley.edu Massachusetts Institute of Technology UC Berkeley HotPar Berkeley, CA March 31, 2009 1 How to Build Parallel Apps? BERKELEY PAR LAB Functionality: or or or App Resource Management: OS Hardware Core 0 Core 1 Core 2 Core 3 Core 4 Core 5 Core 6 Core 7 Need both programmer productivity and performance! 2 Composability is Key to Productivity BERKELEY PAR LAB App 1 App 2 App sort sort bubble quick sort sort code reuse modularity same library implementation, different apps same app, different library implementations Functional Composability 3 Composability is Key to Productivity BERKELEY PAR LAB fast + fast fast fast + faster fast(er) Performance Composability 4 Talk Roadmap BERKELEY PAR LAB Problem: Efficient parallel composability is hard! Solution: . Harts . Lithe Evaluation 5 Motivational Example BERKELEY PAR LAB Sparse QR Factorization (Tim Davis, Univ of Florida) Column Elimination SPQR Tree Frontal Matrix Factorization MKL TBB OpenMP OS Hardware System Stack Software Architecture 6 Out-of-the-Box Performance BERKELEY PAR LAB Performance of SPQR on 16-core Machine Out-of-the-Box sequential Time (sec) Time Input Matrix 7 Out-of-the-Box Libraries Oversubscribe the Resources BERKELEY PAR LAB TX TYTX TYTX TYTX A[0] TYTX A[0] TYTX A[0] TYTX A[0] TYTX TYA[0] A[0] A[0]A[0] +Z +Z +Z +Z +Z +Z +Z +ZA[1] A[1] A[1] A[1] A[1] A[1] A[1]A[1] A[2] A[2] A[2] A[2] A[2] A[2] A[2]A[2]
    [Show full text]
  • Thread Scheduling in Multi-Core Operating Systems Redha Gouicem
    Thread Scheduling in Multi-core Operating Systems Redha Gouicem To cite this version: Redha Gouicem. Thread Scheduling in Multi-core Operating Systems. Computer Science [cs]. Sor- bonne Université, 2020. English. tel-02977242 HAL Id: tel-02977242 https://hal.archives-ouvertes.fr/tel-02977242 Submitted on 24 Oct 2020 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Ph.D thesis in Computer Science Thread Scheduling in Multi-core Operating Systems How to Understand, Improve and Fix your Scheduler Redha GOUICEM Sorbonne Université Laboratoire d’Informatique de Paris 6 Inria Whisper Team PH.D.DEFENSE: 23 October 2020, Paris, France JURYMEMBERS: Mr. Pascal Felber, Full Professor, Université de Neuchâtel Reviewer Mr. Vivien Quéma, Full Professor, Grenoble INP (ENSIMAG) Reviewer Mr. Rachid Guerraoui, Full Professor, École Polytechnique Fédérale de Lausanne Examiner Ms. Karine Heydemann, Associate Professor, Sorbonne Université Examiner Mr. Etienne Rivière, Full Professor, University of Louvain Examiner Mr. Gilles Muller, Senior Research Scientist, Inria Advisor Mr. Julien Sopena, Associate Professor, Sorbonne Université Advisor ABSTRACT In this thesis, we address the problem of schedulers for multi-core architectures from several perspectives: design (simplicity and correct- ness), performance improvement and the development of application- specific schedulers.
    [Show full text]
  • Trees • Binary Trees • Traversals of Trees • Template Method Pattern • Data
    TREES • trees • binary trees • traversals of trees • template method pattern • data structures for trees Trees 1 Trees •atree represents a hierarchy - organization structure of a corporation Electronics R’Us R&D Sales Purchasing Manufacturing Domestic International TV CD Tuner Canada S. America Overseas Africa Europe Asia Australia - table of contents of a book student guide overview grading environment programming support code exams homeworks programs Trees 2 Another Example • Unix or DOS/Windows file system /user/rt/courses/ cs016/ cs252/ grades grades homeworks/ programs/ projects/ hw1 hw2 hw3 pr1 pr2 pr3 papers/ demos/ buylow sellhigh market Trees 3 Terminology • A is the root node. • B is the parent of D and E. • C is the sibling of B • D and E are the children of B. • D, E, F, G, I are external nodes, or leaves. • A, B, C, H are internal nodes. • The depth (level) of E is 2 • The height of the tree is 3. • The degree of node B is 2. A B C D E F G H I Property: (# edges) = (#nodes) − 1 Trees 4 Binary Trees • Ordered tree: the children of each node are ordered. • Binary tree: ordered tree with all internal nodes of degree 2. • Recursive definition of binary tree: •Abinary tree is either -anexternal node (leaf), or -aninternal node (the root) and two binary trees (left subtree and right subtree) Trees 5 Examples of Binary Trees • arithmetic expression + × × + 5 4 + × + 7 2 3 + 2 8 1 + 4 6 ((((3 × (1 + (4 + 6))) + (2 + 8)) × 5) + ( 4 × (7 + 2))) •river Trees 6 Properties of Binary Trees •(# external nodes ) = (# internal nodes) + 1 •(#
    [Show full text]