CIS 190: C/C++ Programming. Lecture 5 Linked Lists
|
|
|
- Nora Payne
- 7 years ago
- Views:
Transcription
1 CIS 190: C/C++ Programming Lecture 5 Linked Lists 1
2 Outline (from last class) Memory and Functions Linked Lists & Arrays Anatomy of a Linked List Details On Handling headptr Using Linked Lists Creation Traversal Inserting a Node Deleting a Node Homework 4B 2
3 Memory and Functions how do different types of variables get passed to and returned from functions? passing by value passing by reference implicit: arrays, strings explicit: pointers 3
4 Memory and Functions some simple examples: int Add(int x, int y); int answer = Add(1, 2); void PrintMenu(void); PrintMenu(); int GetAsciiValue(char c); int ascii = GetAsciiValue ( m ); all passed by value 4
5 Memory and Functions passing arrays to functions void TimesTwo(int array[], int size); int arr [ARR_SIZE]; /* set values of arr */ TimesTwo(arr, ARR_SIZE); arrays of any type are passed by reference changes made in-function persist 5
6 Memory and Functions passing arrays to functions void TimesTwo(int array[], int size); void TimesTwo(int * array, int size); both of these behave the same way they take a pointer to: the beginning of an array an int that we (can) treat like an array 6
7 Memory and Functions passing strings to functions void PrintName(char name[]); void PrintName(char *name ); char myname [NAME_SIZE] = Alice ; PrintName(myName); strings are arrays (of characters) implicitly passed by reference 7
8 Memory and Functions passing pointers to int to functions void Square(int *n); int x = 9; Square(&x); pass address of an integer (in this case, x) 8
9 Memory and Functions passing int pointers to function void Square(int *n); int x = 9; int *xptr = &x; Square(???); pass??? 9
10 Memory and Functions passing int pointers to function void Square(int *n); int x = 9; int *xptr = &x; Square(xPtr); pass xptr, which is an address to an integer (x) 10
11 Memory and Functions returning pointers from functions CAR* MakeCar(void) { CAR temp; return &temp; } temp is on the stack so what happens? 11
12 Memory and Functions returning pointers from functions CAR* MakeCar(void) { CAR temp; return &temp; } temp is on the stack so it will be returned to the process when MakeCar() returns! 12
13 Memory and Functions returning pointers from functions CAR* MakeCar(void) { CAR* temp; temp = (CAR*) malloc (sizeof(car)); return temp; } temp is on the heap so what happens? 13
14 Memory and Functions returning pointers from functions CAR* MakeCar(void) { CAR* temp; temp = (CAR*) malloc (sizeof(car)); return temp; } temp is on the heap so it belongs to you and will remain on the heap until you free() it 14
15 Outline (from last class) Memory and Functions Linked Lists & Arrays Anatomy of a Linked List Details On Handling headptr Using Linked Lists Creation Traversal Inserting a Node Deleting a Node Homework 4B 15
16 What is a Linked List? 16
17 What is a Linked List? structure dynamic allow easy insertion and deletion uses nodes that contain pointer to node in the list this is called singly linked, and is what we ll be using 17
18 Question What are some disadvantages of arrays? not dynamic size is fixed once created you can resize it, but you have to do it by hand same for insertion & deletion; it s possible, but it s difficult and there s no built-in function for it require contiguous block of memory 18
19 Question Can we fix these with linked lists? How? not dynamic linked lists can change size constantly can add nodes anywhere in a linked lists elements can be removed with no empty spaces require contiguous block of memory only one node needs to be held contiguously 19
20 Question Are there any disadvantages to linked lists? harder to search/access than arrayz need to manage size/counter for size harder to manage memory in-list cycles, segfaults, etc. pointer to node takes up more memory 20
21 Outline (from last class) Memory and Functions Linked Lists & Arrays Anatomy of a Linked List Details On Handling headptr Using Linked Lists Creation Traversal Inserting a Node Deleting a Node Homework 4B 21
22 Linked List Anatomy headptr NULL 22
23 Nodes a node is one element of a linked list nodes consist of two parts: typically represented as structs 23
24 Nodes a node is one element of a linked list nodes consist of two parts: stored in node typically represented as structs 24
25 Nodes a node is one element of a linked list nodes consist of two parts: stored in node pointer to node in list typically represented as structs 25
26 Node Definition nodes are typically represented as structs typedef struct node { int ; PTR ; } ; 26
27 Node Definition nodes are typically represented as structs typedef struct node * PTR; typedef struct node { int } ; ; PTR ; typedef PTR beforehand so that it can be used in the definition of the structure 27
28 Linked List Anatomy headptr NULL 28
29 List Head headptr points to the first in the list if there is no list, points to NULL headptr does not contain any of its own only a pointer to a 29
30 Linked Lists headptr PTR NULL 30
31 Linked Lists headptr 0xFFEE NULL 31
32 Linked Lists 0xFFC4 0xFFC0 0xFFC8 0xFFDC 0xFFEE 0xFFEE NULL 32
33 Linked Lists 0xFFC4 0xFFC0 = 5; = 3; = 8; = 2; 0xFFC8 0xFFDC 0xFFEE 0xFFEE NULL 33
34 Outline (from last class) Memory and Functions Linked Lists & Arrays Anatomy of a Linked List Details On Handling headptr Using Linked Lists Creation Traversal Inserting a Node Deleting a Node Homework 4B 34
35 More About headptr headptr is a pointer to a it has a place where it s stored in memory and it has where it points to in memory 35
36 More About headptr headptr is a pointer to a it has a place where it s stored in memory and it has where it points to in memory 0xFFC4 address where it s stored in memory 0xDC44 value where it points to in memory 36
37 Passing Pointers when we pass a pointer by value, we pass where it points to in memory so we can change the value(s) stored in the memory location to which it points but we can t alter the pointer itself 37
38 Passing Pointers by Value Example void SquareNum (int *intptr) { } (*intptr) = (*intptr) * (*intptr); 38
39 Passing Pointers by Value Example void SquareNum (int *intptr) { } (*intptr) = (*intptr) * (*intptr); int x = 4; int *xptr = &x; 39
40 Passing Pointers by Value Example void SquareNum (int *intptr) { } (*intptr) = (*intptr) * (*intptr); int x = 4; int *xptr = &x; SquareNum (xptr); /* value of x is now 16 */ 40
41 Passing Pointers when we pass a pointer by reference, we are passing where it is stored in memory so we can change both where it points to in memory and the values that are stored there 41
42 Passing Pointers by Reference Example void Reassign (int **ptr, int *newaddress) { } *ptr = newaddress; 42
43 Passing Pointers by Reference Example void Reassign (int **ptr, int *newaddress) { } *ptr = newaddress; int x = 3, y = 5; int *intptr = &x; 43
44 Passing Pointers by Reference Example void Reassign (int **ptr, int *newaddress) { } *ptr = newaddress; int x = 3, y = 5; int *intptr = &x; ReassignPointer (&intptr, &y); /* intptr now points to y */ 44
45 headptr Naming Conventions two variable names for headptr inside functions when we pass headptr by value we pass where it points to in memory PTR head = address of first node when we pass headptr by reference we pass where it s stored in memory PTR *headptr = where headptr is stored 45
46 Outline (from last class) Memory and Functions Linked Lists & Arrays Anatomy of a Linked List Details On Handling headptr Using Linked Lists Creation Traversal Inserting a Node Deleting a Node Homework 4B 46
47 Building a Linked List from Scratch 47
48 Building a Linked List from Scratch headptr PTR 1. declare a headptr, and set equal to NULL NULL 48
49 Building a Linked List from Scratch headptr PTR NULL 1. declare a headptr, and set equal to NULL 2. allocate space for a node and set to a temporary variable tempnode NULL 49
50 Building a Linked List from Scratch headptr PTR NULL = 17; 1. declare a headptr, and set equal to NULL 2. allocate space for a node and set to a temporary variable 3. initialize node s tempnode NULL 50
51 Building a Linked List from Scratch headptr PTR tempnode = 17; NULL 1. declare a headptr, and set equal to NULL 2. allocate space for a node and set to a temporary variable 3. initialize node s 4. insert node in list 51
52 Building a Linked List from Scratch headptr insert another node PTR tempnode = 17; = 2; NULL 52
53 Building a Linked List from Scratch headptr PTR insert another node and another, etc. = 17; = 2; = 9; NULL tempnode 53
54 Outline (from last class) Memory and Functions Linked Lists & Arrays Anatomy of a Linked List Details On Handling headptr Using Linked Lists Creation Traversal Inserting a Node Deleting a Node Homework 4B 54
55 Creating a Node PTR CreateNode (void) 1. create and allocate memory for a node newnode = (PTR) malloc (sizeof()); 55
56 Creating a Node PTR CreateNode (void) 1. create and allocate memory for a node newnode = (PTR) malloc (sizeof()); cast as PTR, but space for why? 56
57 Creating a Node PTR CreateNode (void) 1. create and allocate memory for a node newnode = (PTR) malloc (sizeof()); cast as PTR, but space for why? 2. ensure that memory was allocated 3. initialize 57
58 Setting a Node s Data void SetData (PTR temp, int ) temp is a pointer, but it points to a struct use arrow notation to access elements or dot star notation temp-> = ; (*temp). = ; 58
59 When Itself is a Struct typedef struct node { } ; CIS_CLASS class; PTR STRUCT ; int classnum; char room[room_str]; char title [TITLE_STR]; CIS_CLASS STRUCT ( ) 59
60 Setting Data when is a Struct void SetData (PTR temp, int classnum, char room [ROOM_STR], char title [TITLE_STR]) temp->class.classnum = classnum; strcpy(temp->class.room, room); strcpy(temp->class.title, title); the class struct is not a pointer, so we can use just dot notation 60
61 Outline (from last class) Memory and Functions Linked Lists & Arrays Anatomy of a Linked List Details On Handling headptr Using Linked Lists Creation Traversal Inserting a Node Deleting a Node Homework 4B 61
62 Traversing a Linked List used for many linked list operations check to see if list is empty use two temporary pointers to keep track of current and previous nodes (prev and curr) move through list, setting prev to curr and curr to the element of the list continue until you hit the end (or conditions met) 62
63 Special Cases with Linked Lists always a separate rule when dealing with the first element in the list (where headptr points) and a separate rule for when the list is empty laid out in the code available online, but keep it in mind whenever working with linked lists make sure you understand the code before you start using it in your programs 63
64 Traversing a Linked List Step 1 headptr PTR curr set curr to *headptr, the first in the list prev NULL NULL 64
65 Traversing a Linked List Step 2 headptr PTR curr check if curr == NULL (end of list) if it doesn t, continue prev NULL NULL 65
66 Traversing a Linked List Step 2 headptr PTR curr check if curr == NULL (end of list) if it doesn t, continue prev NULL NULL or if your conditions have been met! but you must always check that curr!= NULL first 66
67 Traversing a Linked List Step 3 headptr PTR prev curr set prev = curr NULL 67
68 Traversing a Linked List Step 4 headptr PTR prev curr set curr = curr-> NULL 68
69 Traversing a Linked List Step 4 headptr PTR prev curr set curr = curr-> NULL 69
70 Traversing a Linked List Step 5 headptr PTR prev curr continue to repeat steps 2-4 until you reach the end NULL 70
71 Traversing a Linked List Step 5 headptr PTR prev curr check if curr == NULL (end of list) if it doesn t, continue NULL 71
72 Traversing a Linked List Step 5 headptr PTR prev curr set prev = curr NULL 72
73 Traversing a Linked List Step 5 headptr PTR prev curr set curr = curr-> NULL 73
74 Traversing a Linked List Step 5 headptr PTR prev set curr = curr-> curr NULL 74
75 Traversing a Linked List Step 5 headptr PTR prev check if curr == NULL (end of list) curr if it doesn t, continue NULL 75
76 Traversing a Linked List Step 5 headptr PTR set prev = curr prev curr NULL 76
77 Traversing a Linked List Step 5 headptr PTR set curr = curr-> prev curr NULL 77
78 Traversing a Linked List Step 5 headptr PTR set curr = curr-> prev curr NULL 78
79 Traversing a Linked List Step 5 check if curr == NULL (end of list) headptr PTR prev curr NULL 79
80 Traversing a Linked List Step 5 check if curr == NULL (end of list) headptr prev curr PTR it does! we ve reached the end of the list NULL 80
81 Printing the Entire Linked List void PrintList (PTR head) check to see if list is empty if so, print out a message if not, traverse the linked list print out the of each node 81
82 Outline (from last class) Memory and Functions Linked Lists & Arrays Anatomy of a Linked List Details On Handling headptr Using Linked Lists Creation Traversal Inserting a Node Deleting a Node Homework 4B 82
83 Inserting a Node void Insert (PTR *headptr, PTR temp) check if list is empty if so, temp becomes the first node if list is not empty traverse the list and insert temp at the end 83
84 headptr PTR prev Inserting a Node check if curr == NULL (end of list) curr NULL 84
85 Inserting a Node check if curr == NULL (end of list) headptr PTR prev curr insert the new node by changing where prev-> points to NULL 85
86 Inserting a Node check if curr == NULL (end of list) headptr PTR prev curr insert the new node by changing where prev-> points to address of new node NULL 86
87 Inserting a Node check if curr == NULL (end of list) headptr PTR prev curr insert the new node by changing where prev-> points to address of new node NULL new node is successfully inserted at end of the list! 87
88 Inserting a Node in the Middle int Insert (PTR *headptr, PTR temp, int where) traverse list until you come to place to insert CAUTION: don t go past the end of the list! insert temp at appropriate spot CAUTION: don t lose any pointers! return an integer to convey success/failure 88
89 Inserting a Node Step 1 prev curr traverse the list until you find where you want to insert temp temp NULL 89
90 Inserting a Node Step 2 prev curr first have temp-> point to what will be the node following it in the list (curr) temp temp-> = curr; 90
91 Inserting a Node Step 3 prev curr then you can have prev-> point to temp as the new node in the list temp prev-> = temp; 91
92 Inserting a Node Done prev curr temp is now stored in the list between prev and curr temp 92
93 Inserting a Node Done prev temp curr temp is now stored in the list between prev and curr return a successful code (insert worked) 93
94 Outline (from last class) Memory and Functions Linked Lists & Arrays Anatomy of a Linked List Details On Handling headptr Using Linked Lists Creation Traversal Inserting a Node Deleting a Node Homework 4B 94
95 Deleting a Node int Delete (PTR *headptr, int target) code is similar to insert pass in a way to find the node you want to delete traverse list until you find the correct node: curr-> == target return an integer to convey success/failure 95
96 Deleting a Node Step 1 prev PTR curr PTR PTR traverse the list, searching until curr-> matches target 96
97 Deleting a Node Step 1 prev PTR curr PTR PTR traverse the list, searching until curr-> matches target but don t forget, you must always check that curr!= NULL first 97
98 Deleting a Node Step 2 prev curr remove curr from the list by setting prev-> to curr-> PTR PTR PTR 98
99 Deleting a Node Step 3 prev curr free the memory used by curr and set pointers to NULL PTR PTR PTR 99
100 Deleting a Node Step 3 prev curr free the memory used by curr and set pointers to NULL PTR PTR PTR curr-> = NULL; NULL 100
101 Deleting a Node Step 3 prev curr free the memory used by curr and set pointers to NULL PTR PTR PTR NULL curr-> = NULL; free(curr); 101
102 Deleting a Node Step 3 prev curr free the memory used by curr and set pointers to NULL PTR PTR curr-> = NULL; free(curr); 102
103 Deleting a Node Step 3 prev curr NULL free the memory used by curr and set pointers to NULL PTR PTR curr-> = NULL; free(curr); curr = NULL; 103
104 Deleting a Node Step 3 prev curr NULL free the memory used by curr and set pointers to NULL PTR PTR curr-> = NULL; free(curr); curr = NULL; 104
105 Outline (from last class) Memory and Functions Linked Lists & Arrays Anatomy of a Linked List Details On Handling headptr Using Linked Lists Creation Traversal Inserting a Node Deleting a Node Homework 4B 105
106 Homework 4B Karaoke heavy on pointers and memory management think before you attack start early test often (don t forget edge cases) use a debugger when needed 106
107 Linked List Code for HW4B code for all of these functions is available on the Lectures page comments explain each step you can use this code in your Homework 4B, or as the basis for similar functions 107
Lecture 11 Doubly Linked Lists & Array of Linked Lists. Doubly Linked Lists
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
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)
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
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
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
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
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,
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
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
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 11 Array of Linked Lists
Lecture 11 Array of Linked Lists In this lecture Array of Linked Lists Creating an Array of Linked Lists Representing a Sparse Matrix Defining a Node for Sparse Matrix Exercises Solutions An Array of Linked
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
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.
Memory management. Announcements. Safe user input. Function pointers. Uses of function pointers. Function pointer example
Announcements Memory management Assignment 2 posted, due Friday Do two of the three problems Assignment 1 graded see grades on CMS Lecture 7 CS 113 Spring 2008 2 Safe user input If you use scanf(), include
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
C++ INTERVIEW QUESTIONS
C++ INTERVIEW QUESTIONS http://www.tutorialspoint.com/cplusplus/cpp_interview_questions.htm Copyright tutorialspoint.com Dear readers, these C++ Interview Questions have been designed specially to get
Data Structures Using C++ 2E. Chapter 5 Linked Lists
Data Structures Using C++ 2E Chapter 5 Linked Lists Test #1 Next Thursday During Class Cover through (near?) end of Chapter 5 Objectives Learn about linked lists Become aware of the basic properties of
LINKED DATA STRUCTURES
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
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
arrays C Programming Language - Arrays
arrays So far, we have been using only scalar variables scalar meaning a variable with a single value But many things require a set of related values coordinates or vectors require 3 (or 2, or 4, or more)
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
Molecular Dynamics Simulations with Applications in Soft Matter Handout 7 Memory Diagram of a Struct
Dr. Martin O. Steinhauser University of Basel Graduate Lecture Spring Semester 2014 Molecular Dynamics Simulations with Applications in Soft Matter Handout 7 Memory Diagram of a Struct Friday, 7 th March
Data Structures and Algorithms!
Data Structures and Algorithms! The material for this lecture is drawn, in part, from! The Practice of Programming (Kernighan & Pike) Chapter 2! 1 Motivating Quotation!!! Every program depends on algorithms
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
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
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
CMSC 202H. ArrayList, Multidimensional Arrays
CMSC 202H ArrayList, Multidimensional Arrays What s an Array List ArrayList is a class in the standard Java libraries that can hold any type of object an object that can grow and shrink while your program
CmpSci 187: Programming with Data Structures Spring 2015
CmpSci 187: Programming with Data Structures Spring 2015 Lecture #12 John Ridgway March 10, 2015 1 Implementations of Queues 1.1 Linked Queues A Linked Queue Implementing a queue with a linked list is
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
Coding Rules. Encoding the type of a function into the name (so-called Hungarian notation) is forbidden - it only confuses the programmer.
Coding Rules Section A: Linux kernel style based coding for C programs Coding style for C is based on Linux Kernel coding style. The following excerpts in this section are mostly taken as is from articles
Illustration 1: Diagram of program function and data flow
The contract called for creation of a random access database of plumbing shops within the near perimeter of FIU Engineering school. The database features a rating number from 1-10 to offer a guideline
Data Structures and Algorithms!
Data Structures and Algorithms! The material for this lecture is drawn, in part, from! The Practice of Programming (Kernighan & Pike) Chapter 2! 1 Motivating Quotation!!! Every program depends on algorithms
Algorithms and Data Structures Exercise for the Final Exam (17 June 2014) Stack, Queue, Lists, Trees, Heap
Algorithms and Data Structures Exercise for the Final Exam (17 June 2014) Stack, Queue, Lists, Trees, Heap Singly linked list (1) Data about exam results are stored into a singly linked list. Each list
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
C Interview Questions
http://techpreparation.com C Interview Questions And Answers 2008 V i s i t T e c h P r e p a r a t i o n. c o m f o r m o r e i n t e r v i e w q u e s t i o n s a n d a n s w e r s C Interview Questions
Lecture Notes on Binary Search Trees
Lecture Notes on Binary Search Trees 15-122: Principles of Imperative Computation Frank Pfenning Lecture 17 March 17, 2010 1 Introduction In the previous two lectures we have seen how to exploit the structure
ADTs,, Arrays, Linked Lists
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
Lecture 22: C Programming 4 Embedded Systems
Lecture 22: C Programming 4 Embedded Systems Today s Goals Basic C programming process Variables and constants in C Pointers to access addresses Using a High Level Language High-level languages More human
Numerical Algorithms Group
Title: Calling C Library DLLs from C# Utilizing legacy software Summary: For those who need to utilize legacy software, we provide techniques for calling unmanaged code written in C from C#. The.NET framework
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
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. 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,
Object Oriented Software Design II
Object Oriented Software Design II Introduction to C++ Giuseppe Lipari http://retis.sssup.it/~lipari Scuola Superiore Sant Anna Pisa February 20, 2012 G. Lipari (Scuola Superiore Sant Anna) C++ Intro February
1 Abstract Data Types Information Hiding
1 1 Abstract Data Types Information Hiding 1.1 Data Types Data types are an integral part of every programming language. ANSI-C has int, double and char to name just a few. Programmers are rarely content
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
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
CS107L Handout 04 Autumn 2007 October 19, 2007 Custom STL-Like Containers and Iterators
CS107L Handout 04 Autumn 2007 October 19, 2007 Custom STL-Like Containers and Iterators This handout is designed to provide a better understanding of how one should write template code and architect iterators
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
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
The Advantages of Dan Grossman CSE303 Spring 2005, Lecture 25
CSE 303: Concepts and Tools for Software Development Dan Grossman Spring 2005 Lecture 25 Memory-Management Idioms Dan Grossman CSE303 Spring 2005, Lecture 25 1 No tools or rule today Review: Java and C
ECS 165B: Database System Implementa6on Lecture 2
ECS 165B: Database System Implementa6on Lecture 2 UC Davis, Spring 2011 Por6ons of slides based on earlier ones by Raghu Ramakrishnan, Johannes Gehrke, Jennifer Widom, Bertram Ludaescher, and Michael Gertz.
Pseudo code Tutorial and Exercises Teacher s Version
Pseudo code Tutorial and Exercises Teacher s Version Pseudo-code is an informal way to express the design of a computer program or an algorithm in 1.45. The aim is to get the idea quickly and also easy
EE2204 DATA STRUCTURES AND ALGORITHM (Common to EEE, EIE & ICE)
EE2204 DATA STRUCTURES AND ALGORITHM (Common to EEE, EIE & ICE) UNIT I LINEAR STRUCTURES Abstract Data Types (ADT) List ADT array-based implementation linked list implementation cursor-based linked lists
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
List, Stack and Queue. Tom Chao Zhou CSC2100B Data Structures Tutorial 3
List, Stack and Queue Tom Chao Zhou CSC2100B Data Structures Tutorial 3 Outline Structure Linked List Overview Implementation Stack Overview Implementation Queue Overview Implementation Structure A collection
MS SQL Performance (Tuning) Best Practices:
MS SQL Performance (Tuning) Best Practices: 1. Don t share the SQL server hardware with other services If other workloads are running on the same server where SQL Server is running, memory and other hardware
Object-Oriented Design Lecture 4 CSU 370 Fall 2007 (Pucella) Tuesday, Sep 18, 2007
Object-Oriented Design Lecture 4 CSU 370 Fall 2007 (Pucella) Tuesday, Sep 18, 2007 The Java Type System By now, you have seen a fair amount of Java. Time to study in more depth the foundations of the language,
The following themes form the major topics of this chapter: The terms and concepts related to trees (Section 5.2).
CHAPTER 5 The Tree Data Model There are many situations in which information has a hierarchical or nested structure like that found in family trees or organization charts. The abstraction that models hierarchical
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
Chapter 5 Names, Bindings, Type Checking, and Scopes
Chapter 5 Names, Bindings, Type Checking, and Scopes Chapter 5 Topics Introduction Names Variables The Concept of Binding Type Checking Strong Typing Scope Scope and Lifetime Referencing Environments Named
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
Unix Security Technologies. Pete Markowsky <peterm[at] ccs.neu.edu>
![Unix Security Technologies. Pete Markowsky <peterm[at] ccs.neu.edu>](/thumbs/32/15517621.jpg "Unix Security Technologies. Pete Markowsky <peterm[at] ccs.neu.edu>")
Unix Security Technologies Pete Markowsky What is this about? The goal of this CPU/SWS are: Introduce you to classic vulnerabilities Get you to understand security advisories Make
5 Arrays and Pointers
5 Arrays and Pointers 5.1 One-dimensional arrays Arrays offer a convenient way to store and access blocks of data. Think of arrays as a sequential list that offers indexed access. For example, a list of
ECE 250 Data Structures and Algorithms MIDTERM EXAMINATION 2008-10-23/5:15-6:45 REC-200, EVI-350, RCH-106, HH-139
ECE 250 Data Structures and Algorithms MIDTERM EXAMINATION 2008-10-23/5:15-6:45 REC-200, EVI-350, RCH-106, HH-139 Instructions: No aides. Turn off all electronic media and store them under your desk. If
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
Unit 1. 5. Write iterative and recursive C functions to find the greatest common divisor of two integers. [6]
![Unit 1. 5. Write iterative and recursive C functions to find the greatest common divisor of two integers. [6]](/thumbs/40/21353973.jpg "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
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.
Semantic Analysis: Types and Type Checking
Semantic Analysis Semantic Analysis: Types and Type Checking CS 471 October 10, 2007 Source code Lexical Analysis tokens Syntactic Analysis AST Semantic Analysis AST Intermediate Code Gen lexical errors
Embedded Programming in C/C++: Lesson-1: Programming Elements and Programming in C
Embedded Programming in C/C++: Lesson-1: Programming Elements and Programming in C 1 An essential part of any embedded system design Programming 2 Programming in Assembly or HLL Processor and memory-sensitive
Basic Data Structures and Algorithms
Tutorial 3 Basic Data Structures and Algorithms THINGS TO LOOK FOR 3.0 INTRODUCTION 3.1 Array Based Containers Definition and uses of containers. Array and list based containers. Designing and building
Data Structures Using C++
Data Structures Using C++ 1.1 Introduction Data structure is an implementation of an abstract data type having its own set of data elements along with functions to perform operations on that data. Arrays
Industrial Programming
Industrial Programming Systems Programming & Scripting Lecture 11: Systems Programming in C# Industrial Programming 1 Characteristics of System Programming in C# Build algorithms and data structures from
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:
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)
Data Structures and Algorithms
Data Structures and Algorithms CS245-2016S-05 Abstract Data Types and Lists David Galles Department of Computer Science University of San Francisco 05-0: Abstract Data Types Recall that an Abstract Data
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
Scoping (Readings 7.1,7.4,7.6) Parameter passing methods (7.5) Building symbol tables (7.6)
Semantic Analysis Scoping (Readings 7.1,7.4,7.6) Static Dynamic Parameter passing methods (7.5) Building symbol tables (7.6) How to use them to find multiply-declared and undeclared variables Type checking
13 Classes & Objects with Constructors/Destructors
13 Classes & Objects with Constructors/Destructors 13.1 Introduction In object oriented programming, the emphasis is on data rather than function. Class is a way that binds the data & function together.
Lecture 18-19 Data Types and Types of a Language
Lecture 18-19 Data Types and Types of a Language April 29, 2014 Data Types and Types of a Language Data, Data Types and Types Type: Generalities Type Systems and Type Safety Type Equivalence, Coercion
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
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
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
Binary Trees and Huffman Encoding Binary Search Trees
Binary Trees and Huffman Encoding Binary Search Trees Computer Science E119 Harvard Extension School Fall 2012 David G. Sullivan, Ph.D. Motivation: Maintaining a Sorted Collection of Data A data dictionary
KITES TECHNOLOGY COURSE MODULE (C, C++, DS)
KITES TECHNOLOGY 360 Degree Solution www.kitestechnology.com/academy.php info@kitestechnology.com technologykites@gmail.com Contact: - 8961334776 9433759247 9830639522.NET JAVA WEB DESIGN PHP SQL, PL/SQL
Select the Crow s Foot entity relationship diagram (ERD) option. Create the entities and define their components.
Α DESIGNING DATABASES WITH VISIO PROFESSIONAL: A TUTORIAL Microsoft Visio Professional is a powerful database design and modeling tool. The Visio software has so many features that we can t possibly demonstrate
Sample Questions Csci 1112 A. Bellaachia
Sample Questions Csci 1112 A. Bellaachia Important Series : o S( N) 1 2 N N i N(1 N) / 2 i 1 o Sum of squares: N 2 N( N 1)(2N 1) N i for large N i 1 6 o Sum of exponents: N k 1 k N i for large N and k
Linked List as an ADT (cont d.)
Linked List as an ADT (cont d.) Default constructor Initializes list to an empty state Destroy the list Deallocates memory occupied by each node Initialize the list Reinitializes list to an empty state
CS 2412 Data Structures. Chapter 2 Stacks and recursion
CS 2412 Data Structures Chapter 2 Stacks and recursion 1 2.1 Stacks A stack is a data structure in which all insertions and deletions of entries are made at one end, called top of the stack. Examples:
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
Hash Tables. Computer Science E-119 Harvard Extension School Fall 2012 David G. Sullivan, Ph.D. Data Dictionary Revisited
Hash Tables Computer Science E-119 Harvard Extension School Fall 2012 David G. Sullivan, Ph.D. Data Dictionary Revisited We ve considered several data structures that allow us to store and search for data
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
Lecture Notes on Binary Search Trees
Lecture Notes on Binary Search Trees 15-122: Principles of Imperative Computation Frank Pfenning André Platzer Lecture 17 October 23, 2014 1 Introduction In this lecture, we will continue considering associative
How to test and debug an ASP.NET application
Chapter 4 How to test and debug an ASP.NET application 113 4 How to test and debug an ASP.NET application If you ve done much programming, you know that testing and debugging are often the most difficult
Introduction to Object-Oriented Programming
Introduction to Object-Oriented Programming Linked Lists Christopher Simpkins chris.simpkins@gatech.edu CS 1331 (Georgia Tech) Linked Lists 1 / 12 Linked Lists Dynamic data structures Singly linked lists
C++FA 3.1 OPTIMIZING C++
C++FA 3.1 OPTIMIZING C++ Ben Van Vliet Measuring Performance Performance can be measured and judged in different ways execution time, memory usage, error count, ease of use and trade offs usually have
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
Lecture Notes on Stacks & Queues
Lecture Notes on Stacks & Queues 15-122: Principles of Imperative Computation Frank Pfenning, André Platzer, Rob Simmons Lecture 9 February 12, 2013 1 Introduction In this lecture we introduce queues and
Cpt S 223. School of EECS, WSU
Abstract Data Types 1 Topics Abstract Data Types (ADTs) Some basic ADTs: Lists Stacks Queues 2 Primitive Data Type vs. Abstract Data Types Primitive DT: ADT: programmer progra ammer Interface (API) e.g.,
Týr: a dependent type system for spatial memory safety in LLVM
Týr: a dependent type system for spatial memory safety in LLVM Vítor De Araújo Álvaro Moreira (orientador) Rodrigo Machado (co-orientador) August 13, 2015 Vítor De Araújo Álvaro Moreira (orientador) Týr:
COMP 356 Programming Language Structures Notes for Chapter 10 of Concepts of Programming Languages Implementing Subprograms.
COMP 356 Programming Language Structures Notes for Chapter 10 of Concepts of Programming Languages Implementing Subprograms 1 Activation Records activation declaration location Recall that an activation