Lectures on data structures and C 3ed CS(CSI33) By, CHANDRASHEKAR A.M.

Lectures on data structures and C 3ed CS(CSI33) By, CHANDRASHEKAR A.M.

Data Structures and Algorithms
Programs. Different problems. Operations. Size of data. Resources available. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE
Overview of Lecture Basic data structures. How to manipulate them. How to implement them. Other algorithms and how to implement them. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

This Lecture - Review Basic C data types Boolean 1D and multidimensional arrays Strings Input/Output File I/O Structures and typedef copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Basic Data types in C int char float double copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Boolean Has two values, true and false. In C we use integers as Booleans. Zero represents false. Any non-zero integer represents true. The library <stdbool.h> contains definition for bool, true, and false. (This doesn’t work in Borland) In Borland programs, use #define to define the constants true and false copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#include <stdbool.h>
bool leapYear(int year) { if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) ) return true; } else return false;

For Borland use #define or const int
#define true 1 #define false 0 int leapYear(int year) { if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) ) return true; } else return false;

Recall: File inclusion header #include <stdbool.h>
bool leapYear(int year) { if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) ) return true; } else return false; File inclusion header

Recall: Function definition #include <stdbool.h>

Recall: Function name #include <stdbool.h>

Recall: Function return type
#include <stbool.h> bool leapYear(int year) { if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) ) return true; } else Must be compatible with the function’s return type

Recall: Function parameter Parameter type #include <stdbool.h>
bool leapYear(int year) { if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) ) return true; } else return false; Function parameter Parameter type

Recall: Function call int main() { int year, month, day;
printf(“Enter year, month and day: ”); scanf(“%d %d %d”, &year, &month, &day); day = dayOfYear(year, month, day); printf(“\nDay of Year = %d\n”, day); } Function call

Review - Arrays (1D) array1D: 1 N - 1 All the elements are of the same type. An element: array1D[index] In C, the first element has index 0 (zero). copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Review - Multidimensional Arrays
array2D: Arrays of arrays. All the elements are of the same type. An element: array2D[row][column] copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

int dayTable[2][13] = { {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} }; int dayOfYear(int year, int month, int day) { int i; int isLeap = leapYear(year); for (i = 1; i < month; i++) { day += dayTable[isLeap][i]; } return day;

Recall: Global variable Local variable int dayTable[2][13] = {
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} }; int dayOfYear(int year, int month, int day) { int i; int isLeap = leapYear(year); for (i = 1; i < month; i++) { day += dayTable[isLeap][i]; } return day; Global variable Local variable

Recall: 2-dimensional array of int int dayTable[2][13] = {
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} }; int dayOfYear(int year, int month, int day) { int i; int isLeap = leapYear(year); for (i = 1; i < month; i++) { day += dayTable[isLeap][i]; } return day; 2-dimensional array of int

Recall: Index goes from 0 to 12 int dayTable[2][13] = {
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} }; int dayOfYear(int year, int month, int day) { int i; int isLeap = leapYear(year); for (i = 1; i < month; i++) { day += dayTable[isLeap][i]; } return day; Index goes from 0 to 12

Review – Input/Output Input/Output is done via streams
Uses the library stdio.h Streams that are available in the library are stdin (keyboard), stdout and stderr (screen). These can be redirected. Data is written to stdout using the printf() function. printf("%s\n%f\n%c\n%d\n", name, age, gender, idNumber); Data is read in from stdin using the scanf() function. scanf("%s %f %c %d", name, &age, &gender, &idNumber); Format control string Variables containing data to be printed copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE Conversion specifiers Pointers to variables where input will be stored

Review – Input/Output scanf() returns the number of values successfully read and converted or returns a special value EOF when input ends. Note for when reading a single character (%c): if there is a \n character left in the buffer from reading another value (%d) then that \n will be read into your character variable. Conversion specifiers: i or d: display a signed decimal integer f: display a floating point value e or E: display a floating point value in exponential notation g or G: display a floating point value in either f form or e form L: placed before any float conversion specifier to indicate that a long double is displayed copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Note: no ampersand for strings
#include <stdio.h> int main() { int day; int month; int year; char name[30]; printf(“Enter your name:\n”> scanf(“%s”, name); /* skipping spaces */ printf(“Hi %s. Enter birthdate as: dd mm yyyy\n”, name); scanf("%d %d %d", &day, &month, &year); /* alternative */ printf(“Hi %s. Enter birthdate as: dd-mm-yyyy\n”, name); scanf("%d-%d-%d", &day, &month, &year); return 0; } Note: no ampersand for strings Conversion specifier Literal characters

Review - Strings Strings : array of characters Example: char name[30];
Unlike other arrays, strings require an end-of-string character : ‘\0’ String functions you will use from the string.h library include: Length - strlen(string1) Assignment - strcpy(dest, source) Concatenation - strcat(dest, string2) Comparison - strcmp(string1, string2) Max length including ‘\0’ Copies string2 onto the end of the destination string Returns: positive if string1 sorts after string2, 0 if they are the same string negative if string1 sorts before string2 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

string2 needs to be the same length as string 1
#include <stdio.h> #include <string.h> #define MAXLENGTH 100 int main() { char string1[MAXLENGTH]; char string2[MAXLENGTH]; strcpy(string1, “Hello World!”); strcpy(string2, string1); length = strlen(string1); printf(“length of string1 = %d\n”, length); strcpy(string1, “Apple”); strcpy(string2, “Orange”); string1 needs to fit the number of characters of the second string, +1 for the ‘\0’ character string2 needs to be the same length as string 1

sscanf(string1, “%d”, int1);
Prints the order which the two strings sort, alphabetically. if (strcmp(string1, string2) < 0) { printf(“%s %s\n”, string1, string2); } else if (strcmp(string1, string2) == 0) printf(“The strings are the same.\n”); else printf(“%s %s\n”, string2, string1); strcat(string1, “ juice”); printf(“%s\n”, string1); return 0; Note: To scan within a string use: sscanf(string1, “%d”, int1);

Review -File Handling in C
Files need to be opened before use. Associate a "file handler" to each file Modes: read, write, or append File input/output functions use the file handler (not the filename). Need to check the file opened sucessfully. Need to close the file after use. Basic file handling functions: fopen(), fclose(), fscanf(), fprintf(), fgets(). copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

fopen() returns NULL if an error occurs
Associate a file handler for every file to be used. #include <stdio.h> #define MAXLEN 100 int main() { FILE *inputfile = NULL; FILE *outputfile = NULL; char name[MAXLEN]; int count; float mark; inputfile = fopen(“Names.txt”, “r”); outputfile = fopen(“marks.dat”, “w”); if (inputfile == NULL) printf(“Unable to open input file.\n”); return 1; } if (outputfile == NULL) printf(“Unable to open output file.\n”); Mode r : read w : write a : append fopen() returns NULL if an error occurs

fscanf() returns the number of values read and converted
count = 0; while ( fscanf(inputfile, "%s", name ) == 1 ) { count++; printf("Enter mark for %s: \n", name); scanf("%f", &mark); if ( fprintf(outputfile, "%s %f\n", name, mark) <= 0 ) printf("Error writing to output file.\n"); return 1; } printf("\n"); printf("Number of names read: %d\n", count); fclose(inputfile); fclose(outputfile); return 0; fprintf() returns the number of successfully written or negative if an error occurs

fgets(string, length, filehandle)
To read in a line, use fgets(). fgets() returns NULL if end of file is reached. #include <stdio.h> #define MAXLEN 100 int main() { FILE *inputfile = NULL; char line[MAXLEN]; int count = 0; inputfile = fopen(“Names.txt”, “r”); if (inputfile == NULL) printf(“Unable to open input file.\n”); return 1; } while(fgets(line, MAXLEN, inputfile) != NULL) count++; printf(“Number of lines: %d”, count); fclose(inputfile); return 0; fgets(string, length, filehandle) What would happen if you tried to count the number of lines again, once the end of the file has been reached?

structname.membername
Review - struct structname: Members may have different types. structname.membername structs are also known as “records,” and members as “fields” copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Review - typedef Gives a new name to a type that has already been defined. E.g. typedef struct StudentRec Student; Saves typing struct whatever everywhere. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example : #include <stdio.h> #define MAXNAME 80
struct StudentRec { char name[MAXNAME]; int mark; }; typedef struct StudentRec Student;

Recall: Macro substitution #include <stdio.h> #define MAXNAME 80
struct StudentRec { char name[MAXNAME]; int mark; }; typedef struct StudentRec Student; Macro substitution

Recall: Structure declaration #include <stdio.h>
#define MAXNAME 80 struct StudentRec { char name[MAXNAME]; int mark; }; typedef struct StudentRec Student; Structure declaration

Recall: Structure name / tag Members Don’t forget this!
#include <stdio.h> #define MAXNAME 80 struct StudentRec { char name[MAXNAME]; int mark; }; typedef struct StudentRec Student; Structure name / tag Members Don’t forget this!

Recall: Data type New type name #include <stdio.h>
#define MAXNAME 80 struct StudentRec { char name[MAXNAME]; int mark; }; typedef struct StudentRec Student; Data type New type name

Student readStudent(void)
{ Student next; scanf(“%s %d”, next.name, &next.mark); return next; } void printStudent(Student student) { printf(“%s %d\n”, student.name, student.mark);

Recall: An instance of the struct A member of a struct variable
Student readStudent(void) { Student next; scanf(“%s %d”, next.name, &next.mark); return next; } void printStudent(Student student) { printf(“%s %d\n”, student.name, student.mark); An instance of the struct A member of a struct variable “Package”

#define MAXCLASS 100 main() { Student class[MAXCLASS]; int n, i, best = 0; printf(“Enter number of students: ”); scanf(“%d”, &n); for (i = 0; i < n; i++) { class[i] = readStudent(); if (class[best].mark < class[i].mark) { best = i; } printf(“Best student is: ”); printStudent(class[best]);

Recall: Array of instances of structs Assignment
#define MAXCLASS 100 main() { Student class[MAXCLASS]; int n, i, best = 0; printf(“Enter number of students: ”); scanf(“%d”, &n); for (i = 0; i < n; i++) { class[i] = readStudent(); if (class[best].mark < class[i].mark) { best = i; } printf(“Best student is: ”); printStudent(class[best]); Array of instances of structs Recall: Assignment Member of an array element

Revision Basic Data Types and booleans I/O and File I/O Arrays and Structs Strings Typedef Preparation Next lecture: Pointers copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview Revision of Pointers Basic Pointer Arithmetic Pointers and Arrays copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Pointers A pointer is a datatype. You can create variables of this type as you would of other types. Contains a memory address. Points to a specific data type. int *pointer1 = &x; int x; addr of x 0x2000 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE 0x9060

Pointer Operations Type object; Type* aPtr; aPtr = &object assigns the address of object to aPtr. *aPtr allows access to the object through the pointer. If aPtr points to a structure then (*aPtr).member is equivalent to aPtr-> member copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Pointers and Function Arguments
swap x: 1 y: 2 x: 2 y: 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Solution 1 #include <stdio.h> void fakeSwap(int a, int b) {
int tmp; tmp = a; a = b; b = tmp; } int main() int x = 1, y = 2; fakeSwap(x, y); printf(“%d %d\n”, x, y); Solution 1

int tmp; tmp = a; a = b; b = tmp; } int main() int x = 1, y = 2; fakeSwap(x, y); printf(“%d %d\n”, x, y); Solution 1 x: 1 0x2000 y: 2 0x2010

int tmp; tmp = a; a = b; b = tmp; } int main() int x = 1, y = 2; fakeSwap(x, y); printf(“%d %d\n”, x, y); Solution 1 tmp: 0x2060 a: 1 0x2038 b: 2 0x2040 x: 1 0x2000 y: 2 0x2010

int tmp; tmp = a; a = b; b = tmp; } int main() int x = 1, y = 2; fakeSwap(x, y); printf(“%d %d\n”, x, y); Solution 1 tmp: 1 0x2060 a: 1 0x2038 b: 2 0x2040 x: 1 0x2000 y: 2 0x2010

int tmp; tmp = a; a = b; b = tmp; } int main() int x = 1, y = 2; fakeSwap(x, y); printf(“%d %d\n”, x, y); Solution 1 x: 1 0x2000 y: 2 0x2010

Solution 2 #include <stdio.h> void trueSwap(int* a, int* b) {
int tmp; tmp = *a; *a = *b; *b = tmp; } int main() int x = 1, y = 2; trueSwap(&x, &y); printf(“%d %d\n”, x, y); Solution 2

int tmp; tmp = *a; *a = *b; *b = tmp; } int main() int x = 1, y = 2; trueSwap(&x, &y); printf(“%d %d\n”, x, y); Solution 2 x: 1 0x2000 y: 2 0x2010

int tmp; tmp = *a; *a = *b; *b = tmp; } int main() int x = 1, y = 2; trueSwap(&x, &y); printf(“%d %d\n”, x, y); Solution 2 tmp: 0x2060 a: addr of x 0x2038 b: addr of y 0x2040 x: 1 0x2000 y: 2 0x2010

int tmp; tmp = *a; *a = *b; *b = tmp; } int main() int x = 1, y = 2; trueSwap(&x, &y); printf(“%d %d\n”, x, y); Solution 2 tmp: 1 0x2060 a: addr of x 0x2038 b: addr of y 0x2040 x: 1 0x2000 y: 2 0x2010

int tmp; tmp = *a; *a = *b; *b = tmp; } int main() int x = 1, y = 2; trueSwap(&x, &y); printf(“%d %d\n”, x, y); Solution 2 x: 2 0x2000 y: 1 0x2010

More on Pointers You can print the address stored in a pointer using the %p conversion specifier Example: printf(“%p”, numPtr); scanf needs to know where to put the value - it needs the address of the variable as it takes pointers as parameters. Example: int i; scanf(“%d”, &i); copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

/* Very Large Structure */
struct DataBaseRec { }; typedef struct DataBaseRec DataBase; /* Very Large Structure */ copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

DataBase readNewEntry(DataBase theDataBase) { return theDataBase; } void printDataBase(DataBase theDataBase) /* Some code */ /* Some more code */ copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void readNewEntry(DataBase* dataBasePtr) { } printDataBase(const DataBase* dataBasePtr) /* Some code */ /* Some more code */ copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void readNewEntry(DataBase* dataBasePtr) { } printDataBase(const DataBase* dataBasePtr) (DataBase* /* Some code */ Address of Database Database* /* Some more code */ copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void readNewEntry(DataBase* dataBasePtr) { } printDataBase(const DataBase* dataBasePtr) /* Some code */ Database cannot change in this function. const /* Some more code */ copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

int readstudent(Student *student) { printf(“Enter a name: \n”); if (scanf(“%s”, student->name) == 1) printf(“Enter a mark: \n); if (scanf(“%d”, &(student->mark)) == 1) return 1; } return 0; Why do you need the brackets? copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Pointers and Functions
To enable a function to access and change an object. For large structures it is more efficient. Use const specifier whenever a constant is intended. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Pointers and Arrays Type array[size]; Type* pPtr = array + i; Type* qPtr = array + j; The name array is equivalent to &array[0] pPtr++ increments pPtr to point to the next element of array. pPtr += n increments pPtr to point to n elements beyond where it currently points. pPtr-qPtr equals i-j. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Pointers and Arrays (cont)
A normal 1 dimensional array: Type array[size]; array[0] is equivalent to *array array[n] is equivalent to *(array + n) copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Basic Pointer Arithmetic
float array[5]; float* pPtr = array; float* qPtr = NULL; 0x2008 0x2004 array: pPtr: 0x200C 0x2010 0x2014 0x2018 1 2 3 4 NULL 0x2000 qPtr: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

0x2008 0x200C 0x2010 0x2014 0x2018 array: 0x2008 1 2 3 4 pPtr: qPtr: 0x200C NULL 0x2004 0x2000 float array[5]; float* pPtr = array; float* qPtr = NULL; pPtr++; /* pPtr now holds the address: &array[1] */ copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

0x2008 0x200C 0x2010 0x2014 0x2018 array: 0x2008 1 2 3 4 pPtr: qPtr: 0x2018 NULL 0x2004 0x2000 float array[5]; float* pPtr = array; float* qPtr = NULL; pPtr++; /* pPtr = &array[1] */ pPtr += 3; /* pPtr now hold the address: &array[4] */ copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

0x2008 0x200C 0x2010 0x2014 0x2018 array: 0x2008 1 2 3 4 pPtr: qPtr: 0x2018 0x2010 0x2004 0x2000 float array[5]; float* pPtr = array; float* qPtr = NULL; pPtr++; /* pPtr = &array[1] */ pPtr += 3; /* pPtr = &array[4] */ qPtr = array + 2; /*qPtr now holds the address &array[2]*/ copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

0x2008 0x200C 0x2010 0x2014 0x2018 array: 0x2008 1 2 3 4 pPtr: qPtr: 0x2018 0x2010 0x2004 0x2000 float array[5]; float* pPtr = array; float* qPtr = NULL; pPtr++; /* pPtr = &array[1] */ pPtr += 3; /* pPtr = &array[4] */ qPtr = array + 2; /* qPtr = &array[2] */ printf(“%d\n”, pPtr-qPtr); copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

char* strcpy(char* s, char* t) { int i = 0; while (t[i] != 0) s[i] = t[i]; i++; } return s; char* strcpy(char* s, char* t) { char* p = s; while (*p != 0) *p = *t; p++; t++; } return s;

Revision Pointers Pointer Operations address operator (&), and dereferencing operator (*) Pointers and Structures. structure pointer operator (->) Pointers and Function Arguments. Look at “swap” example Pointer Arithmetic Pointers and Arrays copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Next Lecture Stacks abstract data type main operations implementation copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Basic Data Structures Stacks Queues Lists copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview of Stacks What is a Stack? Operations on a Stack push, pop initialize status: empty, full Implementation of a Stack. Example: Reversing a sequence. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

A Stack Items on the Stack Top copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Push Top After Top Before copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

This comes off the stack Pop Top Before After Top copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Operations Initialize the Stack. Pop an item off the top of the stack. Push an item onto the top of the stack. Is the Stack empty? Is the Stack full? Clear the Stack Determine Stack Size copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Stack Properties Sequence of items, where insertions and deletions are done at the top. Main operations are pop and push. Last-In First Out (LIFO). Used when calling functions. Used when implementing recursion. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Implementation array (upside-down) 1 2 : Top index copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Implementation : float entry[MAXSTACK]; 2 Top 1 int top; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#ifndef STACK.H #define STACK.H #include <stdbool.h> #define MAXSTACK 20 struct StackRec { int top; float entry[MAXSTACK]; }; typedef struct StackRec Stack; void intializeStack(Stack* stackPtr); bool stackEmpty(const Stack* stackPtr); bool stackFull(const Stack* stackPtr); void push(Stack* stackPtr, float item); float pop(Stack* stackPtr); #endif copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Stack: #define MAXSTACK 20 struct StackRec { int top; float entry[MAXSTACK]; }; typedef struct StackRec Stack; top: entry: . copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#include <stdio.h> #include <stdlib.h> #include “stack.h” void initializeStack(Stack* stackPtr) { stackPtr -> top = -1; } top: . entry: Stack: addr of Stack stackPtr: -1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

bool stackEmpty(const Stack* stackPtr) { if (stackPtr-> top < 0) return true; } else return false; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

bool stackFull(const Stack* stackPtr) { if (stackPtr -> top >= MAXSTACK-1) return true; } else return false; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void push(Stack* stackPtr, float item) { if (stackFull(stackPtr)) fprintf(stderr, “Stack is full\n”); exit(1); } else stackPtr-> top++; stackPtr-> entry[stackPtr-> top] = item; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

float pop(Stack* stackPtr) { float item; if (stackEmpty(stackPtr)) fprintf(stderr, “Stack is empty\n”); exit(1); } else item = stackPtr-> entry[stackPtr-> top]; stackPtr-> top--; return item; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#include <stdio.h> #include “stack.h” int main() { Stack theStack; float next; initializeStack(&theStack); printf(“Enter number sequence: ”); while (scanf(“%f”, &next) != EOF) { if (!stackFull(&theStack)) { push(&theStack, next); } while (!stackEmpty(&theStack)) { next = pop(&theStack); printf(“%f”, next); printf(“\n”); copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Revision Stack Operations on a Stack push, pop initialize status: empty, full others: clear, size Implementation. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Next Lecture Queue Main Operations Implementation copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Basic Data Structures Stacks Queues Lists copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview What is a Queue? Queue Operations. Applications. Linear Implementation. Circular Implementation. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert Before Front Rear After Front Rear copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Delete Before Front Rear After Front Rear This comes off the queue copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Operations Initialize the queue. Append an item to the rear of the queue. Serve an item from the front of the queue. Is the queue empty? Is the queue full? What size is the queue? copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Applications In operating systems, e.g. printer queues, process queues, etc. Simulation programs. Algorithms. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linear Implementation
1 2 3 4 5 6 7 Front Rear copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert 1 2 3 4 5 6 7 Front Rear copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Delete 1 2 3 4 5 6 7 Front Rear This comes off the queue copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert 1 2 3 4 5 6 7 Front Rear copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert 1 2 3 4 5 6 7 Front Rear NO SPACE HERE copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert 1 2 3 4 5 6 7 Front Rear SPACE HERE copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Circular Implementation
7 6 1 5 2 4 3 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Circular Implementation
1 2 3 4 5 6 7 Front Rear copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert 1 2 3 4 5 6 7 Rear Front copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#ifndef QUEUE.H #define QUEUE.H #include <stdbool.h> #define MAXQUEUE 20 struct QueueRec { int count; int front; int rear; float entry[MAXQUEUE]; }; typedef struct QueueRec Queue; void intializeQueue(Queue* queuePtr); bool queueEmpty(const Queue* queuePtr); bool queueFull(const Queue* queuePtr); void append(Queue* queuePtr, float item); float serve(Queue* queuePtr); #endif copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Queue: #define MAXQUEUE 20 struct QueueRec { int count; int front; int rear; float entry[MAXQUEUE]; }; typedef struct QueueRec Queue; count: front: rear: entry: . copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#include <stdio.h> #include <stdlib.h> #include “queue.h” void initializeQueue(Queue* queuePtr) { queuePtr -> count = 0; queuePtr -> front = 0; queuePtr -> rear = MAXQUEUE-1; } Queue: count: front: queuePtr: addr of Queue 19 rear: entry: . copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

bool queueEmpty(const Queue* queuePtr) { if (queuePtr->count <= 0) return true; } else return false;

bool queueFull(Queue* queuePtr) { if (queuePtr->count >= MAXQUEUE) return true; } else return false;

void append(Queue* queuePtr, float item) { if (queueFull(queuePtr)) fprintf(stderr, “Queue is full\n”); exit(1); } else queuePtr->rear++; if (queuePtr->rear == MAXQUEUE) queuePtr->rear = 0; queuePtr->entry[queuePtr->rear] = item; queuePtr->count++;

float serve(Queue* queuePtr)
{ float item; if (queueEmpty(queuePtr)) fprintf(stderr, “Queue is empty\n”); exit(1); } else { item = queuePtr->entry[queuePtr->front]; queuePtr->front++; if (queuePtr->front == MAXQUEUE) queuePtr->front = 0; queuePtr->count--; return item;

Revision Queue Main Operations Implementation. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Basic Data Types Stack Last-In, First-Out (LIFO) initialize, push, pop, status Queue First-In, First-Out (FIFO) initialize, Insert, delete, status List copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview Lists. Operations. Abstract Data Types (ADT). Programming Styles. Implementations of Lists. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Lists SEAL FOX DEER APE EMU 1 3 4 2 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insertion EMU Inserted at position 2 SEAL FOX DEER APE 1 3 4 EMU 2 Before: After: APE DEER FOX SEAL 1 2 3 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Delete item at position 3
Deletion Delete item at position 3 SEAL DEER APE 1 3 EMU 2 Before: After: APE DEER EMU FOX SEAL 1 2 3 4 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

List Operations Initialize the list. Determine whether the list is empty. Determine whether the list is full. Find the size of the list. Insert an item anywhere in the list. Delete an item anywhere in a list. Go to a particular position in a list. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

A List ADT A sequence of elements together with these operations: Initialize the list. Determine whether the list is empty. Determine whether the list is full. Find the size of the list. Insert an item anywhere in the list. Delete an item anywhere in a list. Go to a particular position in a list. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Abstract Data Type (ADT)
A Data Structure together with operations defined on it. Useful to consider what operations are required before starting implementation. Led to the development of object oriented programming. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

A Stack ADT A sequence of elements together with these operations: Initialize the stack. Determine whether the stack is empty. Determine whether the stack is full. Push an item onto the top of the stack. Pop an item off the top of the stack. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

A Queue ADT A sequence of elements together with these operations: Initialize the queue. Determine whether the queue is empty. Determine whether the queue is full. Find the size of the queue. Append an item to the rear of the queue. Serve an item at the front of the queue. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Comparison Stacks Insert at the top of the stack (push) Delete at the top of the stack (pop) Queues Insert at the rear of the queue (append) Delete at the front of the queue (serve) Lists Insert at any position in the list. Delete at any position in the list. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

A Rational Number ADT Two integers together with these operations: Initialize the rational number. Get the numerator. Get the denominator. Simplify a rational number. Add two rational numbers. Determine whether two rational numbers are equal. etc. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

A String ADT A array of characters together with these operations: Initialize the string. Copy a string. Read in a line of input. Concatenate two strings. Compare two strings. Find a length of a string. etc. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Simple List Implementation
EMU 1 2 3 4 5 APE DEER FOX SEAL copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

1 2 3 4 5 APE DEER EMU FOX SEAL copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linked List Implementation: Using Array Index
data start 1 2 3 4 5 DEER FOX APE SEAL 1 3 -1 link to next item marks last item copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

insert: EMU start 1 2 3 4 5 DEER FOX APE SEAL EMU 1 3 -1 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

insert: EMU start 1 2 3 4 5 DEER FOX APE SEAL EMU 4 3 -1 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linked List Implementation: Using Pointers
start 0x2000 0x2008 0x2010 0x2018 0x2020 0x2018 DEER FOX APE SEAL EMU 0x2020 0x2018 0x2000 NULL 0x2008 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

special pointer constant start 0x2000 0x2008 0x2010 0x2018 0x2020 0x2018 DEER FOX APE SEAL EMU 0x2020 0x2018 0x2000 NULL 0x2008 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Revision List initialize, insert, delete, position, status implementations Difference between Stacks, Queues, and Lists. ADT. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview Linked Stack. Push Pop Linked Queue. Insert Delete copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linked Stack Top of the Stack NULL pointer copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#ifndef LINKEDSTACKH #define LINKEDSTACKH #include <stdbool.h> #include ”node.h” struct LinkedStackRec { Node* topPtr; }; typedef struct LinkedStackRec Stack; void intializeStack(Stack* stackPtr); bool stackEmpty(const Stack* stackPtr); bool stackFull(const Stack* stackPtr); void push(Stack* stackPtr, float item); float pop(Stack* stackPtr); #endif copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Initialize Stack void initializeStack(Stack* stackPtr) {
stackPtr->topPtr = NULL; }

Push Top Top copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Push create a new node for the item link the new node to the current top node make the new node the new top copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Push void push(Stack* stackPtr, float item) {
Node* newNodePtr = makeNode(item); newNodePtr->nextPtr = stackPtr->topPtr; stackPtr->topPtr = newNodePtr; }

Pop Top Top copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Pop check if the stack is empty remember the item in the top node remember address of current top node make the next node the new top free the old top node return the item copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Pop float pop(Stack* stackPtr) { float item;
Node* oldNodePtr = stackPtr->topPtr; if (stackEmpty(stackPtr)) { fprintf(stderr, “Stack is empty\n”); exit(1); } else { item = oldNodePtr->value; stackPtr->topPtr = oldNodePtr->nextPtr; free(oldNodePtr); return item;

Linked Queue Front Rear copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#ifndef LINKEDQUEUEH #define LINKEDQUEUEH #include <stdbool.h> #include “node.h” struct LinkedQueueRec { int count; Node* frontPtr; Node* rearPtr; }; typedef struct LinkedQueueRec Queue; void intializeQueue(Queue* queuePtr); bool queueEmpty(const Queue* queuePtr); bool queueFull(const Queue* queuePtr); void append(Queue* queuePtr, float item); float serve(Queue* queuePtr); #endif copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Initialize Queue void initializeQueue(Queue* queuePtr) {
queuePtr->frontPtr = NULL; queuePtr->rearPtr = NULL; queuePtr->count = 0; }

Insert Front Rear copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert Front Rear Front Rear copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert create a new node for the item if the queue is empty: the new node becomes both front and rear of the queue otherwise: make a link from the current rear to the new node the new node becomes the new rear increment the count copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void append(Queue* queuePtr, float item)
{ Node* newNodePtr = makeNode(item); if (queueEmpty(queuePtr)) { queuePtr->frontPtr = newNodePtr; queuePtr->rearPtr = newNodePtr; queuePtr->count = 1; } else { queuePtr->rearPtr->nextPtr = newNodePtr; queuePtr->count++;

Delete Front Rear copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Delete Front Rear Front Rear copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Delete check that the queue is not empty remember the item in the front node remember the address of the front node make the next node the new front free the old front node decrement count if queue is now empty, set rear to NULL return the item copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

float serve(Queue* queuePtr)
{ float item; Node* oldNodePtr = queuePtr->frontPtr; if (queueEmpty(queuePtr)) { fprintf(stderr, “Queue is empty\n”); exit(1); } else { item = oldNodePtr->value; queuePtr->frontPtr = oldNodePtr->nextPtr; queuePtr->count--; free(oldNodePtr); if (queuePtr->count == 0) { queuePtr->rearPtr = NULL; return item;

#include <stdio.h>
#include “linkedqueue.h” main() { Queue theQueue; float item; initializeQueue(&theQueue); while (scanf(“%f”, &item) != EOF) append(&theQueue, item); } while (!queueEmpty(&theQueue)) item = serve(&theQueue); printf(“%f\n”, item);

Revision Linked Stack. Initialize, Pop, Push. Linked Queue. Initialize, Insert,Delete copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview What is Dynamic Memory ? How to find the size of objects. Allocating memory. Deallocating memory. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Virtual Memory Text Segment program instructions static and dynamic data Data Segment free memory local variables, parameters Stack segment copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Virtual Memory Text Segment global variables, etc. Static data dynamic data Heap Stack segment copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Virtual Memory Text Segment Static data Heap memory is allocated and deallocated as needed Stack segment copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

What is Dynamic Memory? Memory which is allocated and deallocated during the execution of the program. Types: data in run-time stack dynamic data in the heap copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example: Run-Time Stack
Memory is allocated when a program calls a function. parameters local variables where to go upon return Memory is deallocated when a program returns from a function. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: 16: 17: 18: #include <stdio.h> float square(float x) { float result; result = x * x; return result; } main() float a = 3.15; float b; b = square(a); printf(“%f\n”, b); stack copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: 16: 17: 18: #include <stdio.h> float square(float x) { float result; result = x * x; return result; } main() float a = 3.15; float b; b = square(a); printf(“%f\n”, b); stack 3.15 a b copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: 16: 17: 18: #include <stdio.h> float square(float x) { float result; result = x * x; return result; } main() float a = 3.15; float b; b = square(a); printf(“%f\n”, b); stack 3.15 x a 3.15 b copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: 16: 17: 18: #include <stdio.h> float square(float x) { float result; result = x * x; return result; } main() float a = 3.15; float b; b = square(a); printf(“%f\n”, b); stack line 16 x 3.15 a 3.15 b copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: 16: 17: 18: #include <stdio.h> float square(float x) { float result; result = x * x; return result; } main() float a = 3.15; float b; b = square(a); printf(“%f\n”, b); stack result line 16 x 3.15 a 3.15 b copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: 16: 17: 18: #include <stdio.h> float square(float x) { float result; result = x * x; return result; } main() float a = 3.15; float b; b = square(a); printf(“%f\n”, b); stack result 9.9225 line 16 x 3.15 a 3.15 b copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: 16: 17: 18: #include <stdio.h> float square(float x) { float result; result = x * x; return result; } main() float a = 3.15; float b; b = square(a); printf(“%f\n”, b); stack 3.15 a b 9.9225 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: 16: 17: 18: #include <stdio.h> float square(float x) { float result; result = x * x; return result; } main() float a = 3.15; float b; b = square(a); printf(“%f\n”, b); stack copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#include <stdlib.h> #include <stdio.h> int factorial (int x) { if (x == 0) return 1; } return x * factorial (x –1); void main() int n; printf(“Enter a number: \n”); scanf(“%d”, &n); printf(“Factorial: %d\n”, factorial(n); copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

How much memory to allocate?
The sizeof operator returns the size of an object, or type, in bytes. Usage: sizeof(Type) sizeof Object copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 1: int n; char str[25]; float x; double numbers[36]; printf(“%d\n”, sizeof(int)); printf(“%d\n”, sizeof n); n = sizeof str; n = sizeof x; n = sizeof(double); n = sizeof numbers; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Notes on sizeof Do not assume the size of an object, or type; use sizeof instead. Example: int n; In DOS: 2 bytes (16 bits) In GCC/Linux: 4 bytes (32 bits) In MIPS: 4 bytes (32 bits) copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 2: #include <stdio.h> #define MAXNAME 80 #define MAXCLASS 100 struct StudentRec { char name[MAXNAME]; float mark; }; typedef struct StudentRec Student; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 2 (cont.): int main() { int n; Student class[MAXCLASS]; n = sizeof(int); printf(“Size of int = %d\n”, n); n = sizeof(Student); printf(“Size of Student = %d\n”, n); n = sizeof class; printf(“Size of array class = %d\n”, n); return 0; } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Notes on sizeof (cont.) The size of a structure is not necessarily the sum of the sizes of its members. “alignment” and “padding” Example: struct cardRec { char suit; int number; }; typedef struct cardRec Card; Card hand[5]; printf(“%d\n”, sizeof(Card)); printf(“%d\n”, sizeof hand); 5*sizeof(Card) copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Dynamic Memory: Heap Memory can be allocated for new objects. Steps: determine how many bytes are needed allocate enough bytes in the heap take note of where it is (memory address) copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 1: heap #include <stdlib.h> main() { int* aPtr = NULL; aPtr = (int*)malloc(sizeof(int)); *aPtr = 5; free(aPtr); } stack aPtr NULL copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 1: heap #include <stdlib.h> main() { int* aPtr = NULL; aPtr = (int*)malloc(sizeof(int)); *aPtr = 5; free(aPtr); } 0x3a04 stack aPtr 0x3a04 NULL copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 1: “type cast” heap 0x3a04 #include <stdlib.h> main() { int* aPtr = NULL; aPtr = (int*)malloc(sizeof(int)); *aPtr = 5; free(aPtr); } stack aPtr NULL 0x3a04 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 1: heap #include <stdlib.h> main() { int* aPtr = NULL; aPtr = (int*)malloc(sizeof(int)); *aPtr = 5; free(aPtr); } 0x3a04 5 stack aPtr 0x3a04 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 1: heap #include <stdlib.h> main() { int* aPtr = NULL; aPtr = (int*)malloc(sizeof(int)); *aPtr = 5; free(aPtr); } stack aPtr 0x3a04 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 1: heap #include <stdlib.h> main() { int* aPtr = NULL; aPtr = (int*)malloc(sizeof(int)); *aPtr = 5; free(aPtr); } deallocates memory stack aPtr 0x3a04 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#include <stdlib.h> main() { int* aPtr; int* bPtr; aPtr = (int*)malloc(sizeof(int)); *aPtr = 5; bPtr = (int*)malloc(sizeof(int)); *bPtr = 8; free(aPtr); aPtr = bPtr; *bPtr = 6; } Example 2: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Allocating Memory Need to include stdlib.h malloc(n) returns a pointer to n bytes of memory. Always check if malloc has returned the NULL pointer. Apply a type cast to the pointer returned by malloc. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Deallocating Memory free(pointer) deallocates the memory pointed to by a pointer. It does nothing if pointer == NULL. pointer must point to memory previously allocated by malloc. Should free memory no longer being used. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 3: main() { Student* studentPtr = NULL; studentPtr = (Student*)malloc(sizeof(Student)); if (studentPtr == NULL) { fprintf(stderr, “Out of memory\n”); exit(1); } *studentPtr = readStudent(); printStudent(*studentPtr); free(studentPtr); copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

main() { Student* class = NULL; int n, i, best = 0; printf(“Enter number of Students: ”); scanf(“%d”, &n); class = (Student*)malloc(n * sizeof(Student)); if (class != NULL) { for (i = 0; i < n; i++) { class[i] = readStudent(); if (class[best].mark < class[i].mark) { best = i; } printf(“Best student: ”); printStudent(class[best]); Example 4: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Common Errors Assuming that the size of a structure is the sum of the sizes of its members. Referring to memory already freed. Not freeing memory which is no longer required. Freeing memory not allocated by malloc. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#include <stdio.h> #include <stdlib.h> float** makeMatrix(int n, int m){ float* memoryPtr; float** matrixPtr; int i; memoryPtr = (float*)malloc(n*m*sizeof(float)); matrixPtr = (float**)malloc(n*sizeof(float*)); if (memoryPtr == NULL || matrixPtr == NULL) { fprintf(stderr, “Not enough memory\n”); exit(1); } for (i = 0; i < n; i++, memoryPtr += m){ matrixPtr[i] = memoryPtr; return matrixPtr; Example 5: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Revision sizeof malloc free Common errors. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview of Topic Review List Implementations. Nodes. Linked Stacks. Linked Queues Linked Lists. Other List Operations Today’s Lecture copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Lists 15 10 3 1 6 1 3 4 2 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

A List ADT A sequence of elements together with these operations: Initialize the list. Determine whether the list is empty. Determine whether the list is full. Find the size of the list. Insert an item anywhere in the list. Delete an item anywhere in a list. Go to a particular position in a list. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insertion 6 Inserted at position 2 15 10 3 1 4 6 2 Before: After: 1 3 10 15 1 2 3 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

A List ADT A sequence of elements together with these operations: Initialize the list. Determine whether the list is empty. Find the size of the list. Insert an item anywhere in the list. Delete an item anywhere in a list. Go to a particular position in a list. List needs to be able to expand copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

6 1 3 10 15 21 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Expansion and Insertion
1 3 10 15 21 Copy old array, leave space for the new value 1 3 6 10 15 21 6 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Disadvantages Lots of memory needs to be allocated. Lots of copying needs to be done. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

insert: 6 start 0x2000 0x2008 0x2010 0x2018 0x2020 3 15 1 21 10 0x2020 0x2018 0x2000 NULL 0x2008 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Method 1 insert: 6 0x30F0 start 3 15 1 21 0x2000 0x2008 0x2010 0x2018 0x2020 NULL 10 0x30F0 0x30F8 0x3100 0x3108 0x3110 newStart 0x3118 Copy old array, leave space for the new value 1 3 6 10 15 21 0x30F8 0x3100 0x3108 0x3110 0x3118 NULL copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Method 2 insert: 6 start 0x2000 0x2008 0x2010 0x2018 0x2020 3 15 1 21 10 0x2020 0x2018 0x2000 NULL 0x2008 6 newItem 0x30F0 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Method 2 insert: 6 start 0x2000 0x2008 0x2010 0x2018 0x2020 3 15 1 21 10 0x30F0 0x2018 0x2000 NULL 0x2008 6 newItem 0x30F0 0x2020 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Advantages Only a little amount of memory needs to be allocated. Only a little amount of copying needs to be done. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Node: struct NodeRec { float value; struct NodeRec* nextPtr; }; typedef struct NodeRec Node; value: nextPtr: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#ifndef NODE.H #define NODE.H struct NodeRec { float value; struct NodeRec* nextPtr; }; typedef struct NodeRec Node; Node* makeNode(float item); #endif copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Make Node To make a new node for an item take enough bytes from the heap remember its address in memory put the item in that location set “next” link to NULL return the node’s address copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Node* makeNode(float item) { Node* newNodePtr = (Node*)malloc(sizeof(Node)); if (newNodePtr == NULL) { fprintf(stderr, “Out of memory”); exit(1); } else { newNodePtr->value = item; newNodePtr->nextPtr = NULL; return newNodePtr;

#include <stdio.h>
#include <stdlib.h> #include “node.h” int main() { float item; Node* firstNodePtr = NULL; Node* lastNodePtr = NULL; while (scanf(“%f”, &item) != EOF){ if (firstNodePtr == NULL){ firstNodePtr = makeNode(item); lastNodePtr = firstNodePtr; } else { lastNodePtr->nextPtr = makeNode(item); lastNodePtr = lastNodePtr->nextPtr;

firstNodePtr: lastNodePtr: item: 0x30F0 0x2124 6 0x30F0 value: 1 0x2A40 nextPtr: 0x2124 value: 6 NULL nextPtr: value: 0x2A40 3 0x2124 nextPtr: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linked Structure firstNodePtr: 0x30F0 1 0x2A40 0x30F0 0x2124 6 NULL 0x2A40 3 0x2124 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linked Structure firstNodePtr: 0x30F0 1 0x2A40 0x30F0 0x2A40 3 0x2124 0x2124 6 NULL copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linked Structure firstNodePtr: 1 3 6 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linked Structure firstNodePtr: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Revision Node How to make a new Node Linked Structure copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview Operations for Lists. Implementation of Linked Lists. Double Linked Lists. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

List Operations Go to a position in the list. Insert an item at a position in the list. Delete an item from a position in the list. Retrieve an item from a position. Replace an item at a position. Traverse a list. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Comparsion Linked Storage Unknown list size. Flexibility is needed. Contiguous Storage Known list size. Few insertions and deletions are made within the list. Random access copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linked List Head 1 2 3 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#ifndef LINKEDLISTH #define LINKEDLISTH #include <stdbool.h> #include “node.h” struct LinkedListRec { int count; Node* headPtr; }; typedef struct LinkedListRec List; void intializeList(List* listPtr); bool listEmpty(const List* listPtr); Node* setPosition(const List* listPtr, int position); void insertItem(List* listPtr, float item, int position); float deleteNode(List* listPtr, int position); #endif copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Initialize List listPtr addr of list count headPtr NULL void initializeList(List* listPtr) { listPtr->headPtr = NULL; listPtr->count = 0; } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Set Position check if position is within range start with address of head node set count to 0 while count is less than position follow link to next node increment count return address of current node copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Set Position Head 1 2 2 position copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Node* setPosition(const List* listPtr, int position) { int i; Node* nodePtr = listPtr->headPtr; if (position < 0 || position >= listPtr->count) { fprintf(stderr, “Invalid position\n”); exit(1); } else { for (i = 0; i < position; i++) { nodePtr = nodePtr->nextPtr; return nodePtr; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Set Position Head 0x4000 0x2030 0x30a8 2 position i 0x4000 NodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Set Position Head 0x4000 0x2030 0x30a8 2 position 1 i 0x2030 NodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Set Position Head 0x4000 0x2030 0x30a8 2 position 2 i 0x30a8 NodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert Head 1 2 If we insert it at position 0. 1 2 Head copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert Head 1 2 If we insert it at position 0. 2 1 3 Head copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Instead, suppose we insert it at position 1. Head 1 2 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Instead, suppose we insert it at position 1. Head 3 2 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void insertItem(List* listPtr, float item, int position) { Node* newNodePtr = makeNode(item); Node* nodePtr = NULL; if (position == 0) newNodePtr->nextPtr = listPtr->headPtr; listPtr->headPtr = newNodePtr; } else nodePtr = setPosition(listPtr, position-1); newNodePtr->nextPtr = nodePtr->nextPtr; nodePtr->nextPtr = newNodePtr; listPtr->count++; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Inserting – New List Head NULL 0x30a8 position 0x30a8 newNodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Inserting – New List Head 0x30a8 position 0x30a8 newNodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Inserting – Start of List
Head Head 0x30a8 0x2008 0x2000 newNodePtr 0x2000 position copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Inserting – Inside the List
Head 0x3080 0x3050 NodePtr 0x3080 0x2000 newNodePtr 0x2000 1 position copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Delete Head 1 2 3 If we delete the Node at position 0. 2 1 Head copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

If we delete the Node at position 2. Head 1 2 3 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

If we delete the Node at position 2. Head 2 1 2 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void deleteNode(List* listPtr, int position) { Node* oldNodePtr = NULL; Node* nodePtr = NULL; if (listPtr->count > 0 && position < listPtr->count) if (position == 0) { oldNodePtr = listPtr->headPtr; listPtr->headPtr = oldNodePtr->nextPtr; } else { nodePtr = setPosition(listPtr, position - 1); oldNodePtr = nodePtr->nextPtr; nodePtr->nextPtr = oldNodePtr->nextPtr; listPtr->count--; free(oldNodePtr); fprintf(stderr, “List is empty or invalid position.\n”); exit(1); copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Deleting – 1st Node Head 0x4000 0x2030 0x30a8 position 0x4000 NodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Deleting – 1st Node 0x4000 0x2030 0x30a8 position Head 0x4000 NodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Deleting – 1st Node 0x2030 0x30a8 position Head 0x4000 NodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Deleting – Middle Node Head 0x4000 0x2030 0x30a8 1 position 0x2030 NodePtr 0x2030 OldNodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Deleting – Middle Node Head 0x4000 0x30a8 1 position 0x2030 NodePtr 0x2030 OldNodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Double Linked List Operations
Go to a position in the list. Insert an item in a position in the list. Delete an item from a position in the list. Retrieve an item from a position. Replace an item at a position. Traverse a list, in both directions. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Double Linked List 1 2 3 4 Current copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

struct DoubleLinkNodeRec { float value; struct DoubleLinkNodeRec* nextPtr; struct DoubleLinkNodeRec* previousPtr; }; typedef struct DoubleLinkNodeRec Node; struct DoubleLinkListRec int count; Node* currentPtr; int position; typedef struct DoubleLinkListRec DoubleLinkList; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert at end 0x4000 0x3080 0x2030 0x2000 0x3080 0x2030 NULL NULL NULL 0x4000 0x3080 NULL 0x2030 currentPtr prevPtr newPtr 0x2000 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert at end 0x4000 0x3080 0x2030 0x2000 0x3080 0x2030 0x2000 NULL NULL 0x4000 0x3080 NULL 0x2030 currentPtr prevPtr newPtr 0x2000 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert at end 0x4000 0x3080 0x2030 0x2000 0x3080 0x2030 0x2000 NULL NULL 0x4000 0x3080 0x2030 0x2030 currentPtr prevPtr newPtr 0x2000 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert inside the list 0x4000 0x3080 0x2030 0x3080 0x2030 NULL NULL 0x4000 0x3080 0x2000 0x3080 currentPtr prevPtr 0x2000 NULL newPtr NULL copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert inside the list 0x4000 0x3080 0x2030 0x3080 0x2030 NULL NULL 0x4000 0x3080 0x2000 0x3080 currentPtr prevPtr 0x2000 2030 newPtr NULL copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert inside the list 0x4000 0x3080 0x2030 0x3080 0x2030 NULL NULL 0x4000 0x3080 0x2000 0x3080 currentPtr prevPtr 0x2000 2030 newPtr 3080 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Delete from end 0x4000 0x3080 0x2030 0x3080 0x2030 NULL NULL 0x4000 0x3080 oldPtr 0x2030 currentPtr 0x3080 prevPtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Delete from end 0x4000 0x3080 0x2030 0x3080 NULL NULL NULL 0x4000 0x3080 oldPtr 0x2030 currentPtr 0x3080 prevPtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Delete from end 0x4000 0x3080 0x3080 NULL NULL 0x4000 oldPtr 0x2030 currentPtr 0x3080 prevPtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Delete from inside list
0x4000 0x3080 0x2030 0x3080 0x2030 NULL NULL 0x4000 0x3080 oldPtr 0x3080 currentPtr 0x4000 prevPtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

0x4000 0x2030 0x2030 NULL NULL 0x4000 oldPtr 0x3080 currentPtr Head 0x4000 prevPtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Revision Linked List. Benefits of different implementations. Double Linked List. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview Selection Sort Insertion Sort Linear Search. Binary Search. Growth Rates. Implementation. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Selection Sort First find the largest element in the array and exchange it with the element in the last position, then find the second largest element in array and exchange it with the element in the second last position, and continue in this way until the entire array is sorted. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Selection Sort 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 … copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insertion Sort The items of the array are considered one at a time, and each new item is inserted into the appropriate position relative to the previously sorted items. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insertion Sort 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 5 6 … copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linear Search current -7 9 -5 2 8 3 -4 1 2 3 4 5 6 Target is -5 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linear Search current -7 9 -5 2 8 3 -4 1 2 3 4 5 6 Numbers can be in any order. Works for Linked Lists. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Search target Lower Part mid copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Search target Upper Part mid copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Search target Upper Part mid Need List to be sorted. To be able to do random accesses. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Search target -1 2 3 5 8 10 15 1 2 3 4 5 6 mid low high copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Search target -1 2 3 5 8 10 15 1 2 3 4 5 6 mid high low copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Other Uses of Binary Search
To find where a function is zero. Compute functions. Tree data structures. Data processing. Debugging code. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Growth Rates / Complexity
Recall: Growth Rates / Complexity Constant Logarithmic Linear n log(n) Quadratic Cubic Exponential O(1) O(log(n)) O(n) O(n log(n)) O(n2) O(n3) O(2n) copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Selection Sort First find the largest element in the array and exchange it with the element in the last position, then find the second largest element in array and exchange it with the element in the second last position, and continue in this way until the entire array is sorted. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Find where the Maximum is.
/* * Find the position of the maximum in * list[0],…,list[k] */ maxPosition = 0; for (j = 1; j <= k; j++) { if (array[j] > array[maxPosition]) { maxPosition = j; } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void selectionSort(float array[], int size) { int j, k; int maxPosition; float tmp; for (k = size-1; k > 0; k--) { maxPosition = 0; for (j = 1; j <= k; j++) { if (array[j] > array[maxPosition]) maxPosition = j; } tmp = array[k]; array[k] = array[maxPosition]; array[maxPosition] = tmp; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insertion Sort The items of the array are considered one at a time, and each new item is inserted into the appropriate position relative to the previously sorted items. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void insertionSort(float array[], int size) { int j, k; float current; for (k = 1; k < size; k++) current = array[k]; j = k; while (j > 0 && current < array[j-1]) { array[j] = array[j-1]; j--; } array[j] = current; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linear Search current -7 9 -5 2 8 3 -4 1 2 3 4 5 6 Numbers can be in any order. Works for Linked Lists. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Linear Search int linearSearch(float array[], int size, int target) { int i; for (i = 0; i < size; i++) if (array[i] == target) return i; } return -1; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Search mid Need List to be sorted. To be able to do random accesses. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Case 1: target < list[mid] target list: New upper lower mid upper copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Case 2: list[mid] < target target list: New lower lower mid upper copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

int binarySearch(float array[], int size, int target) { int lower = 0, upper = size - 1, mid; while (lower <= upper) { mid = (upper + lower)/2; if (array[mid] > target) upper = mid - 1; } else if (array[mid] < target) lower = mid + 1; else return mid; return -1; The section where the target could be found halves in size each time copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Comparison Array Linked List Selection Sort Insertion Sort Linear Search Binary Search copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Revision Selection Sort Insertion Sort Linear Search Binary Search copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview Unary Recursion Binary Recursion Examples Features Stacks Disadvantages Advantages copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

What is Recursion - Recall
A procedure defined in terms of itself Components: Base case Recursive definition Convergence to base case copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

double power(double x, int n) { int i double tmp = 1; if (n > 0) for (i = 0; i < n; i++) tmp *= x; } return tmp; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

double power(double x, int n) { double tmp = 1; if (n > 0) tmp = power(x, n/2); if (n % 2 == 0) tmp = tmp*tmp; } else tmp = tmp*tmp*x; return tmp; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Unary Recursion Functions calls itself once (at most) Usual format: function RecursiveFunction ( <parameter(s)> ) { if ( base case ) then return base value else return RecursiveFunction ( <expression> ) } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Unary Recursion function Factorial ( n ) { if ( n is less than or equal to 1) then return 1 else return n  Factorial ( n - 1 ) } /* Computes the factorial */ int factorial ( int n ) { if ( n <= 1 ) return 1; } else return n*factorial(n-1); copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Recursion Defined in terms of two or more calls to itself. For example – Fibonacci A series of numbers which begins with 0 and 1 every subsequent number is the sum of the previous two numbers 0, 1, 1, 2, 3, 5, 8, 13, 21,... copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Recursion function Fibonacci ( n ) { if ( n is less than or equal to 1 ) then return n else return Fibonacci ( n - 2 ) + Fibonacci ( n - 1 ) } /* Compute the n-th Fibonacci number */ long fib ( long n ) { if ( n <= 1 ) return n ; else return fib( n - 2 ) + fib( n - 1 ); } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Copy List HeadPtr struct LinkedListRec { int count; Node* headPtr; }; typedef struct LinkedListRec List; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#include “linkList.h” Node* copyNodes(Node* oldNodePtr); void copyList(List* newListPtr, List* oldListPtr) { if (listEmpty(oldListPtr)) initializeList(newListPtr); } else newListPtr->headPtr = copyNodes(oldListPtr->headPtr); newListPtr->count = oldListPtr->count; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Node* copyNodes(Node* oldNodePtr) { Node* newNodePtr = NULL: if (oldNodePtr != NULL) newNodePtr = makeNode(oldNodePtr->value); newNodePtr->nextPtr = copyNodes(oldNodePtr->nextPtr); } return newNodePtr; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Copy Nodes OldNodePtr NewNodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Copy Nodes OldNodePtr NewNodePtr NewNodePtr->next is set to the Result of calling copy nodes on The remainder of the list copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Copy Nodes OldNodePtr NewNodePtr NewNodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Copy Nodes OldNodePtr NULL NewNodePtr NewNodePtr NewNodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Copy Nodes OldNodePtr NewNodePtr NewNodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Copy Nodes OldNodePtr NewNodePtr copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Recursion Process Every recursive process consists of: 1. A base case. 2. A general method that reduces to the base case. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Types of Recursion Direct. Indirect. Linear. n-ary (Unary, Binary, Ternary, …) copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Stacks Every recursive function can be implemented using a stack and iteration. Every iterative function which uses a stack can be implemented using recursion. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

double power(double x, int n) { double tmp = 1; if (n > 0) tmp = power(x, n/2); if (n % 2 == 0) tmp = tmp*tmp; } else tmp = tmp*tmp*x; return tmp; x = 2, n = 5 tmp = 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

double power(double x, int n) { double tmp = 1; if (n > 0) tmp = power(x, n/2); if (n % 2 == 0) tmp = tmp*tmp; } else tmp = tmp*tmp*x; return tmp; x = 2, n = 5 tmp = 1 x = 2, n = 2 tmp = 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

double power(double x, int n) { double tmp = 1; if (n > 0) tmp = power(x, n/2); if (n % 2 == 0) tmp = tmp*tmp; } else tmp = tmp*tmp*x; return tmp; x = 2, n = 5 tmp = 1 x = 2, n = 2 tmp = 1 x = 2, n = 1 tmp = 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

double power(double x, int n) { double tmp = 1; if (n > 0) tmp = power(x, n/2); if (n % 2 == 0) tmp = tmp*tmp; } else tmp = tmp*tmp*x; return tmp; x = 2, n = 5 tmp = 1 x = 2, n = 2 tmp = 1 x = 2, n = 1 tmp = 1 x = 2, n = 0 tmp = 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

double power(double x, int n) { double tmp = 1; if (n > 0) tmp = power(x, n/2); if (n % 2 == 0) tmp = tmp*tmp; } else tmp = tmp*tmp*x; return tmp; x = 2, n = 5 tmp = 1 x = 2, n = 2 tmp = 1 x = 2, n = 1 tmp = 1*1*2 = 2 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

double power(double x, int n) { double tmp = 1; if (n > 0) tmp = power(x, n/2); if (n % 2 == 0) tmp = tmp*tmp; } else tmp = tmp*tmp*x; return tmp; x = 2, n = 5 tmp = 1 x = 2, n = 2 tmp = 2*2 = 4 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

double power(double x, int n) { double tmp = 1; if (n > 0) tmp = power(x, n/2); if (n % 2 == 0) tmp = tmp*tmp; } else tmp = tmp*tmp*x; return tmp; x = 2, n = 5 tmp = 4*4*2 = 32 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

module power(x, n) { create a Stack initialize a Stack loop{ if (n == 0) then {exit loop} push n onto Stack n = n/2 } tmp = 1 loop { if (Stack is empty) then {return tmp} pop n off Stack if (n is even) {tmp = tmp*tmp} else {tmp = tmp*tmp*x} n = 5, x = 2 Stack copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

module power(x, n) { create a Stack initialize a Stack loop{ if (n == 0) then {exit loop} push n onto Stack n = n/2 } tmp = 1 loop { if (Stack is empty) then {return tmp} pop n off Stack if (n is even) {tmp = tmp*tmp} else {tmp = tmp*tmp*x} n = 5, x = 2 Stack 5 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

module power(x, n) { create a Stack initialize a Stack loop{ if (n == 0) then {exit loop} push n onto Stack n = n/2 } tmp = 1 loop { if (Stack is empty) then {return tmp} pop n off Stack if (n is even) {tmp = tmp*tmp} else {tmp = tmp*tmp*x} n = 2, x = 2 Stack 5 2 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

module power(x, n) { create a Stack initialize a Stack loop{ if (n == 0) then {exit loop} push n onto Stack n = n/2 } tmp = 1 loop { if (Stack is empty) then {return tmp} pop n off Stack if (n is even) {tmp = tmp*tmp} else {tmp = tmp*tmp*x} n = 1, x = 2 Stack 5 2 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

module power(x, n) { create a Stack initialize a Stack loop{ if (n == 0) then {exit loop} push n onto Stack n = n/2 } tmp = 1 loop { if (Stack is empty) then {return tmp} pop n off Stack if (n is even) {tmp = tmp*tmp} else {tmp = tmp*tmp*x} n = 0, x = 2 Stack tmp = 1 5 2 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

module power(x, n) { create a Stack initialize a Stack loop{ if (n == 0) then {exit loop} push n onto Stack n = n/2 } tmp = 1 loop { if (Stack is empty) then {return tmp} pop n off Stack if (n is even) {tmp = tmp*tmp} else {tmp = tmp*tmp*x} n = 0, x = 2 Stack tmp = 2 5 2 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

module power(x, n) { create a Stack initialize a Stack loop{ if (n == 0) then {exit loop} push n onto Stack n = n/2 } tmp = 1 loop { if (Stack is empty) then {return tmp} pop n off Stack if (n is even) {tmp = tmp*tmp} else {tmp = tmp*tmp*x} n = 0, x = 2 Stack tmp = 4 5 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

module power(x, n) { create a Stack initialize a Stack loop{ if (n == 0) then {exit loop} push n onto Stack n = n/2 } tmp = 1 loop { if (Stack is empty) then {return tmp} pop n off Stack if (n is even) {tmp = tmp*tmp} else {tmp = tmp*tmp*x} n = 0, x = 2 Stack tmp = 32 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

double power(double x, int n) { double tmp = 1; Stack theStack; initializeStack(&theStack); while (n != 0) { push(&theStack, n); n /= 2; } while (!stackEmpty(&theStack)) { n = pop(&theStack); if (n % 2 == 0) { tmp = tmp*tmp;} else { tmp = tmp*tmp*x;} return tmp; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Disadvantages May run slower. Compilers Inefficient Code May use more space. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Advantages More natural. Easier to prove correct. Easier to analysis. More flexible. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Free List – Non Recursive
Head 0x2000 0x258a 0x4c68 /* Delete the entire list */ void FreeList(Node* head){ Node* next; while (head != NULL) { next=head->next; free(head); head=next; } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

head next 0x2000 0x258a 0x4c68 /* Delete the entire list */ void FreeList(Node* head){ Node* next; while (head != NULL) { next=head->next; free(head); head=next; } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

head next 0x258a 0x4c68 /* Delete the entire list */ void FreeList(Node* head){ Node* next; while (head != NULL) { next=head->next; free(head); head=next; } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

head next NULL 0x4c68 /* Delete the entire list */ void FreeList(Node* head){ Node* next; while (head != NULL) { next=head->next; free(head); head=next; } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

head next NULL /* Delete the entire list */ void FreeList(Node* head){ Node* next; while (head != NULL) { next=head->next; free(head); head=next; } Has local variables on the stack. This is performing two assignments and one comparison per iteration. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Free List Head /* Delete the entire list */ void FreeList(Node* list) { if (list==NULL) return; FreeList(list->next); free(list); } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Free List list 0x2000 0x258a 0x4c68 /* Delete the entire list */ void FreeList(Node* list) { if (list==NULL) return; FreeList(list->next); free(list); } 0x2000 Stack in memory copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Free List list 0x2000 0x258a 0x4c68 /* Delete the entire list */ void FreeList(Node* list) { if (list==NULL) return; FreeList(list->next); free(list); } 0x2000 0x258a Stack in memory copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Free List list 0x2000 0x258a 0x4c68 /* Delete the entire list */ void FreeList(Node* list) { if (list==NULL) return; FreeList(list->next); free(list); } 0x2000 0x258a 0x4c68 Stack in memory copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Free List list 0x2000 0x258a 0x4c68 /* Delete the entire list */ void FreeList(Node* list) { if (list==NULL) return; FreeList(list->next); free(list); } NULL 0x2000 0x258a 0x4c68 Stack in memory copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Free List list 0x2000 0x258a 0x4c68 /* Delete the entire list */ void FreeList(Node* list) { if (list==NULL) return; FreeList(list->next); free(list); } 0x2000 0x258a 0x4c68 Stack in memory copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Free List list 0x2000 0x258a /* Delete the entire list */ void FreeList(Node* list) { if (list==NULL) return; FreeList(list->next); free(list); } 0x2000 0x258a Stack in memory copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Free List list 0x2000 /* Delete the entire list */ void FreeList(Node* list) { if (list==NULL) return; FreeList(list->next); free(list); } 0x2000 Stack in memory copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Free List Head 0x2000 /* Delete the entire list */ void FreeList(Node* list) { if (list==NULL) return; FreeList(list->next); free(list); } Has no local variables on the stack. This is performing one assignment and one comparison per function call. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Revision Recursion copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview Trees. Terminology. Traversal of Binary Trees. Expression Trees. Binary Search Trees. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Trees Family Trees. Organisation Structure Charts. Program Design. Structure of a chapter in a book. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Parts of a Tree copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Parts of a Tree nodes copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Parts of a Tree parent node copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Parts of a Tree child nodes parent node copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Parts of a Tree root node copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Parts of a Tree leaf nodes copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Parts of a Tree sub-tree copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Tree Each node can have at most 2 children copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Traversal Systematic way of visiting all the nodes. Methods: Preorder, Inorder, and Postorder They all traverse the left subtree before the right subtree. The name of the traversal method depends on when the node is visited. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Preorder Traversal Visit the node. Traverse the left subtree. Traverse the right subtree. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example: Preorder 43 43 31 64 31 64 20 20 40 56 89 40 56 89 28 33 47 59 28 33 47 59 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Inorder Traversal Traverse the left subtree. Visit the node. Traverse the right subtree. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example: Inorder 43 43 31 64 31 64 20 20 40 56 89 40 56 89 28 33 47 59 28 33 47 59 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Postorder Traversal Traverse the left subtree. Traverse the right subtree. Visit the node. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example: Postorder 43 43 31 64 31 64 20 20 40 56 89 40 56 89 28 33 47 59 28 33 47 59 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Expression Tree A Binary Tree built with operands and operators. Also known as a parse tree. Used in compilers. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example: Expression Tree
+ / / 1 3 * 4 6 7 1/ *7 / 4 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Notation Preorder Prefix Notation Inorder Infix Notation Postorder Postfix Notation copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example: Infix + + / / / / 1 1 3 * 4 3 * 4 6 7 6 7 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example: Postfix + + / / / / 1 1 3 * 4 3 * 4 6 7 6 7 Recall: Reverse Polish Notation copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example: Prefix + / / 1 3 * 4 6 7 + / 1 3 / * 6 7 4 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Search Tree A Binary Tree such that: Every node entry has a unique key. All the keys in the left subtree of a node are less than the key of the node. All the keys in the right subtree of a node are greater than the key of the node. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 1: key is an integer 43 31 64 20 40 56 89 28 33 47 59 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert Create new node for the item. Find a parent node. Attach new node as a leaf. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert 57 Example: 43 31 64 20 40 56 89 28 33 47 59 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert 57 Example: 43 31 64 20 40 56 89 28 33 47 59 57 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Search: Checklist if target key is less than current node’s key, search the left sub-tree. else, if target key is greater than current node’s key, search the right sub-tree. returns: if found, pointer to node containing target key. otherwise, NULL pointer. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Search Example: 59 43 31 64 20 40 56 89 28 33 47 59 57 found copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Search Example: 61 43 31 64 20 40 56 89 28 33 47 59 57 failed copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Revision Binary Tree Preorder, Inorder, Postorder Traveral Expression Trees Prefix, Infix, and Postfix notation Insert and Search copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview Binary Search Trees. Hash Tables. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Recall - Binary Search Tree
A Binary Tree such that: Every node entry has a unique key. All the keys in the left subtree of a node are less than the key of the node. All the keys in the right subtree of a node are greater than the key of the node. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 1: key is an integer 43 31 64 20 40 56 89 28 33 47 59 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 2: key is a string Fred Dan Mary Alan Eve Kate Sue Greg Len Bill Eric copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Tree Node entry link to right child node link to left child node copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Search Tree Node
Example 1: struct TreeNodeRec { int key; struct TreeNodeRec* leftPtr; struct TreeNodeRec* rightPtr; }; typedef struct TreeNodeRec TreeNode; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Binary Search Tree Node
Example 2: #define MAXLEN 15 struct TreeNodeRec { char key[MAXLEN]; struct TreeNodeRec* leftPtr; struct TreeNodeRec* rightPtr; }; typedef struct TreeNodeRec TreeNode; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Recall: maximum string length is fixed #define MAXLEN 15 struct TreeNodeRec { char key[MAXLEN]; struct TreeNodeRec* leftPtr; struct TreeNodeRec* rightPtr; }; typedef struct TreeNodeRec TreeNode; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 3: struct TreeNodeRec { char* key; struct TreeNodeRec* leftPtr; struct TreeNodeRec* rightPtr; }; typedef struct TreeNodeRec TreeNode; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Recall: Allows strings of arbitrary length. Memory needs to be allocated dynamically before use. Use strcmp to compare strings. struct TreeNodeRec { char* key; struct TreeNodeRec* left; struct TreeNodeRec* right; }; typedef struct TreeNodeRec TreeNode; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Book Record struct BookRec { char* author; char* title; char* publisher; /* etc.: other book information. */ }; typedef struct BookRec Book; key copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example 4: Binary Search Tree Node struct TreeNodeRec { Book info; struct TreeNodeRec* leftPtr; struct TreeNodeRec* rightPtr; }; typedef struct TreeNodeRec TreeNode; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Tree Node struct TreeNodeRec { float key; struct TreeNodeRec* leftPtr; struct TreeNodeRec* rightPtr; }; typedef struct TreeNodeRec TreeNode; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

#ifndef TREE_H #define TREE_H struct TreeNodeRec { float key; struct TreeNodeRec* leftPtr; struct TreeNodeRec* rightPtr; }; typedef struct TreeNodeRec TreeNode; TreeNode* makeTreeNode(float value); TreeNode* insert(TreeNode* nodePtr, float item); TreeNode* search(TreeNode* nodePtr, float item); void printInorder(const TreeNode* nodePtr); void printPreorder(const TreeNode* nodePtr); void printPostorder(const TreeNode* nodePtr); #endif copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

MakeNode parameter: item to be inserted steps: allocate memory for the new node check if memory allocation is successful if so, put item into the new node set left and right branches to NULL returns: pointer to (i.e. address of) new node copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

TreeNode* makeTreeNode(float value) { TreeNode* newNodePtr = NULL; newNodePtr = (TreeNode*)malloc(sizeof(TreeNode)); if (newNodePtr == NULL) fprintf(stderr, “Out of memory\n”); exit(1); } else newNodePtr->key = value; newNodePtr->leftPtr = NULL; newNodePtr->rightPtr = NULL; return newNodePtr; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

value 3.3 newNodePtr NULL newNodePtr 0x2000 0x2000 newNodePtr 0x2000 3.3 0x2000 NULL NULL copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Inorder Inorder traversal of a Binary Search Tree always gives the sorted order of the keys. void printInorder(TreeNode* nodePtr) { } initially, pointer to root node copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Inorder Inorder traversal of a Binary Search Tree always gives the sorted order of the keys. void printInorder(TreeNode* nodePtr) { traverse left sub-tree visit the node traverse right sub-tree } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Inorder Inorder traversal of a Binary Search Tree always gives the sorted order of the keys. void printInorder(TreeNode* nodePtr) { printInorder(nodePtr->leftPtr); printf(“ %f, nodePtr->key); printInorder(nodePtr->rightPtr); } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Inorder Inorder traversal of a Binary Search Tree always gives the sorted order of the keys. void printInorder(TreeNode* nodePtr) { if (nodePtr != NULL) printInorder(nodePtr->leftPtr); printf(“ %f”, nodePtr->key); printInorder(nodePtr->rightPtr); } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Inorder nodePtr void printInorder(TreeNode* nodePtr){ if (nodePtr != NULL){ printInorder(nodePtr->leftPtr); printf(“ %f”, nodePtr->key); printInorder(nodePtr->rightPtr); } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Search Example: 59 43 31 64 20 40 56 89 28 33 47 59 57 found copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Search Example: 61 43 31 64 20 40 56 89 28 33 47 59 57 failed copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Search: Checklist if target key is less than current node’s key, search the left sub-tree. else, if target key is greater than current node’s key, search the right sub-tree. returns: if found, or if target key is equal to current node’s key, a pointer to node containing target key. otherwise, NULL pointer. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

TreeNode* search(TreeNode* nodePtr, float target) { if (nodePtr != NULL) if (target < nodePtr->key) nodePtr = search(nodePtr->leftPtr, target); } else if (target > nodePtr->key) nodePtr = search(nodePtr->rightPtr, target); return nodePtr; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Function Call to Search
/* …other bits of code omitted… */ printf(“Enter target ”); scanf(“%f”, &item); if (search(rootPtr, item) == NULL) { printf(“Item was not found\n”); } else printf(“Item found\n”); /* …and so on… */ copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Search Find 0.7 nodePtr 1.0 0.6 1.9 0.3 0.8 1.4 2.7 0.4 0.7 1.1 1.8 TreeNode* search(TreeNode* nodePtr, float target){ if (nodePtr != NULL){ if (target < nodePtr->key) nodePtr = search(nodePtr->leftPtr, target); else if (target > nodePtr->key) nodePtr = search(nodePtr->rightPtr, target); } return nodePtr; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Search Find 0.5 nodePtr 1.0 0.6 1.9 0.3 0.8 1.4 2.7 0.4 0.7 1.1 1.8 TreeNode* search(TreeNode* nodePtr, float target){ if (nodePtr != NULL){ if (target < nodePtr->key) nodePtr = search(nodePtr->leftPtr, target); else if (target > nodePtr->key) nodePtr = search(nodePtr->rightPtr, target); } return nodePtr; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert 57 Example: 43 31 64 20 40 56 89 28 33 47 59 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert 57 Example: 43 31 64 20 40 56 89 28 33 47 59 57 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert Create new node for the item. Find a parent node. Attach new node as a leaf. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert: Recursive parameters: pointer to current node (initially: root node). item to be inserted. If current node is NULL Create a new node and return it. Else if item’s key is less (greater) than current node’s key: otherwise, let the left (right) child node be the current node, setting the parent left (right) link equal that node, and repeat recursively. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

TreeNode* insert(TreeNode* nodePtr, float item) { if (nodePtr == NULL) nodePtr = makeTreeNode(item); } else if (item < nodePtr->key) nodePtr->leftPtr = insert(nodePtr->leftPtr, item); else if (item > nodePtr->key) nodePtr->rightPtr = insert(nodePtr->rightPtr, item); return nodePtr; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Function Call to Insert
/* …other bits of code omitted… */ printf(“Enter number of items ”); scanf(“%d”, &n); for (i = 0; i < n; i++) { scanf(“%f”, &item); rootPtr = insert(rootPtr, item); } /* …and so on… */ copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert Insert 0.9 nodePtr 1.0 0.6 1.9 0.3 0.8 1.4 2.7 0.4 0.7 1.1 1.8 TreeNode* insert(TreeNode* nodePtr, float item) { if (nodePtr == NULL) nodePtr = makeTreeNode(item); else if (item < nodePtr->key) nodePtr->leftPtr = insert(nodePtr->leftPtr, item); else if (item > nodePtr->key) nodePtr->rightPtr = insert(nodePtr->rightPtr, item); return nodePtr; } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Insert Insert 0.9 nodePtr 1.0 0.6 1.9 0.3 0.8 1.4 2.7 0.4 0.7 0.9 1.1 1.8 TreeNode* insert(TreeNode* nodePtr, float item) { if (nodePtr == NULL) nodePtr = makeTreeNode(item); else if (item < nodePtr->key) nodePtr->leftPtr = insert(nodePtr->leftPtr, item); else if (item > nodePtr->key) nodePtr->rightPtr = insert(nodePtr->rightPtr, item); return nodePtr; } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Sorting To sort a sequence of items: Insert items into a Binary Search Tree. Then Inorder Traverse the tree. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Sorting: Analysis Average Case: O(n log(n)) ~ log2 n Insert (i+1)th item: ~ log2(i) comparisons copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Sort Sort the following list into a binary search tree 1.0 2.5 0.5 0.7 3.6 2.1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Sort 1.0 Sort the following list into a binary search tree 2.1 1.0 2.5 0.5 0.7 3.6 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Sort 1.0 2.5 Sort the following list into a binary search tree 2.1 1.0 2.5 0.5 0.7 3.6 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Sort 1.0 0.5 2.5 Sort the following list into a binary search tree 2.1 1.0 2.5 0.5 0.7 3.6 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Sort 1.0 0.5 2.5 0.7 Sort the following list into a binary search tree 1.0 2.5 0.5 0.7 3.6 2.1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Sort 1.0 0.5 2.5 0.7 3.6 Sort the following list into a binary search tree 1.0 2.5 0.5 0.7 3.6 2.1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Sort 1.0 0.5 2.5 0.7 2.1 3.6 Sort the following list into a binary search tree 1.0 2.5 0.5 0.7 3.6 2.1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Sorting: Analysis Worst Case: O(n2) Example: Insert: 1, 3, 7, 9, 11, 15 Insert (i+1)th item: ~ i comparisons copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Revision Binary Search Tree Make Tree Node, Insert item, Search for an item, and Print Inorder. Tree sort. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Overview Divide and Conquer Merge Sort Quick Sort copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Divide and Conquer Recall: Binary Search Search Search Search copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Divide and Conquer Sort Sort Sort Sort Sort Sort Sort copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Divide and Conquer Combine Combine Combine copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Divide and Conquer module sort(array) { if (size of array > 1) split(array, firstPart, secondPart) sort(firstPart) sort(secondPart) combine(firstPart, secondPart) } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Merge Sort Sort Sort Merge copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Merge Sort array: size tmpArrayPtr: tmp: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

secondPart : array + mid
Merge Sort array[0] array[mid] mid (size - mid) firstPart : array secondPart : array + mid copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Merge Sort array: mergeList tmp: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Merge Sort array: tmp: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Merge Sort array: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void mergeSort(float array[], int size) { int* tmpArrayPtr = (int*)malloc(size*sizeof(int)); if (tmpArrayPtr != NULL) mergeSortRec(array, size, tmpArrayPtr); } else fprintf(stderr, “Not enough memory to sort list.\n”); exit(1); free(tmpArrayPtr); copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void mergeSortRec(float array[], int size, float tmp[]) { int i; int mid = size/2; if (size > 1) mergeSortRec(array, mid, tmp); mergeSortRec(array+mid, size-mid, tmp); mergeArrays(array, mid, array+mid, size-mid, tmp); for (i = 0; i < size; i++) array[i] = tmp[i]; } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 aSize: 5 bSize: 6 tmp: copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=0 j=0 tmp: k=0 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=0 j=0 tmp: 3 k=0 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=1 j=0 tmp: 3 5 k=1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=2 j=0 tmp: 3 5 6 k=2 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=2 j=1 tmp: 3 5 6 10 k=3 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=2 j=2 tmp: 3 5 6 10 14 k=4 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=2 j=3 tmp: 3 5 6 10 14 15 k=5 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=3 j=3 tmp: 3 5 6 10 14 15 22 k=6 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=3 j=4 tmp: 3 5 6 10 14 15 22 28 k=7 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=4 j=4 tmp: 3 5 6 10 14 15 22 28 30 k=8 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

mergeArrays Example: a: b: 3 5 15 28 30 6 10 14 22 43 50 i=5 j=4 Done. tmp: 3 5 6 10 14 15 22 28 30 43 50 k=9 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

void mergeArrays(float a[],int aSize,float b[],int bSize,float tmp[]) { int k, i = 0, j = 0; for (k = 0; k < aSize + bSize; k++) if (i == aSize) { tmp[k] = b[j]; j++; } else if (j == bSize) { tmp[k] = a[i]; i++; else if (a[i] <= b[j]) { else { copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Merge Sort and Linked Lists
copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Merge Sort Analysis Most of the work is in the merging. Takes O(n log(n)) Uses more space than other sorts. Useful for linked lists. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Quick Sort Partition x < p p p <= x Sort Sort copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Quick Sort Example: array: 5 89 35 10 24 15 37 13 20 17 70 size: 11 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Quick Sort Example: array: 5 89 35 14 24 15 15 37 13 20 7 70 “pivot element” copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Quick Sort Example: array: 5 89 35 14 24 15 37 13 20 7 70 partition: 5 89 35 14 24 37 13 20 7 70 15 7 14 5 13 15 35 37 89 20 24 70 index: 4 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Quick Sort Example: index: 4 array: 7 14 5 13 15 35 37 89 20 24 70 index (size - index - 1) copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

secondPart : array + index + 1
Quick Sort Example: array[0] array[index + 1] 7 14 5 13 15 35 37 89 20 24 70 index (size - index - 1) firstPart : array secondPart : array + index + 1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Quick Sort void quickSort(float array[], int size) { int index; if (size > 1) index = partition(array, size); quickSort(array, index); quickSort(array+index+1, size - index - 1); } copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Partition: Checklist p p p x < p p <= x p x < p p <= x p x < p p <= x copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Partition Example: mid: 4 array: 5 5 89 35 14 24 15 15 37 13 20 7 70 15 89 35 14 24 5 37 13 20 7 70 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Partition Example: array: 15 89 35 14 24 5 37 13 20 7 70 k=1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Partition Example: index:0 array: 15 89 89 35 14 24 5 37 13 20 7 70 k:1 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Partition Example: index:1 array: 15 89 14 89 35 14 24 5 37 13 20 7 70 k:3 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Partition Example: index:2 array: 15 14 35 5 35 89 24 5 37 13 20 7 70 k:5 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Partition Example: index:2 array: 15 14 5 89 24 35 37 13 20 7 70 k:7 etc... copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Partition Example: index:4 array: 15 14 5 13 7 35 37 89 20 24 70 k:11 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Partition Example: index:4 array: 15 14 5 13 7 35 37 89 20 24 70 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Partition Example: index:4 array: 15 7 15 14 5 13 7 35 37 89 20 24 70 x < 15 15 <= x copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example: pivot now in correct position array: 15 7 15 14 5 13 7 35 37 89 20 24 70 x < 15 15 <= x copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Example: 7 14 5 13 15 35 37 89 20 24 70 Sort Sort 7 14 5 13 35 37 89 20 24 70 copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

int partition(float array[], int size) { int k; int mid = size/2; int index = 0; swap(array, array+mid); for (k = 1; k < size; k++) if (list[k] < list[0]) index++; swap(array+k, array+index); } swap(array, array+index); return index; copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Quick Sort Analysis Most of the work done in partitioning. Need to be careful of choice of pivot. Example: 2, 4, 6, 7, 3, 1, 5 Average case takes O(n log(n)) time. Worst case takes O(n2) time. copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Revision Merge Sort Quick Sort copy right (version1.0) SUNITHA C.N,CS&E dept,SJCE

Lectures on data structures and C 3ed CS(CSI33) By, CHANDRASHEKAR A.M.

Similar presentations

Presentation on theme: "Lectures on data structures and C 3ed CS(CSI33) By, CHANDRASHEKAR A.M."— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Lectures on data structures and C 3ed CS(CSI33) By, CHANDRASHEKAR A.M.

Similar presentations

Presentation on theme: "Lectures on data structures and C 3ed CS(CSI33) By, CHANDRASHEKAR A.M."— Presentation transcript:

Similar presentations

About project

Feedback