CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.
-
Upload
stephanie-pierce -
Category
Documents
-
view
219 -
download
0
description
Transcript of CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.
![Page 1: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/1.jpg)
CNG 140C Programming(Lecture set 12)
Spring 2006-2007http://www.ceng.metu.edu.tr/~bozyigit/cng140
Chapter 13Dynamic Data Structures
![Page 2: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/2.jpg)
CNG140 C Programming 2
Objectives
• Introduction to Linked Lists• Dynamic Memory Allocation• Stacks• Queues• Dynamically Linked Lists• Common Programming and Compiler Errors
![Page 3: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/3.jpg)
CNG140 C Programming 3
Introduction
• Dynamic memory allocation: an alternative to fixed memory allocation in which memory space grows or diminishes during program execution
• Dynamic memory allocation makes it unnecessary to reserve a fixed amount of memory for a scalar, array, or structure variable in advance– Also known as run-time allocation– Requests are made for allocation and release of
memory space while the program is running
![Page 4: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/4.jpg)
CNG140 C Programming 4
Introduction to Linked Lists
• An array of structures can be used to insert and delete ordered structures, but this is not an efficient use of memory– Better alternative: a linked list
• Linked list: set of structures, each containing at least one member whose value is the address of the next logically ordered structure in the list– Also known as self-referencing structures
![Page 5: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/5.jpg)
CNG140 C Programming 5
Introduction to Linked Lists (continued)
![Page 6: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/6.jpg)
CNG140 C Programming 6
Introduction to Linked Lists (continued)
![Page 7: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/7.jpg)
CNG140 C Programming 7
Introduction to Linked Lists (continued)
• A NULL acts as a sentinel or flag to indicate when the last structure has been processed
• In addition to an end-of-list sentinel value, we must provide a special pointer for storing the address of the first structure in the list
![Page 8: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/8.jpg)
CNG140 C Programming 8
Introduction to Linked Lists (continued)
![Page 9: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/9.jpg)
CNG140 C Programming 9
A structure can contain any data type, including a pointer. A pointer member of a structure is used like any other pointer variable.
Introduction to Linked List: Pointer Example
![Page 10: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/10.jpg)
CNG140 C Programming 10
is evaluated as (t1.nextaddr)->nameit can be replaced by (*t1.nextaddr).name
Introduction to Linked Lists: Link List Example
![Page 11: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/11.jpg)
CNG140 C Programming 11
Introduction to Linked Lists (continued)
![Page 12: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/12.jpg)
CNG140 C Programming 12
Introduction to Linked Lists (continued)
Disadvantage: exactly three structures are defined in main() by name, and storage for them is reserved at compile time
![Page 13: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/13.jpg)
CNG140 C Programming 13
Introduction to Linked Lists (continued)
can be replaced by while(!contents)
![Page 14: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/14.jpg)
CNG140 C Programming 14
Dynamic Memory Allocation
![Page 15: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/15.jpg)
CNG140 C Programming 15
Dynamic Memory Allocation (continued)
• The malloc() and calloc() functions can frequently be used interchangeably– The advantage of calloc() is that it initializes all
newly allocated numeric memory to 0 and character allocated memory to NULL
– We use malloc() because it is the more general purpose of the two functions
– malloc(10*sizeof(char)) or calloc(10,sizeof(char)) requests enough memory to store 10 characters
• The space allocated by malloc() comes from the computer’s heap
![Page 16: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/16.jpg)
CNG140 C Programming 16
…
Necessary because malloc() returns void
Dynamic Memory Allocation (continued)
![Page 17: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/17.jpg)
CNG140 C Programming 17
Dynamic Memory Allocation (continued)
• malloc() is more typically used for dynamically allocating memory for structuresstruct OfficeInfo *Off;/* request space for one structure */Off = (struct OfficeInfo *) malloc(sizeof(struct OfficeInfo));
/* check that space was allocated */if (Off == (struct OfficeInfo*) NULL){ printf("\nAllocation failed\n"); exit(1);}
![Page 18: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/18.jpg)
CNG140 C Programming 18
Example: Structure and Dynamic memory allocation
• This listing uses a structure type PersonalData and dynamic memory allocation
![Page 19: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/19.jpg)
CNG140 C Programming 19
Example/*********************************************************//* *//* Structures Demo *//* *//*********************************************************/ /* Simple program to initialize some structures */ /* and to print them out again. Does no error */ /* checking, so be wary of string sizes etc.. */
#include <stdio.h>
#define NAMESIZE 30#define ADDRSIZE 80#define NOOFPERSONS 20#define NEWLINE() putchar('\n');
![Page 20: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/20.jpg)
CNG140 C Programming 20
Example: cont.
/*********************************************************/
typedef struct { char *Name; char *Address; int YearOfBirth; int MonthOfBirth; int DayOfBirth; } PersonDat;
/*********************************************************/
![Page 21: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/21.jpg)
CNG140 C Programming 21
Example : cont.main () /* Make some records */{ PersonDat record[NOOFPERSONS]; PersonDat PersonalDetails(); int person;printf ("Birth Records For Employees");printf ("\n---------------------------");printf ("\n\n");printf ("Enter data\n");for (person = 0; person < NOOFPERSONS; person++) { record[person] = PersonalDetails(); NEWLINE(); }DisplayRecords (record);}
![Page 22: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/22.jpg)
CNG140 C Programming 22
Example : cont./*********************************************************/PersonDat PersonalDetails() /* No error checking! */{ PersonDat dat;
char strbuff[ADDRSIZE], *malloc();printf ("Name :");dat.Name = malloc(NAMESIZE);strcpy (dat.Name,gets(strbuff));printf ("Address :");dat.Address = malloc(ADDRSIZE);strcpy (dat.Address,gets(strbuff));printf ("Year of birth:");dat.YearOfBirth = getint (1900,2007);printf ("Month of birth:");dat.MonthOfBirth = getint (1,12);printf ("Day of birth:");dat.DayOfBirth = getint(1,31);return (dat);
}
![Page 23: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/23.jpg)
CNG140 C Programming 23
Example : cont./**********************************************************/DisplayRecords (rec)PersonDat rec[NOOFPERSONS];{ int pers;
for (pers = 0; pers < NOOFPERSONS; pers++) { printf ("Name : %s\n", rec[pers].Name); printf ("Address : %s\n", rec[pers].Address); printf("Date of Birth: %1d/%1d/%1d\n",rec[pers].DayOfBirth, rec[pers].MonthOfBirth,rec[pers].YearOfBirth); NEWLINE(); }}
![Page 24: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/24.jpg)
CNG140 C Programming 24
Example : cont./* Toolkit */getint (a,b) /* return int between a and b */int a,b;{ int p, i = a - 1;for (p=0; ((a > i) || (i > b)); p++) { printf ("? : "); scanf ("%d",&i);
}return (i);}
![Page 25: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/25.jpg)
CNG140 C Programming 25
Stacks
• Stack: special type of linked list in which objects can only be added to and removed from the top of the list– Last-in, first-out (LIFO) list
• In a true stack, the only item that can be seen and accessed is the top item
![Page 26: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/26.jpg)
CNG140 C Programming 26
Stacks (continued)
![Page 27: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/27.jpg)
CNG140 C Programming 27
Stack Implementation
• Creating a stack requires the following four components:– A structure definition– A method of designating the current top stack
structure– An operation for placing a new structure on the stack– An operation for removing a structure from the stack
![Page 28: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/28.jpg)
CNG140 C Programming 28
PUSH and POP
PUSH (add a new structure to the stack) Dynamically create a new structure Put the address in the top-of-stack pointer into the address
field of the new structure Fill in the remaining fields of the new structure Put the address of the new structure into the top-of-stack
pointerPOP (remove a structure from the top of the stack) Move the structure contents pointed to by the top-of-stack
pointer into a work area Free the structure pointed to by the top-of-stack pointer Move the address in the work area address field into the top-
of-stack pointer
![Page 29: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/29.jpg)
CNG140 C Programming 29
PUSH and POP (continued)
![Page 30: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/30.jpg)
CNG140 C Programming 30
PUSH and POP (continued)
![Page 31: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/31.jpg)
CNG140 C Programming 31
PUSH and POP (continued)
![Page 32: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/32.jpg)
CNG140 C Programming 32
PUSH and POP (continued)
![Page 33: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/33.jpg)
CNG140 C Programming 33
PUSH and POP (continued)
• A sample run using Program 13.5 produced the following:
Enter as many names as you wish, one per lineTo stop entering names, enter a single xEnter a name: Jane JonesEnter a name: Bill SmithEnter a name: Jim RobinsonEnter a name: x
The names popped from the stack are:Jim RobinsonBill SmithJane Jones
![Page 34: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/34.jpg)
CNG140 C Programming 34
Queues
• A second important data structure that relies on linked structures is called a queue– Items are removed from a queue in the order in
which they were entered– It is a first in, first out (FIFO) structure
![Page 35: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/35.jpg)
CNG140 C Programming 35
Queues (continued)
![Page 36: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/36.jpg)
CNG140 C Programming 36
Queues (continued)
![Page 37: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/37.jpg)
CNG140 C Programming 37
Enque and Serve
• Enqueueing: placing a new item on top of the queue
• Serving or dequeing: removing an item from a queue
![Page 38: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/38.jpg)
CNG140 C Programming 38
Enque and Serve (continued)
![Page 39: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/39.jpg)
CNG140 C Programming 39
Enque and Serve (continued)
Enqueue (add a new structure to an existing queue) Dynamically create a new a structure Set the address field of the new structure to a NULL Fill in the remaining fields of the new structure Set the address field of the prior structure (which is
pointed to by the queueIn pointer) to the address of the newly created structure
Update the address in the queueIn pointer with the address of the newly created structure
![Page 40: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/40.jpg)
CNG140 C Programming 40
Enque and Serve (continued)
![Page 41: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/41.jpg)
CNG140 C Programming 41
Enque and Serve (continued)
Serve (remove a structure from an existing queue) Move the contents of the structure pointed to by the
queueOut pointer into a work area Free the structure pointed to by the queueOut
pointer Move the address in the work area address field into
the queueOut pointer
![Page 42: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/42.jpg)
CNG140 C Programming 42
Enque and Serve (continued)
![Page 43: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/43.jpg)
CNG140 C Programming 43
Enque and Serve (continued)
![Page 44: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/44.jpg)
CNG140 C Programming 44
Enque and Serve (continued)
![Page 45: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/45.jpg)
CNG140 C Programming 45
Enque and Serve (continued)
![Page 46: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/46.jpg)
CNG140 C Programming 46
Enque and Serve (continued)
![Page 47: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/47.jpg)
CNG140 C Programming 47
Enque and Serve (continued)
• A sample run using Program 13.6 produced the following:Enter as many names as you wish, one per lineTo stop entering names, enter a single xEnter a name: Jane JonesEnter a name: Bill SmithEnter a name: Jim RobinsonEnter a name: x
The names served from the queue are:Jane JonesBill SmithJim Robinson
![Page 48: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/48.jpg)
CNG140 C Programming 48
Dynamically Linked Lists
• Both stacks and queues are examples of linked lists in which elements can only be added to and removed from the ends of the list
• In a dynamically linked list, this capability is extended to permit adding or deleting a structure from anywhere within the list
• Such a capability is extremely useful when structures must be kept within a specified order
![Page 49: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/49.jpg)
CNG140 C Programming 49
Common Programming Errors
• Not checking the return codes provided by malloc() and realloc()
• Not correctly updating all relevant pointer addresses when adding or removing structures from dynamically created stacks, queues, and linked lists
• Forgetting to free previously allocated memory space when the space is no longer needed
![Page 50: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/50.jpg)
CNG140 C Programming 50
Common Programming Errors (continued)
• Not preserving the integrity of the addresses contained in the top-of-stack pointer, queue-in, queue-out, and list pointer when dealing with a stack, queue, and dynamically linked list, respectively
• Related to the previous error is the equally disastrous one of not correctly updating internal structure pointers when inserting and removing structures from a stack, queue, or dynamically linked list
![Page 51: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/51.jpg)
CNG140 C Programming 51
Common Compiler Errors
![Page 52: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/52.jpg)
CNG140 C Programming 52
Common Compiler Errors (continued)
![Page 53: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/53.jpg)
CNG140 C Programming 53
Summary
• An alternative to fixed memory allocation for variables at compile time is the dynamic allocation of memory at run time
• malloc() reserves a requested number of bytes and returns a pointer to the first reserved byte
• realloc() operates in a similar fashion as malloc() except it is used to expand or contract an existing allocated space
• free() is used to deallocate previously allocated memory space
![Page 54: CNG 140 C Programming (Lecture set 12) Spring 2006-2007 Chapter 13 Dynamic Data Structures.](https://reader034.fdocuments.in/reader034/viewer/2022051303/5a4d1b567f8b9ab0599a997b/html5/thumbnails/54.jpg)
CNG140 C Programming 54
Summary (continued)
• A stack is a list consisting of structures that can only be added and removed from the top of the list
• A queue is a list consisting of structures that are added to the top of the list and removed from the bottom of the list
• A dynamically linked list consists of structures that can be added or removed from any position in the list