# BM267 - Introduction to Data Structures

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 BM267 - Introduction to Data Structures 3. Elementary Data Structures Ankara University Computer Engineering Department BLM267 1

2 Objectives Learn about elementary data structures - Data structures that form the basis of more complex data structures. Structure: Combines different data types as a unit. Array: Combines many instances of the same data type as a unit. Linked list: allows insertions and removals anywhere. Implementation using dynamic allocation vs fixed arrays. String: allows insertions and removals of substrings hence the size changes dynamically. BLM267 2

3 Self-referential objects Object = any data type (elementary or aggregate) that has memory allocated for it (we talk about concrete types now). Node: object that contains a pointer to a object of the same type Nodes can be linked together to form useful data structures such as lists, queues, stacks and trees By convention, a NULL pointer (value 0) is used to indicate that the link is not meaningful. BLM267 3

4 Node A node in the simplest form has two fields: Data Link A node can have two or more links, each pointing to a node. Data Link Link Link field always contains information that identifies the successor node. This information may be a pointer (memory address), or an index (into an array). BLM267 4

5 Node Data Link Data field can contain any data type. Link field points to a node (it contains a memory address) If link field has a value of 0 (NULL or NIL) then node does not have a successor. Then, the link is terminated : Data 0 Data NULL Data Data BLM267 5

6 Node A node for int values defined in C: struct node { int data; node * next; }; data next You can define an array of such structures: struct node array[n]; Or allocate each node separately: malloc(sizeof( struct node)); BLM267 6

7 Programming errors with pointers Dereferencing a NULL pointer struct node *q = NULL; ptr 0 q->data = 5; /* ERROR */ Using a freed element node free(q->next); q->next->data = 6; /* PROBLEM */ Using a pointer before set q = (node*)malloc(sizeof(node)); q->next->data = 7; /* ERROR */ BLM267 7

8 Linked List (as an elementary data type) The simplest kind of linked list is a linear chain of links (pointers) to nodes of the same type. More sophisticated linked lists maye have several chains of pointers. A linked list can only be reached thru its handle(s). Handles are called the head pointer (or list-head), tailpointer (or list-end). BLM267 8

9 Linked list - most common types Singly linked list Each node points to the next Terminates with a null pointer Only traversed in one direction Circular, singly linked Pointer in the last node points back to the first node Doubly linked list May have two start pointers head element and tail element Each node has forward / backward pointers Allows traversals both forwards and backwards Circular, doubly linked list Forward pointer of the last node points to the first node and backward pointer of the first node points to the last node BLM267 9

10 Singly-linked list Consists of a sequence of nodes with one link field. LH The first node in the list is called the head node. To access a node, the predecessor of the node must be available. To access the head node, its address is kept in a special pointer named head (or listhead, LH) pointer outside the list. BLM267 10

11 Singly-linked list List operations: Insert a new item (pointer to the new node is given) Delete an item (the key value of the item is given) Search for an item (the key value is given) Normally, only the listhead (LH) is given. There is no information on: The number of nodes (might be 0, 1 or any number N). The value in each node. BLM267 11

12 Singly-linked unordered list Let s assume that the items are always added to the beginning of the list Deleting an item may require the traversal of the entire list. Searching for an item may require the traversal of the entire list BLM267 12

13 Singly-linked unordered list Adding a node to an unordered list: List head pointer (LH) is given, A pointer to the new node (newnode) is given LH newnode The desired result is: LH BLM267 13

14 Singly-linked unordered list struct LNODE { int val; LNODE * next; }; LNODE * LH; LNODE * newnode; C code for creating a node: newnode = malloc(sizeof(lnode)); BLM267 14

16 Singly-linked unordered list Deleting a node: List head pointer (LH) is given, The key value of the item (key) is given (Assume 13) The desired result is: Modified Deleted BLM267 16

17 Singly-linked unordered list For deletions, need to keep two pointers, pointing to the modified and deleted items. Special cases: In case of deleting the first item, listhead pointer LH must be updated. We will assume that an item with key always exists in the list. BLM267 17

18 Singly-linked unordered list C code for deleting a node whose data value is given: Let the caller update the listhead pointer Caller code: LH = DeleteNode(LH, key); Where: LNODE * DeleteNode(LNODE * head, int key) { LNODE * node = head; LNODE * prev = NULL; while (node->val!= key) { prev = node; node = node->next; } } if (!prev) head = node->next; else prev->next = node->next; free (node); return head; (Deleting the first node) (Return listhead) BLM267 18

19 Singly-linked unordered list Let the called function update the listhead pointer Caller code: DeleteNode(&LH, key); Where: void DeleteNode(LNODE ** head, int key) { LNODE * node = head; LNODE * prev = NULL; while (node->val!= key) (Find node to delete) { prev = node; node = node->next; } } if (!prev) *head = node->next; else prev->next = node->next; free (node); (Deleting the first node) BLM267 19

20 Singly-linked unordered list Search for a value: List head pointer (LH) is given, The key value (key) is given The desired result is: TRUE : Value is in the list FALSE: Value is not in the list BLM267 20

21 Singly-linked unordered list Caller code: if(search(lh,12)) /*Search for an item with value 12 */... /* Value found */ else... /* Value not found */ Where: int Search(LNODE * node, int key) { while (node) if (node->val == key) return 1; /* Value found */ else node = node->next; return 0; /* Value not found */ } BLM267 21

22 Sorted lists Keep the items on the list in a sorted order, based on data value in each node Advantages: already sorted, no need for sort operation operations such as delete, find, etc. need not search to the end of the list if the item is not in list Disadvantages Insert operation must search for the right place to add element (slower than simply adding at beginning) BLM267 22

23 Singly-linked ordered list Adding a node to an ordered list: List head pointer (LH) is given, LH A pointer to the new node is given Initial configuration 12 The desired result is: Modified Added BLM267 23

24 Circular singly-linked list Last node references the first node Every node has a successor No node in a circular linked list contains NULL Checking if the circle is completed: if(node->next == list)... Pointer comparison BLM267 24

25 Singly-linked list with dummy head node Dummy head node is always present, even when the linked list is empty. Insertion and deletion algorithms use two pointers, prev and node, For empty lists, initialize prev to reference the dummy head node, rather than NULL. Move both pointers together. prev node BLM267 25

27 Doubly-linked ordered list Adding a node to an ordered list: List head pointer (LH) is given, A pointer to the new node is given LH BLM267 27

29 Doubly-linked ordered list Deleting a node: List head pointer (LH) is given, The key value of the item (val) is given (Assume 15) Modified Deleted Modified BLM267 29

30 Implementing lists using arrays Arrays have fixed number of elements (check for overflow). Pointers now become array indices (of type integer). Since C arrays start with index 0, we will assume -1 corresponds to the NULL pointer. The last used array element need to be maintained. Here is the NODE structure for use with arrays in C: struct NODE { int val; int next; }; BLM267 30

31 Implementing lists using arrays (2) NODE node[n]; int LH = -1; A NODE array of size N, (N is a compile-time constant) Note that we have to distinguish unused array elements. We will accept the convention that a link value of -2 denotes an unused array element. Therefore, the array has to be initialized. for(i=0; i<n; i++) node[i].next = -2; -1 LH -1 means: the chain ends here, -2 means: node is available (not currently used). Any other value means: 1) node is currently in the list and, 2) is followed by node whose index is here. BLM

32 Implementing lists using arrays (3) We will also need to find an empty element to insert the new node (instead of using malloc()). Caller Code: index = FindEmpty( ); if (index == -1) { /* No more space on array */} else { /* Use node[index] */ }... Where: int FindEmpty() { int i; for(i=0; i<n; i++) if(node[i].link == -2) return i; return -1; } BLM267 32

33 Implementing lists using arrays (4) C code for adding a node to the beginning of the list, assuming node[] and LH are defined globally. Caller code: AddNode(newNode); Where: void AddNode(int newval) { int index; index = FindEmpty( ); if (index == -1) { /* No more space on array */ } else { node[index].val = newval; node[index].next = LH; LH = index; } } BLM267 33

34 Implementing lists using arrays (5) C code for deleting a node, assuming node[] and LH are defined globally and val always exists in the list. Caller code: DeleteNode(val); Where: void DeleteNode(int delval) { int index=lh; while(!(index < 0)) if(node[index].val == delval) break; else { prev = index; index = node[index].next; } if(prev < 0) (Deleting the first node) LH = node[index].next; } else node[prev].next = node[index].next; node[index].next = -2; (Mark as empty) BLM267 34

35 Implementing lists using arrays (6) C code for searching a value in an unordered list, assuming node[] and LH are defined globally. Caller code: if(searchval(val)) /*Search for an item with value val */... /* Value found */ else... /* Value not found */ Where: int SearchVal(int val) { int index=lh; while(!(index < 0)) if(node[index].val == val) return 1; /* Success */ else /* keep trying */ index = node[index].next; return 0; /* Failure*/ } BLM267 35

36 Lists vs. Arrays - A comparison Space (storage) considerations A linked list requires pointers to nodes. An array requires the maximum number of elements to be known in advance. If that maximum is not required, space is wasted at the end of the array. Time considerations Operations on a linked list require more lines of explicit code than those in an array. However, addressing an array element uses more implicit (compiler generated) code. Arrays are quicker at finding and altering in the middle Linked lists are quicker at insertions and removals in the beginning/middle BLM267 36

37 String (as an elementary data type) Not a built-in C/C++ type. String type can be (and is) implemented transparently. Need to grow and shrink in size - Efficiently represented as (variable-length) array of characters. Need to be maintained dynamically (by the system or by the user.) String Operations: Compute length Copy Compare strings Check substring existence Append, insert, delete substring BLM267 37

38 String representation Allocate a fixed number of bytes for characters. Use as many characters as needed, disregard the rest. char str1[50]; A N K A R A U N I V E R S I T Y Array elements can be addressed individually as chars. Beginning of the string is the first character: str1[0]. Handle of the string is a pointer to the first character. How to tell at which position the string ends BLM267 38

39 BLM String representation Two accepted ways to represent strings. ASCIIZ representation: End the string with a binary 0. \0 Y T I S R E V I N U A R A K N A \0 Null (empty) string: Size-Content representation: Keep string size at the front. 17 Y T I S R E V I N U A R A K N A Null (empty) string: 00

40 Null string representation char * str; An empty (null) string is NOT represented by: str = 0; An empty (null) string is represented by: *str = 0; Empty or not, string pointers must always point to valid memory locations. 0x00 If a string pointer is NULL, the string is invalid (cannot do string operations on it) A null pointer and a null string are different entities. BLM267 40

41 String buffer When processing strings, strings are allowed to grow/shrink in size (create, copy, append). Allocating one (maximum size) array for each string is very inefficient. Compilers use a contiguous memory block called string buffer (or string space) to keep literal strings which are constant (format strings, initialization strings etc.) Some applications define a string buffer which is a memory area that contains all strings side by side, and can be manipulated under program control. A N K A R A \0 U N I V E R S I T Y \0 BLM267 41

42 String buffer If a string grows in size, it may need to be moved to a different location in string buffer. A N K A R A \0 U N I V E R S I T Y \0 char * p char * q After strcat(p,q): A N K A R A U N I V E R S I T Y \0 \0 char * p char * q BLM267 42

43 String buffer Empty locations in string buffer may need to be compacted from time to time. \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 BLM267 43

44 Elementary data structures Elementary data structures are the data types that are implemented in programming language syntax, or can be added with little effort. Basically, structures, arrays, linked lists and strings are sufficient to implement most of the useful data structures. Many languages have elementary types as syntactic (language-defined) data types, or have extensive libraries that implement them. BLM267 44

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

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

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

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

### 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

### 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

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

### Chapter 13. Disk Storage, Basic File Structures, and Hashing

Chapter 13 Disk Storage, Basic File Structures, and Hashing Chapter Outline Disk Storage Devices Files of Records Operations on Files Unordered Files Ordered Files Hashed Files Dynamic and Extendible Hashing

### 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

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

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

### Overview of Data Structures

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

### Standard Version of Starting Out with C++, 4th Edition. Linked Lists. Copyright 2003 Scott/Jones Publishing

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!

### International Journal Of Engineering Research & Management Technology

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

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

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

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

### 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

### Memory 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

### 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,

### Symbol Tables. Introduction

Symbol Tables Introduction A compiler needs to collect and use information about the names appearing in the source program. This information is entered into a data structure called a symbol table. The

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

### Data 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

### 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

### 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

### Copyright 2007 Ramez Elmasri and Shamkant B. Navathe. Slide 13-1

Slide 13-1 Chapter 13 Disk Storage, Basic File Structures, and Hashing Chapter Outline Disk Storage Devices Files of Records Operations on Files Unordered Files Ordered Files Hashed Files Dynamic and Extendible

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

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

### Chapter 13 Disk Storage, Basic File Structures, and Hashing.

Chapter 13 Disk Storage, Basic File Structures, and Hashing. Copyright 2004 Pearson Education, Inc. Chapter Outline Disk Storage Devices Files of Records Operations on Files Unordered Files Ordered Files

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

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

### Chapter 13. Pointers and Linked Lists

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

1 ADTs,, Arrays, Linked Lists Outline and Required Reading: ADTs ( 2.1.2) Arrays ( 1.5) Linked Lists ( 4.3.1, 4.3.2) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic Abstract Data Type (ADT) 2 abstract

### TIE-20106 1 TIE-20106 2

TIE-20106 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

### CSE 211: Data Structures Lecture Notes VII

CSE 211: Data Structures Lecture Notes VII LINKED LISTS In the previous lectures we have seen the representation of ordered lists using an array and sequential mapping. These representations had the property

### Lecture 10: Dynamic Memory Allocation 1: Into the jaws of malloc()

CS61: Systems Programming and Machine Organization Harvard University, Fall 2009 Lecture 10: Dynamic Memory Allocation 1: Into the jaws of malloc() Prof. Matt Welsh October 6, 2009 Topics for today Dynamic

### Chapter 13. Chapter Outline. Disk Storage, Basic File Structures, and Hashing

Chapter 13 Disk Storage, Basic File Structures, and Hashing Copyright 2007 Ramez Elmasri and Shamkant B. Navathe Chapter Outline Disk Storage Devices Files of Records Operations on Files Unordered Files

### System 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 end-term exam http://ssw.jku.at/misc/ssw/ 1. Memory

### 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

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

### 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

### 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

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

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

### Data Structure with C

Subject: Data Structure with C Topic : Tree Tree A tree is a set of nodes that either:is empty or has a designated node, called the root, from which hierarchically descend zero or more subtrees, which

### Introduction to data structures

Notes 2: Introduction to data structures 2.1 Recursion 2.1.1 Recursive functions Recursion is a central concept in computation in which the solution of a problem depends on the solution of smaller copies

### Introduction 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

### Record Storage and Primary File Organization

Record Storage and Primary File Organization 1 C H A P T E R 4 Contents Introduction Secondary Storage Devices Buffering of Blocks Placing File Records on Disk Operations on Files Files of Unordered Records

### UNIT-1 PART-A UNIT-2 PART-A

UNIT-1 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

### SYSTEMS PROGRAMMING C++ INTRODUCTION

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

### C Dynamic Data Structures. University of Texas at Austin CS310H - Computer Organization Spring 2010 Don Fussell

C Dynamic Data Structures University of Texas at Austin CS310H - Computer Organization Spring 2010 Don Fussell Data Structures A data structure is a particular organization of data in memory. We want to

### 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:

### strsep exercises Introduction C strings Arrays of char

strsep exercises Introduction The standard library function strsep enables a C programmer to parse or decompose a string into substrings, each terminated by a specified character. The goals of this document

### Pallab Dasgupta. Linked Lists CS10001: Programming & Data Structures. Dept. of Computer Sc. & Engg., Indian Institute of Technology Kharagpur

Linked Lists CS10001: Programming & Data Structures Pallab Dasgupta Dept. of Computer Sc. & Engg., Indian Institute of Technology Kharagpur Arrays: pluses and minuses + Fast element access. -- Impossible

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

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

### 2. Compressing data to reduce the amount of transmitted data (e.g., to save money).

Presentation Layer The presentation layer is concerned with preserving the meaning of information sent across a network. The presentation layer may represent (encode) the data in various ways (e.g., data

### 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.

### 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

### recursion, 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

### Data 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,

### 406 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

### Data Structures. Topic #4

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

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

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

### Algorithms 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

### 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

### Singly Linked Lists and Chains

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

### Stacks, 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 well-defined collection of elements (elements could be numbers, functions, geometric shapes);

### Last Time: Dynamic Memory Allocation. Introduction to Computer Systems /18 243, fall th Lecture, Oct. 27 th. Last Time: Fragmentation

Last Time: Dynamic Memory Allocation Introduction to Computer Systems 15 213/18 243, fall 2009 17 th Lecture, Oct. 27 th p1 = malloc(4) p2 = malloc(5) p3 = malloc(6) Instructors: Roger Dannenberg and Greg

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

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

### Chapter 8: Structures for Files. Truong Quynh Chi tqchi@cse.hcmut.edu.vn. Spring- 2013

Chapter 8: Data Storage, Indexing Structures for Files Truong Quynh Chi tqchi@cse.hcmut.edu.vn Spring- 2013 Overview of Database Design Process 2 Outline Data Storage Disk Storage Devices Files of Records

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

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

### 1 (1x17 =17 points) 2 (21 points) 3 (5 points) 4 (3 points) 5 (4 points) Total ( 50points) Page 1

CS 1621 MIDTERM EXAM 1 Name: Problem 1 (1x17 =17 points) 2 (21 points) 3 (5 points) 4 (3 points) 5 (4 points) Total ( 50points) Score Page 1 1. (1 x 17 = 17 points) Determine if each of the following statements

### Memory 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

### BSc (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 2005-2006 / Semester

### CS271: Data Structures. Binary Search Trees

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

### Operating Systems CSE 410, Spring 2004. File Management. Stephen Wagner Michigan State University

Operating Systems CSE 410, Spring 2004 File Management Stephen Wagner Michigan State University File Management File management system has traditionally been considered part of the operating system. Applications

### Node-Based Structures Linked Lists: Implementation

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

### INTRODUCTION The collection of data that makes up a computerized database must be stored physically on some computer storage medium.

Chapter 4: Record Storage and Primary File Organization 1 Record Storage and Primary File Organization INTRODUCTION The collection of data that makes up a computerized database must be stored physically

### Symbol Tables. IE 496 Lecture 13

Symbol Tables IE 496 Lecture 13 Reading for This Lecture Horowitz and Sahni, Chapter 2 Symbol Tables and Dictionaries A symbol table is a data structure for storing a list of items, each with a key and

### C Primer. Fall Introduction C vs. Java... 1

CS 33 Intro Computer Systems Doeppner C Primer Fall 2016 Contents 1 Introduction 1 1.1 C vs. Java.......................................... 1 2 Functions 1 2.1 The main() Function....................................

Linked Lists Ch 17 (Gaddis) Introduction to Linked Lists A data structure representing a A series of nodes chained together in sequence CS 3358 Summer I 2012 Jill Seaman - Each node points to one other

### Data Structures and Data Manipulation

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

### Anatomy of a linked list

Linked Lists Anatomy of a linked list A linked list consists of: A sequence of nodes mylist a b c d Each node contains a value and a link (pointer or reference) to some other node The last node contains

### 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

Arrays and Linked Lists 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)

### Stack & Queue. Darshan Institute of Engineering & Technology. Explain Array in detail. Row major matrix No of Columns = m = u2 b2 + 1

Stack & Queue Explain Array in detail One Dimensional Array Simplest data structure that makes use of computed address to locate its elements is the onedimensional array or vector; number of memory locations

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

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

### CS0213 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: 2012-2013 SCHOOL OF COMPUTER SCIENCE & ENGINEERING SRM UNIVERSITY, SRM NAGAR, KATTANKULATHUR-603203.

### Abstract 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

### Bhakta Kavi Narsinh Mehta University, Junagadh

Bhakta Kavi Narsinh Mehta University, Junagadh Draft Syllabus for B.Sc. (Computer Science) Bachelor of Science (Computer Science) (Semester - 1) Effective From June - 2016 B.Sc. (C.S.) (Semester - 1) CS-101:

### Strings in C++ and Java. Questions:

Strings in C++ and Java Questions: 1 1. What kind of access control is achieved by the access control modifier protected? 2 2. There is a slight difference between how protected works in C++ and how it

### Example Solution to Exam in EDA150 C Programming

Example Solution to Exam in EDA150 C Programming Janurary 12, 2011, 14-19 Inga hjälpmedel! Examinator: Jonas Skeppstedt, tel 0767 888 124 30 out of 60p are needed to pass the exam. General Remarks A function

### 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

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

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

### Standard printing function in C is printf Prints everything numbers, strings, etc. May be complex to use. Standard C library is called libc

Arrays and Structs and Pointers, Oh My! Programming in C Input and output Using printf Standard input and output Pointers Arrays Structures Combining these things together Arrays and Structs and Pointers,

### Object-Oriented Programming, Iouliia Skliarova

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

### Glossary 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

### Unit 1. 5. Write iterative and recursive C functions to find the greatest common divisor of two integers. [6]

Unit 1 1. Write the following statements in C : [4] Print the address of a float variable P. Declare and initialize an array to four characters a,b,c,d. 2. Declare a pointer to a function f which accepts

### 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

### 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,

### Ordered Lists and Binary Trees

Data Structures and Algorithms Ordered Lists and Binary Trees Chris Brooks Department of Computer Science University of San Francisco Department of Computer Science University of San Francisco p.1/62 6-0: