1 lectures on data structures and c 3ed cs(csi33) by, chandrashekar a.m

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

1

Lectures on Lectures on data structures anddata structures and C C

3ed CS(CSI33)3ed CS(CSI33)By,By,

CHANDRASHEKAR A.M.CHANDRASHEKAR A.M.


2

Data Structures and AlgorithmsData Structures and Algorithms

• Programs.

• Different problems.

• Operations.

• Size of data.

• Resources available.


3

Overview of LectureOverview of Lecture

• Basic data structures.

• How to manipulate them.

• How to implement them.

• Other algorithms and how to implement them.


4

This Lecture - ReviewThis Lecture - Review

• Basic C data types

• Boolean

• 1D and multidimensional arrays

• Strings

• Input/Output

• File I/O• Structures and typedef


5

Basic Data types in CBasic Data types in C

• int

• char

• float

• double


6

BooleanBoolean

• 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

#include <stdbool.h>

bool leapYear(int year){ if ((year % 4 == 0 && year % 100 != 0)

|| (year % 400 == 0) ) { return true; } else { return false; }}

#define true 1#define false 0

int leapYear(int year){ if ((year % 4 == 0 && year % 100 != 0)


For Borland use #define or const int




File inclusion header

Recall:




Function definitionRecall:

Function name#include <stdbool.h>



Recall:

Must be compatible with the function’s return type

Function return type

#include <stbool.h>


|| (year % 400 == 0) ) { return true; } else { return true; }}

Recall:




Parameter type

Function parameter

Recall:

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);}

Recall:

Function call


15

Review - Arrays (1D)Review - Arrays (1D)

• All the elements are of the same type.

• An element: array1D[index]

• In C, the first element has index 0 (zero).

array1D:

0 1 N - 1


16

Review - Multidimensional ArraysReview - Multidimensional Arrays

• Arrays of arrays.

• All the elements are of the same type.

• An element: array2D[row][column]

array2D:

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}};



return day;}

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}};



return day;}

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}};



return day;}


21

• 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

Review – Input/OutputReview – Input/Output

Conversion specifiers Pointers to variables where input will be stored

Variables containing data to be printed


22

• 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

Review – Input/OutputReview – Input/Output

#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


24

• 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

Review - StringsReview - Strings

#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”);

string2 needs to be the same length as string

1

string1 needs to fit the number of characters of the second string, +1 for

the ‘\0’ character

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;

}

Prints the order which

the two strings sort,

alphabetically.

Note: To scan within a string use:sscanf(string1, “%d”, int1);


27

Review -File Handling in CReview -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().

#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”); return 1; }

Moder : read

w : writea : append

Associate a file handler for every file to be used.

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

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

}

To read in a line, use fgets().fgets() returns NULL if end of file is reached.

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?


31

Review -Review - struct struct

• Members may have different types.

structname.membername• structs are also known as “records,” and

members as “fields”

structname:


32

Review -Review - typedef typedef

• Gives a new name to a type that has already been defined.

• E.g.

typedef struct StudentRec Student;

• Saves typing struct whatever everywhere.

#include <stdio.h>

#define MAXNAME 80

struct StudentRec{ char name[MAXNAME]; int mark;};


Example :

Recall:

Macro substitution

#include <stdio.h>

#define MAXNAME 80



#include <stdio.h>

#define MAXNAME 80



Recall:

Structure declaration

Structure name / tag

Members

Don’t forget this!

Recall:

#include <stdio.h>

#define MAXNAME 80



Recall:

Data type

New type name

#include <stdio.h>

#define MAXNAME 80



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“Package”

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); }

#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

Member of an array element

#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]);}


42

RevisionRevision• Basic Data Types and booleans• I/O and File I/O• Arrays and Structs• Strings• Typedef

PreparationPreparationNext lecture: Pointers


43

OverviewOverview

• Revision of Pointers

• Basic Pointer Arithmetic

• Pointers and Arrays


44

PointersPointers

• 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

10x2000

0x9060


45

Pointer OperationsPointer Operations

• 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

Type object;Type* aPtr;


46

Pointers and Function ArgumentsPointers and Function Arguments

x: 1

y: 2swap

x: 2

y: 1

#include <stdio.h>

voidfakeSwap(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

#include <stdio.h>





1

2

x:

y:

Solution 1

0x2000

0x2010

#include <stdio.h>





1

2

x:

y:

1

2

a:

b:

tmp:

Solution 1

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>





1

2

x:

y:

1

2

a:

b:

1tmp:

Solution 1

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>





1

2

x:

y:

2

2

a:

b:

1tmp:

Solution 1

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>





1

2

x:

y:

2

1

a:

b:

1tmp:

Solution 1

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>





1

2

x:

y:

Solution 1

0x2000

0x2010

#include <stdio.h>

voidtrueSwap(int* a, int* b){ int tmp;

tmp = *a; *a = *b; *b = tmp;}


trueSwap(&x, &y); printf(“%d %d\n”, x, y);}

Solution 2

#include <stdio.h>


tmp = *a; *a = *b; *b = tmp;}



1

2

x:

y:

Solution 2

0x2000

0x2010

#include <stdio.h>


tmp = *a; *a = *b; *b = tmp;}



1

2

x:

y:

addr of x

addr of y

a:

b:

tmp:

Solution 2

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>


tmp = *a; *a = *b; *b = tmp;}



1

2

x:

y:

addr of x

addr of y

a:

b:

1tmp:

Solution 2

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>


tmp = *a; *a = *b; *b = tmp;}



2

2

x:

y:

addr of x

addr of y

a:

b:

1tmp:

Solution 2

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>


tmp = *a; *a = *b; *b = tmp;}



2

1

x:

y:

addr of x

addr of y

a:

b:

1tmp:

Solution 2

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>


tmp = *a; *a = *b; *b = tmp;}



2

1

x:

y:

Solution 2

0x2000

0x2010


61

More on PointersMore 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);


62

struct DataBaseRec{

};

typedef struct DataBaseRec DataBase;

/* Very Large Structure */


63

DataBasereadNewEntry(DataBase theDataBase){

return theDataBase;}

voidprintDataBase(DataBase theDataBase){

}

/* Some code */

/* Some more code */


64

voidreadNewEntry(DataBase* dataBasePtr){

}

voidprintDataBase(const DataBase* dataBasePtr){

}

/* Some code */



65


}


}

/* Some code */


(DataBase*

Address of Database

Database*


66


}


}

/* Some code */


Database cannot change in this function.

const


67

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?


68

Pointers and FunctionsPointers 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.


69

Pointers and ArraysPointers and Arrays

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

Type array[size];

Type* pPtr = array + i;

Type* qPtr = array + j;


70

Pointers and Arrays (cont)Pointers and Arrays (cont)

• array[0] is equivalent to *array• array[n] is equivalent to *(array + n)

Type array[size];

A normal 1 dimensional array:


71

float array[5];

float* pPtr = array;

float* qPtr = NULL;

0x2008

0x2008

0x2004

array:

pPtr:

0x2008 0x200C 0x2010 0x2014 0x2018

0 1 2 3 4

NULL0x2000

qPtr:

Basic Pointer ArithmeticBasic Pointer Arithmetic


72

float array[5];


float* qPtr = NULL;

pPtr++; /* pPtr now holds the address: &array[1] */

0x200C

0x2008

0x2004

array:

pPtr:

0x2008 0x200C 0x2010 0x2014 0x2018

0 1 2 3 4

NULL0x2000

qPtr:


73

float array[5];


float* qPtr = NULL;

pPtr++; /* pPtr = &array[1] */

pPtr += 3; /* pPtr now hold the address: &array[4] */

0x2018

0x2008

0x2004

array:

pPtr:

0x2008 0x200C 0x2010 0x2014 0x2018

0 1 2 3 4

NULL0x2000

qPtr:


74

float array[5];


float* qPtr = NULL;


pPtr += 3; /* pPtr = &array[4] */

qPtr = array + 2; /*qPtr now holds the address &array[2]*/

0x2018

0x2008

0x2004

array:

pPtr:

0x2008 0x200C 0x2010 0x2014 0x2018

0 1 2 3 4

0x20100x2000

qPtr:


75

float array[5];


float* qPtr = NULL;


pPtr += 3; /* pPtr = &array[4] */

qPtr = array + 2; /* qPtr = &array[2] */

printf(“%d\n”, pPtr-qPtr);

0x2018

0x2008

0x2004

array:

pPtr:

0x2008 0x200C 0x2010 0x2014 0x2018

0 1 2 3 4

0x20100x2000

qPtr:

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;}


77

RevisionRevision

• 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


78

Next LectureNext Lecture• Stacks

– abstract data type– main operations– implementation


79

Basic Data StructuresBasic Data Structures

• Stacks

• Queues

• Lists


80

Overview of StacksOverview of Stacks

• What is a Stack?

• Operations on a Stack– push, pop– initialize– status: empty, full

• Implementation of a Stack.

• Example: Reversing a sequence.


81

A StackA Stack

Top

Items on the Stack


82

PushPush

Top

After

Top

Before


83

PopPop

Top

Before After

Top

This comes off the stack


84

OperationsOperations

• 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


85

Stack PropertiesStack 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.


86

ImplementationImplementation

Top

index0

1

2

:

array(upside-down)


87

ImplementationImplementation

Top

float entry[MAXSTACK];

int top;0

1

2

:


88

#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


89

#define MAXSTACK 20

struct StackRec{ int top; float entry[MAXSTACK];};

typedef struct StackRec Stack;

Stack:

.

.

.

entry:

top:


90

#include <stdio.h>#include <stdlib.h>#include “stack.h”

void initializeStack(Stack* stackPtr){ stackPtr -> top = -1;}

top:

.

.

.

entry:

Stack:

addr of Stack

stackPtr:

-1


91

bool stackEmpty(const Stack* stackPtr){ if (stackPtr-> top < 0) { return true; } else { return false; }}


92

bool stackFull(const Stack* stackPtr){ if (stackPtr -> top >= MAXSTACK-1) { return true; } else { return false; }}


93

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; }}


94

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;}


95

#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”);}


96

RevisionRevision• Stack

• Operations on a Stack– push, pop– initialize– status: empty, full– others: clear, size

• Implementation.


97

Next LectureNext Lecture

• Queue

• Main Operations

• Implementation


98

Basic Data StructuresBasic Data Structures

• Stacks

• Queues

• Lists


99

OverviewOverview

• What is a Queue?

• Queue Operations.

• Applications.

• Linear Implementation.

• Circular Implementation.


100

InsertInsertBefore

Front RearAfter

Front Rear


101

DeleteDeleteBefore

Front Rear

After

Front RearThis comes off the queue


102

OperationsOperations

• 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?


103

ApplicationsApplications

• In operating systems, e.g. printer queues, process queues, etc.

• Simulation programs.

• Algorithms.


104

Linear ImplementationLinear Implementation

Front Rear

0 1 2 3 4 5 6 7


105

InsertInsert

Front Rear

0 1 2 3 4 5 6 7


106

InsertInsert

Front Rear

0 1 2 3 4 5 6 7


107

DeleteDelete

Front Rear

0 1 2 3 4 5 6 7

This comes off the queue


108

DeleteDelete

Front Rear

0 1 2 3 4 5 6 7

This comes off the queue


109

InsertInsert

Front Rear

0 1 2 3 4 5 6 7


110

InsertInsert

Front Rear

0 1 2 3 4 5 6 7

NO SPACE

HERE


111

InsertInsert

Front Rear

0 1 2 3 4 5 6 7

SPACE HERE


112

Circular ImplementationCircular Implementation07

1

2

34

5

6


113

Circular ImplementationCircular Implementation

Front Rear

0 1 2 3 4 5 6 7


114

InsertInsert

FrontRear

0 1 2 3 4 5 6 7


115

#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


116

#define MAXQUEUE 20

struct QueueRec{ int count; int front; int rear; float entry[MAXQUEUE];};

typedef struct QueueRec Queue;

Queue:

.

.

.

entry:

count:

front:

rear:


117

#include <stdio.h>#include <stdlib.h>#include “queue.h”

void initializeQueue(Queue* queuePtr){ queuePtr -> count = 0; queuePtr -> front = 0; queuePtr -> rear = MAXQUEUE-1;}

rear:

.

.

.

entry:

Queue:

addr of Queue

queuePtr:

19

count: 0

front: 0

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;}


122

RevisionRevision

• Queue

• Main Operations

• Implementation.


123

Basic Data TypesBasic Data Types

StackLast-In, First-Out (LIFO)initialize, push, pop, status

QueueFirst-In, First-Out (FIFO)initialize, Insert, delete, status

• List


124

OverviewOverview

• Lists.

• Operations.

• Abstract Data Types (ADT).

• Programming Styles.

• Implementations of Lists.


125

ListsLists

SEALFOXDEERAPE EMU0 1 3 42


126

InsertionInsertion

SEALFOXDEERAPE0 1 32

EMU Inserted at position 2

SEALFOXDEERAPE0 1 3 4

EMU2

Before:

After:


127

DeletionDeletion

SEALFOXDEERAPE0 1 3 4

EMU2

Delete item at position 3

SEALDEERAPE0 1 3

EMU2

Before:

After:


128

List OperationsList 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.


129

A List ADTA List ADT

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

A sequence of elements together with these operations:


130

Abstract Data Type (ADT)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.


131

A Stack ADTA Stack ADT

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



132

A Queue ADTA Queue ADT

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



133

ComparisonComparison

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


134

A Rational Number ADTA Rational Number ADT

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

Two integers together with these operations:


135

A String ADTA String ADT

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

A array of characters together with these operations:


136

Simple List ImplementationSimple List Implementation

0 1 2 3 4 5

APE DEER FOX SEAL

EMU


137


0 1 2 3 4 5

APE DEER FOX SEAL

EMU


138


0 1 2 3 4 5

APE DEER FOX SEALEMU


139

Linked List Implementation:Linked List Implementation:Using Array IndexUsing Array Index

DEER FOX APE SEAL

0 1 2 3 4 5

1 3 0 -1

data

marks last item

start

link to next item


140


DEER FOX APE SEAL

0 1 2 3 4 5

3 0 -1

startinsert: EMU

EMU

11


141


DEER FOX APE SEAL

0 1 2 3 4 5

4 3 0 -1

startinsert: EMU

EMU

1


142

Linked List Implementation:Linked List Implementation:Using PointersUsing Pointers

DEER FOX APE SEAL

0x2000 0x2008 0x2010 0x2018 0x2020 0x2018

0x2020 0x2018 0x2000 NULL

start

EMU

0x2008


143


DEER FOX APE SEAL

0x2000 0x2008 0x2010 0x2018 0x2020 0x2018

0x2020 0x2018 0x2000 NULL

start

EMU

0x2008

special pointerconstant


144

RevisionRevision

• List– initialize, insert, delete, position, status– implementations

• Difference between Stacks, Queues, and Lists.

• ADT.


145

OverviewOverview

• Linked Stack.– Push– Pop

• Linked Queue.– Insert– Delete


146

Linked StackLinked Stack

Top of the Stack

NULL pointer


147

#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

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

Initialize StackInitialize Stack


149

PushPush

Top

Top


150

PushPush

• create a new node for the item

• link the new node to the current top node

• make the new node the new top

void push(Stack* stackPtr, float item){ Node* newNodePtr = makeNode(item);

newNodePtr->nextPtr = stackPtr->topPtr; stackPtr->topPtr = newNodePtr;}

PushPush


152

PopPopTop

Top


153

PopPop

• 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

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;}

PopPop


155

Linked QueueLinked Queue

Front Rear


156

#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

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

Initialize QueueInitialize Queue


158

InsertInsert

Front Rear


159

InsertInsert

Front Rear

Front Rear


160

InsertInsert• 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

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->rearPtr = newNodePtr; queuePtr->count++; } }


162

DeleteDelete

Front Rear


163

DeleteDelete

Front Rear

RearFront


164

DeleteDelete

• 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

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); }}


167

RevisionRevision

• Linked Stack.– Initialize, Pop, Push.

• Linked Queue.– Initialize, Insert,Delete


168

OverviewOverview

• What is Dynamic Memory ?

• How to find the size of objects.

• Allocating memory.

• Deallocating memory.


169

Virtual MemoryVirtual Memory

Text Segment

Data Segment

Stack segment

program instructions

static and dynamic data

local variables, parameters

free memory


170


Text Segment

Static data

Heap

Stack segment

global variables, etc.

dynamic data


171


Text Segment

Static data

Heap

Stack segment

memory is allocated and deallocated as needed


172

What is Dynamic Memory?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


173

Example: Run-Time StackExample: 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.


174

#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);}

01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:

stackstack


175

#include <stdio.h>




01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:

stack

3.15a

b


176

#include <stdio.h>




01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:

stack

3.15a

b

3.15x


177

#include <stdio.h>




01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:

stack

3.15a

b

3.15x

line 16


178

#include <stdio.h>




01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:

stack

3.15a

b

3.15x

line 16

result


179

#include <stdio.h>




01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:

stack

3.15a

b

3.15x

line 16

9.9225result


180

#include <stdio.h>




01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:

stack

3.15a

b

3.15x

line 16

9.9225result


181

#include <stdio.h>




01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:

9.9225

stack

3.15a

b


182

#include <stdio.h>




01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:

9.9225

stack

3.15a

b


183

#include <stdio.h>




01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:

stackstack


184

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

}


185

How much memory to allocate?How much memory to allocate?

•The sizeof operator returns the size of an object, or type, in bytes.

•Usage:

sizeof(Type)

sizeof Object


186

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;


187

Notes on Notes on sizeofsizeof

•Do not assume the size of an object, or type; use sizeof instead.

•In DOS: 2 bytes (16 bits)•In GCC/Linux: 4 bytes (32 bits)•In MIPS: 4 bytes (32 bits)

Example: int n;


188

#include <stdio.h>

#define MAXNAME 80#define MAXCLASS 100

struct StudentRec{ char name[MAXNAME]; float mark;};


Example 2:


189

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;}

Example 2 (cont.):


190

Notes on Notes on sizeof sizeof (cont.)(cont.)•The size of a structure is not necessarily the sum of the sizes of its members.

Example: struct cardRec { char suit; int number;};

typedef struct cardRec Card;

Card hand[5];

printf(“%d\n”, sizeof(Card));printf(“%d\n”, sizeof hand);

“alignment” and “padding”

5*sizeof(Card)


191

Dynamic Memory: HeapDynamic 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)


192

#include <stdlib.h>

main(){ int* aPtr = NULL; aPtr = (int*)malloc(sizeof(int)); *aPtr = 5;

free(aPtr);}

Example 1:

NULL

stack

aPtr

heap


193

#include <stdlib.h>


free(aPtr);}

heap

0x3a04

NULL

stack

aPtr 0x3a04

Example 1:


194

#include <stdlib.h>


free(aPtr);}

heap

0x3a04

NULL

stack

aPtr 0x3a04

“type cast”

Example 1:


195

#include <stdlib.h>


free(aPtr);}

5

heap

0x3a04

stack

aPtr 0x3a04

Example 1:


196

#include <stdlib.h>


free(aPtr);}

0x3a04

stack

aPtr

Example 1:

heap


197

#include <stdlib.h>


free(aPtr);}

0x3a04

stack

aPtr

Example 1:

deallocates memory

heap


198

#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 = (int*)malloc(sizeof(int)); *bPtr = 6;}

Example 2:


199

Allocating MemoryAllocating Memory

• NeedNeed to include stdlib.h• malloc(n) returns a pointer to n bytes of

memory.

• AlwaysAlways check if malloc has returned the NULL pointer.

• ApplyApply a type cast to the pointer returned by malloc.


200

Deallocating MemoryDeallocating 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.• ShouldShould free memory no longer being used.


201

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);}

Example 3:


202

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:


203

Common ErrorsCommon 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.


204

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


205

RevisionRevision

• sizeof

• malloc

• free

• Common errors.


206

Overview of TopicOverview of Topic

• Review List Implementations.

• Nodes.

• Linked Stacks.

• Linked Queues

• Linked Lists.

• Other List Operations

Today’s Lecture


207

ListsLists

151031 60 1 3 42


208


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



209

InsertionInsertion

1510310 1 32

6 Inserted at position 2

1510310 1 3 4

62

Before:

After:


210


• 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


211


1 3 10 15 21

6


212

Expansion and InsertionExpansion and Insertion

1 3 10 15 21

1 3 10 15 21

6

6

Copy old array, leave space for the new value


213

DisadvantagesDisadvantages

• Lots of memory needs to be allocated.

• Lots of copying needs to be done.


214


3 15 1 21

0x2000 0x2008 0x2010 0x2018 0x2020

0x2020 0x2018 0x2000 NULL

start

10

0x2008

insert: 6


215

Method 1Method 1 start

3 15 1 21

0x2000 0x2008 0x2010 0x2018 0x2020

0x2020 0x2018 0x2000 NULL

10

0x2008

0x30F0 0x30F8 0x3100 0x3108 0x3110

newStart

0x3118

insert: 6

1 3

0x30F8 0x3100 0x3108 0x3110 0x3118 NULL

6 10 15 21

0x30F0

Copy old array, leave space for the new value


216

Method 2Method 2

3 15 1 21

0x2000 0x2008 0x2010 0x2018 0x2020

0x2020 0x2018 0x2000 NULL

start

10

0x2008

insert: 6

6newItem

0x30F0


217

Method 2Method 2

3 15 1 21

0x2000 0x2008 0x2010 0x2018 0x2020

0x30F0 0x2018 0x2000 NULL

start

10

0x2008

insert: 6

6newItem

0x30F0

0x2020


218

AdvantagesAdvantages

• Only a little amount of memory needs to be allocated.

• Only a little amount of copying needs to be done.


219

struct NodeRec{ float value; struct NodeRec* nextPtr;};

typedef struct NodeRec Node;

Node:

nextPtr:

value:


220

#ifndef NODE.H#define NODE.H

struct NodeRec{ float value; struct NodeRec* nextPtr;};

typedef struct NodeRec Node;

Node* makeNode(float item);

#endif


221

Make NodeMake 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

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; } }}


224

0x30F0 0x2124 6firstNodePtr: lastNodePtr: item:

0x30F0

0x2124

0x2A40

1

0x2A40nextPtr:

value:

6

NULLnextPtr:

value:

3

0x2124nextPtr:

value:


225

Linked StructureLinked Structure

10x30F0

6

3 0x2124

0x2124

0x2A40

NULL

0x2A40 0x30F0firstNodePtr:


226


10x30F0

3 0x21240x2A40

0x2A40 0x30F0firstNodePtr:

60x2124 NULL


227


1

3

firstNodePtr:

6


228


firstNodePtr:


229

RevisionRevision

• Node

• How to make a new Node

• Linked Structure


230

OverviewOverview

• Operations for Lists.

• Implementation of Linked Lists.

• Double Linked Lists.


231

List OperationsList 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.


232

ComparsionComparsion

Linked Storage– Unknown list size.– Flexibility is needed.

Contiguous Storage– Known list size.– Few insertions and deletions are made within the list.– Random access


233

Linked ListLinked List

Head

0 1 2 3


234

#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


235

void initializeList(List* listPtr){ listPtr->headPtr = NULL; listPtr->count = 0;}

Initialize ListInitialize List

count

headPtr

0

NULL

listPtr addr of list


236

Set PositionSet 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


237


Head

0 21

2 position


238

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;}


239


Head

2 position

0x4000

0 i

NodePtr

0x30a80x20300x4000


240


Head

2 position

0x4000

0 i

NodePtr

0x30a80x20300x4000


241


Head

2 position

0x2030

1 i

NodePtr

0x30a80x20300x4000


242


Head

2 position

0x30a8

2 i

NodePtr

0x30a80x20300x4000


243

InsertInsert

Head

0 21

If we insert it at position 0.

Head

10 2


244

InsertInsert

Head

0 21

If we insert it at position 0.

0 21 3

Head


245

Instead, suppose we insert it at position 1.

Head

0 21


246

Head

Instead, suppose we insert it at position 1.

0 32

1


247

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++;}


248

Inserting – New ListInserting – New List

Head

0 position

0x30a8

NULL

newNodePtr

0x30a8


249

Inserting – New ListInserting – New List

Head

0 position

0x30a8 newNodePtr

0x30a8


250

Inserting – Start of ListInserting – Start of List

HeadHead0x30a80x2008

0x2000

0position

0x2000newNodePtr


251



0x2000

0position

0x2000newNodePtr


252



0x2000

0position

0x2000newNodePtr


253

Inserting – Inside the ListInserting – Inside the List

0x2000

1position

0x2000newNodePtr

Head

0x30500x3080

NodePtr 0x3080


254


0x2000

1position

0x2000newNodePtr

Head

0x30500x3080

NodePtr 0x3080


255


0x2000

1position

0x2000newNodePtr

Head

0x30500x3080

NodePtr 0x3080


256

DeleteDelete

2

Head

310

If we delete the Node at position 0.

Head

210


257

Head


2 310


258

Head


2 210


259

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); } else { fprintf(stderr, “List is empty or invalid position.\n”); exit(1); }}


260

Deleting – 1Deleting – 1stst Node Node

Head

0 position

0x4000 NodePtr

0x30a80x20300x4000


261

Head0 position

0x4000 NodePtr

0x30a80x20300x4000



262

Head0 position

0x4000 NodePtr

0x30a80x2030



263

Deleting – Middle NodeDeleting – Middle Node

Head

1 position

0x2030 OldNodePtr

0x30a80x20300x4000

0x2030 NodePtr


264

Head

0x30a80x20300x4000


1 position

0x2030 OldNodePtr

0x2030 NodePtr


265

Head

0x30a80x4000


1 position

0x2030 OldNodePtr

0x2030 NodePtr


266

Double Linked List OperationsDouble 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 directionsin both directions.


267

Double Linked ListDouble Linked List

Current

0 1 2 3 4


268

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;


269

Insert at endInsert at end

currentPtrnewPtr

0x4000 0x3080 0x2030 0x2000

0x4000 0x3080

0x3080 0x2030 NULL

NULLNULL

NULL

0x2000prevPtr

0x2030


270


newPtr

0x4000 0x3080 0x2030 0x2000

0x4000 0x3080

0x3080 0x2030 0x2000

NULLNULL

NULL

0x2000prevPtr

0x2030

currentPtr


271


newPtr

0x4000 0x3080 0x2030 0x2000

0x4000 0x3080

0x3080 0x2030 0x2000

NULLNULL

0x2030

0x2000prevPtr

0x2030

currentPtr


272

Insert inside the listInsert inside the list

newPtr

0x4000 0x3080 0x2030

0x2000

0x4000 0x3080

0x3080 0x2030NULL

NULL

NULL

NULL

0x2000prevPtr

0x3080

currentPtr


273


newPtr

0x4000 0x3080 0x2030

0x2000

0x4000 0x3080

0x3080 0x2030NULL

NULL

2030

NULL

0x2000prevPtr

0x3080

currentPtr


274


newPtr

0x4000 0x3080 0x2030

0x2000

0x4000 0x3080

0x3080 0x2030NULL

NULL

2030

3080

0x2000prevPtr

0x3080

currentPtr


275


newPtr

0x4000 0x3080 0x2030

0x2000

0x4000 0x2000

0x3080 0x2030NULL

NULL

2030

3080

0x2000prevPtr

0x3080

currentPtr


276


newPtr

0x4000 0x3080 0x2030

0x2000

0x4000 0x2000

0x3080 0x2000NULL

NULL

2030

3080

0x2000prevPtr

0x3080

currentPtr


277

Delete from endDelete from end

oldPtr

0x4000 0x3080 0x2030

0x4000 0x3080

0x3080 0x2030 NULL

NULL

0x2030currentPtr

prevPtr 0x3080


278


0x4000 0x3080 0x2030

0x4000 0x3080

0x3080 NULL NULL

NULL

oldPtr 0x2030currentPtr

prevPtr 0x3080


279


0x4000 0x3080

0x4000

0x3080 NULL

NULL


prevPtr 0x3080


280

Delete from inside listDelete from inside list

0x4000 0x3080 0x2030

0x4000 0x3080

0x3080 0x2030 NULL

NULL


prevPtr 0x4000


281


0x4000 0x3080 0x2030

0x4000 0x3080

0x2030 0x2030 NULL

NULL


prevPtr 0x4000


282


0x4000 0x3080 0x2030

0x4000 0x4000

0x2030 0x2030 NULL

NULL


prevPtr 0x4000


283


Head

0x4000 0x2030

0x4000

0x2030 NULL

NULL


prevPtr 0x4000


284

RevisionRevision

• Linked List.

• Benefits of different implementations.

• Double Linked List.


285

OverviewOverview

• Selection Sort

• Insertion Sort

• Linear Search.

• Binary Search.

• Growth Rates.

• Implementation.


286

Selection SortSelection 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.


287


01 2 3 45 6

01 2 345 6

01 23 4 5 6

01 2 3 4 5 6

…


288

Insertion SortInsertion 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.


289

Insertion SortInsertion Sort01 2 3 45 6

01 2 3 45 6

0 1 2 3 45 6

…

0 1 2 3 45 6

0 1 2 3 45 6

0 1 2 3 45 6


290

Linear SearchLinear Search

-7 9 -5 2 8 3 -4

0 1 2 3 4 5 6

current

• Target is -5


291


-7 9 -5 2 8 3 -4

0 1 2 3 4 5 6

current

• Target is -5


292


-7 9 -5 2 8 3 -4

0 1 2 3 4 5 6

• Target is -5

current


293


-7 9 -5 2 8 3 -4

0 1 2 3 4 5 6

current

• Numbers can be in any order.

• Works for Linked Lists.


294

Binary SearchBinary Search

mid

target

Lower Part


295


mid

target

Upper Part


296


mid

• Need– List to be sorted.– To be able to do random accesses.

target

Upper Part


297


-1 2 3 5 8 10 15

0 1 2 3 4 5 6

mid highlow

target


298


-1 2 3 5 8 10 15

0 1 2 3 4 5 6

mid highlow

target


299


-1 2 3 5 8 10 15

0 1 2 3 4 5 6

high

mid

low

target


300

Other Uses of Binary SearchOther Uses of Binary Search

• To find where a function is zero.

• Compute functions.

• Tree data structures.

• Data processing.

• Debugging code.


301

Growth Rates / ComplexityGrowth 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)

Recall:


302


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.


303

/* * 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; }}

Find where the Maximum is.Find where the Maximum is.


304

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; }}


305

Insertion SortInsertion 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.


306

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; }}


307


-7 9 -5 2 8 3 -4

0 1 2 3 4 5 6

current

• Numbers can be in any order.

• Works for Linked Lists.


308

int linearSearch(float array[], int size, int target){ int i;

for (i = 0; i < size; i++) { if (array[i] == target) { return i; } } return -1;}



309


mid

• Need– List to be sorted.– To be able to do random accesses.


310

Case 1: target < list[mid]

lower mid upper

target

New upper

list:


311

Case 2: list[mid] < target

lower mid upper

target

New lower

list:


312

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 wherethe target could be foundhalves in size each time


313

ComparisonComparisonArray Linked List

Selection Sort

Insertion Sort

Linear Search

Binary Search


314

RevisionRevision• Selection Sort• Insertion Sort• Linear Search• Binary Search


315

OverviewOverview

• Unary Recursion

• Binary Recursion

• Examples

• Features

• Stacks

• Disadvantages

• Advantages


316

What is Recursion - RecallWhat is Recursion - Recall

• A procedure defined in terms of itself

• Components:

– Base case

– Recursive definition

– Convergence to base case


317

double power(double x, int n){ int i double tmp = 1;

if (n > 0) { for (i = 0; i < n; i++) { tmp *= x; } }

return tmp;}


318

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;}


319

Unary RecursionUnary Recursion

• Functions calls itself once (at most)• Usual format:

function RecursiveFunction ( <parameter(s)> ){

if ( base case ) thenreturn base value

elsereturn RecursiveFunction ( <expression> )

}


320

Unary RecursionUnary Recursion

/* Computes the factorial */

int factorial ( int n ){ if ( n <= 1 ) { return 1; } else { return n*factorial(n-1); }}

function Factorial ( n ){

if ( n is less than or equal to 1)

then

return 1

else

return n Factorial ( n - 1 )}


321

Binary RecursionBinary 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,...


322

Binary RecursionBinary Recursion

/* Compute the n-th Fibonacci number */long fib ( long n ){ if ( n <= 1 ) return n ; else return fib( n - 2 ) + fib( n - 1 );}

function Fibonacci ( n ){ if ( n is less than or equal to 1 ) then return n else return Fibonacci ( n - 2 ) + Fibonacci ( n - 1 )}


323

Copy ListCopy ListHeadPtr

struct LinkedListRec{ int count; Node* headPtr;};

typedef struct LinkedListRec List;


324

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


325

Node* copyNodes(Node* oldNodePtr){ Node* newNodePtr = NULL:

if (oldNodePtr != NULL) { newNodePtr = makeNode(oldNodePtr->value); newNodePtr->nextPtr = copyNodes(oldNodePtr->nextPtr); }

return newNodePtr;}


326

Copy NodesCopy NodesOldNodePtr

NewNodePtr


327


NewNodePtr

NewNodePtr->next is set to the Result of calling copy nodes onThe remainder of the list


328


NewNodePtrNewNodePtr


329


NewNodePtrNewNodePtr NewNodePtr

NULL


330

Copy NodesCopy Nodes

NewNodePtr NewNodePtr

OldNodePtr


331

Copy NodesCopy Nodes

NewNodePtr

OldNodePtr


332

Recursion ProcessRecursion Process

Every recursive process consists of:

1. A base case. 2. A general method that reduces to the base case.


333

Types of RecursionTypes of Recursion

• Direct.

• Indirect.

• Linear.

• n-ary (Unary, Binary, Ternary, …)


334

StacksStacks

• Every recursive function can be implemented using a stack and iteration.

• Every iterative function which uses a stack can be implemented using recursion.


335



x = 2, n = 5

tmp = 1


336



x = 2, n = 5

tmp = 1

x = 2, n = 2

tmp = 1


337



x = 2, n = 5

tmp = 1

x = 2, n = 2

tmp = 1

x = 2, n = 1

tmp = 1


338



x = 2, n = 5

tmp = 1

x = 2, n = 2

tmp = 1

x = 2, n = 1

tmp = 1

x = 2, n = 0

tmp = 1


339



x = 2, n = 5

tmp = 1

x = 2, n = 2

x = 2, n = 1

tmp = 1

tmp = 1*1*2 = 2


340



x = 2, n = 5

tmp = 1

x = 2, n = 2

tmp = 2*2 = 4


341



x = 2, n = 5

tmp = 4*4*2 = 32


342

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

Stackn = 5, x = 2


343


5

Stackn = 5, x = 2


344


5

2

Stackn = 2, x = 2


345


5

2

1

Stackn = 1, x = 2


346


5

2

1

Stackn = 0, x = 2

tmp = 1


347


5

2

Stackn = 0, x = 2

tmp = 2


348


5

Stackn = 0, x = 2

tmp = 4


349


Stackn = 0, x = 2

tmp = 32


350

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;}


351

DisadvantagesDisadvantages

• May run slower.– Compilers– Inefficient Code

• May use more space.


352

AdvantagesAdvantages

• More natural.

• Easier to prove correct.

• Easier to analysis.

• More flexible.


353

Free List – Non RecursiveFree List – Non RecursiveHead

/* Delete the entire list */void FreeList(Node* head){ Node* next;

while (head != NULL) { next=head->next; free(head); head=next; }}

0x2000 0x4c680x258a


354

Free List – Non RecursiveFree List – Non Recursivehead



next

0x2000 0x258a 0x4c68


355




next

0x258a 0x4c68


356




next

NULL

0x4c68


357




next

NULL

Has local variables on the stack. This is performing two assignments and one comparison per iteration.


358

Free ListFree ListHead

/* Delete the entire list */void FreeList(Node* list){ if (list==NULL) return; FreeList(list->next); free(list);}


359

Free ListFree Listlist


0x258a 0x4c680x2000

Stack in memory

0x2000


360



0x258a 0x4c680x2000

0x2000

0x258a

Stack in memory


361



0x258a 0x4c680x2000

0x2000

0x258a

0x4c68

Stack in memory


362



0x258a 0x4c680x2000

NULL

0x2000

0x258a

0x4c68

Stack in memory


363



0x258a 0x4c680x2000

0x2000

0x258a

0x4c68

Stack in memory


364



0x258a0x2000

0x2000

0x258a

Stack in memory


365



0x2000

0x2000

Stack in memory


366

Free ListFree ListHead


0x2000

Has no local variables on the stack. This is performing one assignment and one comparison per function call.


367

RevisionRevision

• Recursion


368

OverviewOverview

• Trees.

• Terminology.

• Traversal of Binary Trees.

• Expression Trees.

• Binary Search Trees.


369

TreesTrees

• Family Trees.

• Organisation Structure Charts.

• Program Design.

• Structure of a chapter in a book.


370

Parts of a TreeParts of a Tree


371


nodes


372

Parts of a TreeParts of a Treeparent node


373

Parts of a TreeParts of a Treechild

nodesparent node


374

Parts of a TreeParts of a Treechild

nodesparent node


375


root node


376

Parts of a TreeParts of a Treeleaf

nodes


377


sub-tree


378


sub-tree


379


sub-tree


380


sub-tree


381

Binary TreeBinary Tree• Each node can have at most 2 children


382

TraversalTraversal

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


383

Preorder TraversalPreorder Traversal

• Visit the node.

• Traverse the left subtree.

• Traverse the right subtree.


384

Example: PreorderExample: Preorder

31

43

64

20 40 56

28 33 47 59

89

43 31 20 28 40 33 64 56 47 59 89


385

Inorder TraversalInorder Traversal


• Visit the node.



386

Example: InorderExample: Inorder

31

43

64

20 40 56

28 33 47 59

89

20 3128 4033 43 5647 59 64 89


387

Postorder TraversalPostorder Traversal



• Visit the node.


388

Example: PostorderExample: Postorder

31

43

64

20 40 56

28 33 47 59

89

2028 40 3133 5647 59 6489 43


389

Expression TreeExpression Tree

• A Binary Tree built with operands and operators.

• Also known as a parse tree.

• Used in compilers.


390

Example: Expression TreeExample: Expression Tree

/

+

/

1 3 *

6 7

4

1/3 + 6*7 / 4


391

NotationNotation

• Preorder– Prefix Notation

• Inorder– Infix Notation

• Postorder– Postfix Notation


392

Example: InfixExample: Infix

/

+

/

1 3 *

6 7

4

1 / 3 + *6 7 / 4


393

7

//

/

1

+

/

3 *

6

4

Example: PostfixExample: Postfix

Recall: Reverse Polish Notation

1

1 3

3

6

6

7

7

*

*

4

4

/

/

+

+


394

/

+

/

1 3 *

6 7

4

Example: PrefixExample: Prefix

+ / 1 3 / * 6 7 4


395

Binary Search Tree 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.


396

Example 1:

31

43

64

20 40 56

28 33 47 59

89

key is an integer


397

Example 1:

31

43

64

20 40 56

28 33 47 59

89

key is an integer


398

InsertInsert

• Create new node for the item.

• Find a parent node.

• Attach new node as a leaf.


399

InsertInsert

31

43

64

20 40 56

28 33 47 59

89

Example:57


400

InsertInsert

31

43

64

20 40 56

28 33 47 59

89

Example:57

57


401

Search: ChecklistSearch: 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.


402

SearchSearch

31

43

64

20 40 56

28 33 47 59

89

Example: 59

57 found


403

SearchSearch

31

43

64

20 40 56

28 33 47 59

89

Example: 61

57 failed


404

RevisionRevision

• Binary Tree

• Preorder, Inorder, Postorder Traveral

• Expression Trees

• Prefix, Infix, and Postfix notation

• Insert and Search


405

OverviewOverview

• Binary Search Trees.

• Hash Tables.


406

Recall - Binary Search Tree 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.


407

Example 1:

31

43

64

20 40 56

28 33 47 59

89

key is an integer


408

Fred

Dan Mary

Alan Eve

Bill Eric

Kate

Greg Len

Sue

Example 2: key is a string


409

Binary Tree NodeBinary Tree Node

entry

link to right child nodelink to left

child node


410

struct TreeNodeRec{ int key;

struct TreeNodeRec* leftPtr; struct TreeNodeRec* rightPtr;};

typedef struct TreeNodeRec TreeNode;

Binary Search Tree Node Binary Search Tree Node

Example 1:


411

Example 2:

Binary Search Tree Node Binary Search Tree Node

#define MAXLEN 15

struct TreeNodeRec{ char key[MAXLEN];




412

Recall:

maximumstring length

is fixed

#define MAXLEN 15

struct TreeNodeRec{ char key[MAXLEN];




413

struct TreeNodeRec{ char* key;



Example 3:


414

Recall:

struct TreeNodeRec{ char* key;

struct TreeNodeRec* left; struct TreeNodeRec* right;};


•Allows strings of arbitrary length.

•Memory needs to be allocated dynamically before use.

•Use strcmp to compare strings.


415


416

struct BookRec{ char* author; char* title; char* publisher; /* etc.: other book information. */};

typedef struct BookRec Book;

Book Record

key


417

struct TreeNodeRec{ Book info; struct TreeNodeRec* leftPtr; struct TreeNodeRec* rightPtr;};


Example 4: Binary Search Tree Node


418

struct TreeNodeRec{ float key;



Tree NodeTree Node


419

#ifndef TREE_H#define TREE_H

struct TreeNodeRec{ float key; struct TreeNodeRec* leftPtr; struct TreeNodeRec* rightPtr;};


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


420

MakeNodeMakeNode

• 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


421

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;}


422

0x2000

newNodePtr NULL

0x2000newNodePtr

0x20000x2000newNodePtr 3.3

NULL NULL

value 3.3


423

InorderInorder

• Inorder traversal of a Binary Search Tree always gives the sorted order of the keys.

void printInorder(TreeNode* nodePtr){

}

initially, pointerto root node


424

InorderInorder



traverse left sub-tree visit the node traverse right sub-tree

}


425

InorderInorder



printInorder(nodePtr->leftPtr); printf(“ %f, nodePtr->key); printInorder(nodePtr->rightPtr);

}


426

InorderInorder


void printInorder(TreeNode* nodePtr){ if (nodePtr != NULL) { printInorder(nodePtr->leftPtr); printf(“ %f”, nodePtr->key); printInorder(nodePtr->rightPtr); }}


427

InorderInorder

void printInorder(TreeNode* nodePtr){ if (nodePtr != NULL){ printInorder(nodePtr->leftPtr); printf(“ %f”, nodePtr->key); printInorder(nodePtr->rightPtr); }}

nodePtr


428

InorderInorder


nodePtr


429

InorderInorder


nodePtr


430

InorderInorder


nodePtr


431

InorderInorder


nodePtr


432

InorderInorder


nodePtr


433

InorderInorder


nodePtr


434

InorderInorder


nodePtr


435

InorderInorder


nodePtr


436

InorderInorder


nodePtr


437

InorderInorder


nodePtr


438

InorderInorder


nodePtr


439

InorderInorder


nodePtr


440

InorderInorder


nodePtr


441

InorderInorder


nodePtr


442

InorderInorder


nodePtr


443

InorderInorder


nodePtr


444

InorderInorder


nodePtr


445

InorderInorder


nodePtr


446

InorderInorder


nodePtr


447

InorderInorder


nodePtr


448

InorderInorder


nodePtr


449

InorderInorder


nodePtr


450

InorderInorder


nodePtr


451

SearchSearch

31

43

64

20 40 56

28 33 47 59

89

Example: 59

57 found


452

SearchSearch

31

43

64

20 40 56

28 33 47 59

89

Example: 61

57 failed


453

Search: ChecklistSearch: 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.


454

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;}


455

/* …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… */

Function Call to SearchFunction Call to Search


456

SearchSearch

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;}

1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Find 0.7nodePtr


457

SearchSearch


1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Find 0.7nodePtr


458

SearchSearch


1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Find 0.7nodePtr


459

SearchSearch


1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Find 0.7nodePtr


460

SearchSearch


1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Find 0.5nodePtr


461

SearchSearch


1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Find 0.5nodePtr


462

SearchSearch


1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Find 0.5nodePtr


463

SearchSearch


1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Find 0.5nodePtr


464

SearchSearch


1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Find 0.5nodePtr


465

InsertInsert

31

43

64

20 40 56

28 33 47 59

89

Example:57


466

InsertInsert

31

43

64

20 40 56

28 33 47 59

89

Example:57

57


467

InsertInsert

• Create new node for the item.

• Find a parent node.

• Attach new node as a leaf.


468

Insert: RecursiveInsert: 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.


469

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;}


470

/* …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… */

Function Call to InsertFunction Call to Insert


471

InsertInsert

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;}

1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Insert 0.9nodePtr


472

InsertInsert



1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Insert 0.9nodePtr


473

InsertInsert



1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Insert 0.9nodePtr


474

InsertInsert



1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Insert 0.9nodePtr


475

InsertInsert



1.0

1.81.1

2.71.4

1.9

0.4 0.7

0.80.3

0.6

Insert 0.9nodePtr

0.9


476

SortingSorting

To sort a sequence of items:

• Insert items into a Binary Search Tree.

• Then Inorder Traverse the tree.


477

Sorting: AnalysisSorting: Analysis

• Insert (i+1)th item: ~ log2(i) comparisons

~ log2 n

• Average Case: O(n log(n))


478

SortSort

Sort the following list into a binary search tree

0.51.0 0.7 2.12.5 3.6


479

SortSort

0.51.0 0.7 2.12.5 3.6

1.0



480

SortSort

0.51.0 0.7 2.12.5 3.6

1.0

2.5



481

SortSort

0.51.0 0.7 2.12.5 3.6

1.0

2.50.5



482

SortSort

0.51.0 0.7 2.12.5 3.6

1.0

2.50.5

0.7



483

SortSort

1.0

2.50.5

0.7 3.6


0.51.0 0.7 2.12.5 3.6


484

SortSort

0.51.0 0.7 2.12.5 3.6

1.0

2.50.5

0.7 3.62.1



485

Sorting: AnalysisSorting: Analysis

• Insert (i+1)th item: ~ i comparisons

Example:

Insert: 1, 3, 7, 9, 11, 15

• Worst Case: O(n2)


486

RevisionRevision

• Binary Search Tree

• Make Tree Node, Insert item, Search for an item, and Print Inorder.

• Tree sort.


487

OverviewOverview

• Divide and Conquer

• Merge Sort

• Quick Sort


488

SearchSearch

Divide and ConquerDivide and Conquer

SearchSearch

SearchSearch

Recall: Binary Search


489

SortSort


SortSort SortSort

SortSort SortSort SortSort SortSort


490


CombineCombine

CombineCombine CombineCombine


491


module sort(array){ if (size of array > 1) { split(array, firstPart, secondPart) sort(firstPart) sort(secondPart) combine(firstPart, secondPart) }}


492




493




494




495




496

Merge SortMerge Sort

Sort Sort

Merge


497

array:array:

sizesize


tmp:tmp:

tmpArrayPtr:tmpArrayPtr:


498

array[mid]array[mid]array[0]array[0]

midmid (size - mid)(size - mid)

firstPart : array

secondPart : array + mid



499


mergeListmergeList

tmp:tmp:

array:array:


500


tmp:tmp:

array:array:


501


array:array:


502

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);}


503

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]; } }}


504

mergeArraysmergeArrays

3 5 15 28 30 6 10 14 22 43 50a:a: b:b:

aSize: 5aSize: 5 bSize: 6bSize: 6

Example:

tmp:tmp:


505


5 15 28 30 10 14 22 43 50a:a: b:b:

Example:

tmp:tmp:

i=0i=0

k=0k=0

j=0j=0

3 6


506


5 15 28 30 10 14 22 43 50a:a: b:b:

Example:

tmp:tmp:

i=0i=0

k=0k=0

3

j=0j=0

3 6


507


3 15 28 30 10 14 22 43 50a:a: b:b:

Example:

tmp:tmp:

i=1i=1 j=0j=0

k=1k=1

3 5

5 6


508


3 5 28 30 10 14 22 43 50a:a: b:b:

Example:

3 5tmp:tmp:

i=2i=2 j=0j=0

k=2k=2

6

15 6


509


3 5 28 30 6 14 22 43 50a:a: b:b:

Example:

3 5 6tmp:tmp:

i=2i=2 j=1j=1

k=3k=3

15 10

10


510

10


3 5 28 30 6 22 43 50a:a: b:b:

Example:

3 5 6tmp:tmp:

i=2i=2 j=2j=2

k=4k=4

15 10 14

14


511

1410


3 5 28 30 6 14 43 50a:a: b:b:

Example:

3 5 6tmp:tmp:

i=2i=2 j=3j=3

k=5k=5

15 10 22

15


512

1410


3 5 30 6 14 43 50a:a: b:b:

Example:

3 5 6tmp:tmp:

i=3i=3 j=3j=3

k=6k=6

15 10 22

2215

28


513

1410


3 5 30 6 14 50a:a: b:b:

Example:

3 5 6tmp:tmp:

i=3i=3 j=4j=4

k=7k=7

15 10 22

2815

28 43

22


514

1410


3 5 6 14 50a:a: b:b:

Example:

3 5 6tmp:tmp:

i=4i=4 j=4j=4

k=8k=8

15 10 22

3015

28 43

22

30

28


515

1410


3 5 6 14 50a:a: b:b:

Example:

3 5 6 30tmp:tmp:

i=5i=5 j=4j=4

k=9k=9

15 10 22

15

28 43

22

30

28 43 50

Done.


516

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]) { tmp[k] = a[i]; i++; } else { tmp[k] = b[j]; j++; } }}


517

Merge Sort and Linked ListsMerge Sort and Linked Lists

Sort Sort

Merge


518

Merge Sort AnalysisMerge 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.


519

Quick SortQuick Sort

x < p p p <= x

Partition

Sort Sort


520

Quick SortQuick SortExample:

5 89 35 10 24 15 37 13 20 17 70array:array:

size: 11size: 11


521


5 89 35 14 24 15 37 13 20 7 70array:array:

“pivot element”

15


522

partition:partition:


5 89 35 14 24 37 13 20 7 70array:array: 15

5 89 35 14 24 37 13 20 7 7015

7 14 5 13 15 35 37 89 20 24 70

index: 4index: 4


523


array:array: 7 14 5 13 15 35 37 89 20 24 70

index: 4index: 4

indexindex (size - index - 1)(size - index - 1)


524


indexindex (size - index - 1)(size - index - 1)

array[0]array[0] array[index + 1]array[index + 1]

firstPart : array

secondPart : array + index + 1

14 5 13 15 37 89 20 24 707 35


525

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); }}

Quick SortQuick Sort


526

Partition: ChecklistPartition: Checklist

p

p

00

p x < p p <= x

p x < p p <= x

px < p p <= x


527

PartitionPartitionExample:

5 89 35 14 24 15 37 13 20 7 70array:array: 15

mid: 4mid: 4

15 89 35 14 24 5 37 13 20 7 70

5

00


528


array:array:

k=1k=1

15 89 35 14 24 5 37 13 20 7 70

00


529


array:array:

k:1k:1

15 89 35 14 24 5 37 13 20 7 70

index:0index:0

89


530


array:array:

k:2k:2

15 89 35 14 24 5 37 13 20 7 70

index:0index:0

35


531


array:array:

k:3k:3

15 89 35 14 24 5 37 13 20 7 70

index:0index:0

14


532


array:array:

k:3k:3

15 89 35 14 24 5 37 13 20 7 70

index:1index:1

8914


533


array:array:

k:4k:4

15 14 35 89 24 5 37 13 20 7 70

index:1index:1

24


534


array:array:

k:5k:5

15 14 35 89 24 5 37 13 20 7 70

index:1index:1

5


535


array:array:

k:5k:5

15 14 35 89 24 5 37 13 20 7 70

index:2index:2

5 35


536


array:array:

k:6k:6

15 14 89 24 37 13 20 7 70

index:2index:2

5 35 37


537


array:array:

k:7k:7

15 14 89 24 37 13 20 7 70

index:2index:2

5 35

etc...


538


array:array:

k:11k:11

15 14 13 7 37 89 20 24 70

index:4index:4

5 35


539


array:array: 15 14 13 7 37 89 20 24 70

index:4index:4

5 35


540


array:array: 15 14 13 7 37 89 20 24 70

index:4index:4

5 35157

x < 15x < 15 15 <= x15 <= x


541

Example:

array:array: 15 14 13 7 37 89 20 24 705 35157

x < 15x < 15 15 <= x15 <= x

pivot now incorrect position


542

Example:

14 13 37 89 20 24 705 357

14 1357 37 89 20 24 7035

15

Sort Sort


543

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;}


544

Quick Sort AnalysisQuick 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.


545

RevisionRevision

• Merge Sort

• Quick Sort

1 lectures on data structures and c 3ed cs(csi33) by, chandrashekar a.m

Documents