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

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.

Data Structures and AlgorithmsData Structures and Algorithms

• Programs.

• Different problems.

• Operations.

• Size of data.

• Resources available.

Overview of LectureOverview of Lecture

• Basic data structures.

• How to manipulate them.

• How to implement them.

• Other algorithms and how to implement them.

This Lecture - ReviewThis Lecture - Review

• Basic C data types

• Boolean

• 1D and multidimensional arrays

• Strings

• Input/Output

• File I/O• Structures and typedef

Basic Data types in CBasic Data types in C

• int

• char

• float

• double

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

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

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

• 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

• 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

• 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

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

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?

Review -Review - struct struct

• Members may have different types.

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

members as “fields”

structname:

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

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

PreparationPreparationNext lecture: Pointers

OverviewOverview

• Revision of Pointers

• Basic Pointer Arithmetic

• Pointers and Arrays

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

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;

Pointers and Function ArgumentsPointers and Function Arguments

y: 2swap

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

Solution 1

0x2000

0x2010

#include <stdio.h>

Solution 1

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>

Solution 1

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>

Solution 1

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>

Solution 1

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>

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

Solution 2

0x2000

0x2010

#include <stdio.h>

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

addr of x

addr of y

Solution 2

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>

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

addr of x

addr of y

Solution 2

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>

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

addr of x

addr of y

Solution 2

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>

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

addr of x

addr of y

Solution 2

0x2000

0x2010

0x2060

0x2038

0x2040

#include <stdio.h>

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

Solution 2

0x2000

0x2010

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

struct DataBaseRec{

typedef struct DataBaseRec DataBase;

/* Very Large Structure */

DataBasereadNewEntry(DataBase theDataBase){

return theDataBase;}

voidprintDataBase(DataBase theDataBase){

/* Some code */

/* Some more code */

voidreadNewEntry(DataBase* dataBasePtr){

voidprintDataBase(const DataBase* dataBasePtr){

/* Some code */

(DataBase*

Address of Database

Database*

/* Some code */

Database cannot change in this function.

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?

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.

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;

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:

float array[5];

float* pPtr = array;

float* qPtr = NULL;

0x2008

0x2004

array:

0x2008 0x200C 0x2010 0x2014 0x2018

0 1 2 3 4

NULL0x2000

Basic Pointer ArithmeticBasic Pointer Arithmetic

float array[5];

float* qPtr = NULL;

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

0x200C

0x2008

0x2004

array:

0x2008 0x200C 0x2010 0x2014 0x2018

0 1 2 3 4

NULL0x2000

float array[5];

float* qPtr = NULL;

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

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

0x2018

0x2008

0x2004

array:

0x2008 0x200C 0x2010 0x2014 0x2018

0 1 2 3 4

NULL0x2000

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:

0x2008 0x200C 0x2010 0x2014 0x2018

0 1 2 3 4

0x20100x2000

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:

0x2008 0x200C 0x2010 0x2014 0x2018

0 1 2 3 4

0x20100x2000

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

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

Next LectureNext Lecture• Stacks

– abstract data type– main operations– implementation

Basic Data StructuresBasic Data Structures

• Stacks

• Queues

• Lists

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.

A StackA Stack

Items on the Stack

PushPush

Before

PopPop

Before After

This comes off the stack

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

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.

ImplementationImplementation

index0

array(upside-down)

ImplementationImplementation

float entry[MAXSTACK];

int top;0

#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

#define MAXSTACK 20

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

typedef struct StackRec Stack;

Stack:

entry:

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

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

entry:

Stack:

addr of Stack

stackPtr:

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

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

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

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

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

RevisionRevision• Stack

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

• Implementation.

Next LectureNext Lecture

• Queue

• Main Operations

• Implementation

Basic Data StructuresBasic Data Structures

• Stacks

• Queues

• Lists

OverviewOverview

• What is a Queue?

• Queue Operations.

• Applications.

• Linear Implementation.

• Circular Implementation.

InsertInsertBefore

Front RearAfter

Front Rear

DeleteDeleteBefore

Front Rear

Front RearThis comes off the queue

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?

ApplicationsApplications

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

• Simulation programs.

• Algorithms.

Linear ImplementationLinear Implementation

Front Rear

0 1 2 3 4 5 6 7

InsertInsert

Front Rear

0 1 2 3 4 5 6 7

InsertInsert

Front Rear

0 1 2 3 4 5 6 7

DeleteDelete

Front Rear

0 1 2 3 4 5 6 7

This comes off the queue

DeleteDelete

Front Rear

0 1 2 3 4 5 6 7

This comes off the queue

InsertInsert

Front Rear

0 1 2 3 4 5 6 7

InsertInsert

Front Rear

0 1 2 3 4 5 6 7

NO SPACE

InsertInsert

Front Rear

0 1 2 3 4 5 6 7

SPACE HERE

Circular ImplementationCircular Implementation07

Circular ImplementationCircular Implementation

Front Rear

0 1 2 3 4 5 6 7

InsertInsert

FrontRear

0 1 2 3 4 5 6 7

#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

#define MAXQUEUE 20

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

typedef struct QueueRec Queue;

Queue:

entry:

count:

front:

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

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

entry:

Queue:

addr of Queue

queuePtr:

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

RevisionRevision

• Queue

• Main Operations

• Implementation.

Basic Data TypesBasic Data Types

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

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

• List

OverviewOverview

• Lists.

• Operations.

• Abstract Data Types (ADT).

• Programming Styles.

• Implementations of Lists.

ListsLists

SEALFOXDEERAPE EMU0 1 3 42

InsertionInsertion

SEALFOXDEERAPE0 1 32

EMU Inserted at position 2

SEALFOXDEERAPE0 1 3 4

Before:

After:

DeletionDeletion

SEALFOXDEERAPE0 1 3 4

Delete item at position 3

SEALDEERAPE0 1 3

Before:

After:

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.

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:

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.

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.

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.

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.

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:

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:

Simple List ImplementationSimple List Implementation

0 1 2 3 4 5

APE DEER FOX SEAL

0 1 2 3 4 5

APE DEER FOX SEAL

0 1 2 3 4 5

APE DEER FOX SEALEMU

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

marks last item

link to next item

DEER FOX APE SEAL

0 1 2 3 4 5

3 0 -1

startinsert: EMU

DEER FOX APE SEAL

0 1 2 3 4 5

4 3 0 -1

startinsert: EMU

Linked List Implementation:Linked List Implementation:Using PointersUsing Pointers

DEER FOX APE SEAL

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

0x2020 0x2018 0x2000 NULL

0x2008

DEER FOX APE SEAL

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

0x2020 0x2018 0x2000 NULL

0x2008

special pointerconstant

RevisionRevision

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

• Difference between Stacks, Queues, and Lists.

• ADT.

OverviewOverview

• Linked Stack.– Push– Pop

• Linked Queue.– Insert– Delete

Linked StackLinked Stack

Top of the Stack

NULL pointer

#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

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

PopPopTop

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

Linked QueueLinked Queue

Front Rear

#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

InsertInsert

Front Rear

InsertInsert

Front Rear

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

DeleteDelete

Front Rear

DeleteDelete

Front Rear

RearFront

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

RevisionRevision

• Linked Stack.– Initialize, Pop, Push.

• Linked Queue.– Initialize, Insert,Delete

OverviewOverview

• What is Dynamic Memory ?

• How to find the size of objects.

• Allocating memory.

• Deallocating memory.

Virtual MemoryVirtual Memory

Text Segment

Data Segment

Stack segment

program instructions

static and dynamic data

local variables, parameters

free memory

Text Segment

Static data

Stack segment

global variables, etc.

dynamic data

Text Segment

Static data

Stack segment

memory is allocated and deallocated as needed

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

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.

#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

#include <stdio.h>

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

#include <stdio.h>

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

#include <stdio.h>

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

line 16

#include <stdio.h>

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

line 16

result

#include <stdio.h>

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

line 16

9.9225result

#include <stdio.h>

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

line 16

9.9225result

#include <stdio.h>

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

9.9225

#include <stdio.h>

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

9.9225

#include <stdio.h>

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

stackstack

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

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

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;

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;

#include <stdio.h>

#define MAXNAME 80#define MAXCLASS 100

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

Example 2:

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.):

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)

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)

#include <stdlib.h>

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

free(aPtr);}

Example 1:

#include <stdlib.h>

free(aPtr);}

0x3a04

aPtr 0x3a04

Example 1:

#include <stdlib.h>

free(aPtr);}

0x3a04

aPtr 0x3a04

“type cast”

Example 1:

#include <stdlib.h>

free(aPtr);}

0x3a04

aPtr 0x3a04

Example 1:

#include <stdlib.h>

free(aPtr);}

0x3a04

Example 1:

#include <stdlib.h>

free(aPtr);}

0x3a04

Example 1:

deallocates memory

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

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.

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.

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:

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:

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.

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

RevisionRevision

• sizeof

• malloc

• free

• Common errors.

Overview of TopicOverview of Topic

• Review List Implementations.

• Nodes.

• Linked Stacks.

• Linked Queues

• Linked Lists.

• Other List Operations

Today’s Lecture

ListsLists

151031 60 1 3 42

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

InsertionInsertion

1510310 1 32

6 Inserted at position 2

1510310 1 3 4

Before:

After:

• 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

1 3 10 15 21

Expansion and InsertionExpansion and Insertion

1 3 10 15 21

Copy old array, leave space for the new value

DisadvantagesDisadvantages

• Lots of memory needs to be allocated.

• Lots of copying needs to be done.

3 15 1 21

0x2000 0x2008 0x2010 0x2018 0x2020

0x2020 0x2018 0x2000 NULL

0x2008

insert: 6

Method 1Method 1 start

3 15 1 21

0x2000 0x2008 0x2010 0x2018 0x2020

0x2020 0x2018 0x2000 NULL

0x2008

0x30F0 0x30F8 0x3100 0x3108 0x3110

newStart

0x3118

insert: 6

0x30F8 0x3100 0x3108 0x3110 0x3118 NULL

6 10 15 21

0x30F0

Copy old array, leave space for the new value

Method 2Method 2

3 15 1 21

0x2000 0x2008 0x2010 0x2018 0x2020

0x2020 0x2018 0x2000 NULL

0x2008

insert: 6

6newItem

0x30F0

Method 2Method 2

3 15 1 21

0x2000 0x2008 0x2010 0x2018 0x2020

0x30F0 0x2018 0x2000 NULL

0x2008

insert: 6

6newItem

0x30F0

0x2020

AdvantagesAdvantages

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

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

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

typedef struct NodeRec Node;

nextPtr:

value:

#ifndef NODE.H#define NODE.H

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

typedef struct NodeRec Node;

Node* makeNode(float item);

#endif

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

0x30F0 0x2124 6firstNodePtr: lastNodePtr: item:

0x30F0

0x2124

0x2A40

0x2A40nextPtr:

value:

NULLnextPtr:

value:

0x2124nextPtr:

value:

Linked StructureLinked Structure

10x30F0

3 0x2124

0x2124

0x2A40

0x2A40 0x30F0firstNodePtr:

10x30F0

3 0x21240x2A40

0x2A40 0x30F0firstNodePtr:

60x2124 NULL

firstNodePtr:

RevisionRevision

• Node

• How to make a new Node

• Linked Structure

OverviewOverview

• Operations for Lists.

• Implementation of Linked Lists.

• Double Linked Lists.

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.

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

Linked ListLinked List

0 1 2 3

#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

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

Initialize ListInitialize List

headPtr

listPtr addr of list

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

2 position

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

2 position

0x4000

NodePtr

0x30a80x20300x4000

2 position

0x4000

NodePtr

0x30a80x20300x4000

2 position

0x2030

NodePtr

0x30a80x20300x4000

2 position

0x30a8

NodePtr

0x30a80x20300x4000

InsertInsert

If we insert it at position 0.

InsertInsert

If we insert it at position 0.

0 21 3

Instead, suppose we insert it at position 1.

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

Inserting – New ListInserting – New List

0 position

0x30a8

newNodePtr

0x30a8

Inserting – New ListInserting – New List

0 position

0x30a8 newNodePtr

0x30a8

Inserting – Start of ListInserting – Start of List

HeadHead0x30a80x2008

0x2000

0position

0x2000newNodePtr

0x2000

0position

0x2000newNodePtr

0x2000

0position

0x2000newNodePtr

Inserting – Inside the ListInserting – Inside the List

0x2000

1position

0x2000newNodePtr

0x30500x3080

NodePtr 0x3080

0x2000

1position

0x2000newNodePtr

0x30500x3080

NodePtr 0x3080

0x2000

1position

0x2000newNodePtr

0x30500x3080

NodePtr 0x3080

DeleteDelete

If we delete the Node at position 0.

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

Deleting – 1Deleting – 1stst Node Node

0 position

0x4000 NodePtr

0x30a80x20300x4000

Head0 position

0x4000 NodePtr

0x30a80x20300x4000

Head0 position

0x4000 NodePtr

0x30a80x2030

Deleting – Middle NodeDeleting – Middle Node

1 position

0x2030 OldNodePtr

0x30a80x20300x4000

0x2030 NodePtr

0x30a80x20300x4000

1 position

0x2030 OldNodePtr

0x2030 NodePtr

0x30a80x4000

1 position

0x2030 OldNodePtr

0x2030 NodePtr

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.

Double Linked ListDouble Linked List

Current

0 1 2 3 4

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;

Insert at endInsert at end

currentPtrnewPtr

0x4000 0x3080 0x2030 0x2000

0x4000 0x3080

0x3080 0x2030 NULL

NULLNULL

0x2000prevPtr

0x2030

newPtr

0x4000 0x3080 0x2030 0x2000

0x4000 0x3080

0x3080 0x2030 0x2000

NULLNULL

0x2000prevPtr

0x2030

currentPtr

newPtr

0x4000 0x3080 0x2030 0x2000

0x4000 0x3080

0x3080 0x2030 0x2000

NULLNULL

0x2030

0x2000prevPtr

0x2030

currentPtr

Insert inside the listInsert inside the list

newPtr

0x4000 0x3080 0x2030

0x2000

0x4000 0x3080

0x3080 0x2030NULL

0x2000prevPtr

0x3080

currentPtr

newPtr

0x4000 0x3080 0x2030

0x2000

0x4000 0x3080

0x3080 0x2030NULL

0x2000prevPtr

0x3080

currentPtr

newPtr

0x4000 0x3080 0x2030

0x2000

0x4000 0x3080

0x3080 0x2030NULL

0x2000prevPtr

0x3080

currentPtr

newPtr

0x4000 0x3080 0x2030

0x2000

0x4000 0x2000

0x3080 0x2030NULL

0x2000prevPtr

0x3080

currentPtr

newPtr

0x4000 0x3080 0x2030

0x2000

0x4000 0x2000

0x3080 0x2000NULL

0x2000prevPtr

0x3080

currentPtr

Delete from endDelete from end

oldPtr

0x4000 0x3080 0x2030

0x4000 0x3080

0x3080 0x2030 NULL

0x2030currentPtr

prevPtr 0x3080

0x4000 0x3080 0x2030

0x4000 0x3080

0x3080 NULL NULL

oldPtr 0x2030currentPtr

prevPtr 0x3080

0x4000 0x3080

0x4000

0x3080 NULL

prevPtr 0x3080

Delete from inside listDelete from inside list

0x4000 0x3080 0x2030

0x4000 0x3080

0x3080 0x2030 NULL

prevPtr 0x4000

0x4000 0x3080 0x2030

0x4000 0x3080

0x2030 0x2030 NULL

prevPtr 0x4000

0x4000 0x3080 0x2030

0x4000 0x4000

0x2030 0x2030 NULL

prevPtr 0x4000

0x4000 0x2030

0x4000

0x2030 NULL

prevPtr 0x4000

RevisionRevision

• Linked List.

• Benefits of different implementations.

• Double Linked List.

OverviewOverview

• Selection Sort

• Insertion Sort

• Linear Search.

• Binary Search.

• Growth Rates.

• Implementation.

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.

01 2 3 45 6

01 2 345 6

01 23 4 5 6

01 2 3 4 5 6

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.

Insertion SortInsertion Sort01 2 3 45 6

01 2 3 45 6

0 1 2 3 45 6

Linear SearchLinear Search

-7 9 -5 2 8 3 -4

0 1 2 3 4 5 6

current

• Target is -5

-7 9 -5 2 8 3 -4

0 1 2 3 4 5 6

current

• Target is -5

-7 9 -5 2 8 3 -4

0 1 2 3 4 5 6

• Target is -5

current

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

Binary SearchBinary Search

target

Lower Part

target

Upper Part

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

target

Upper Part

-1 2 3 5 8 10 15

0 1 2 3 4 5 6

mid highlow

target

-1 2 3 5 8 10 15

0 1 2 3 4 5 6

mid highlow

target

-1 2 3 5 8 10 15

0 1 2 3 4 5 6

target

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.

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:

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.

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

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

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.

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

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

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

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

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

Case 1: target < list[mid]

lower mid upper

target

New upper

Case 2: list[mid] < target

lower mid upper

target

New lower

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

ComparisonComparisonArray Linked List

Selection Sort

Insertion Sort

Linear Search

Binary Search

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

OverviewOverview

• Unary Recursion

• Binary Recursion

• Examples

• Features

• Stacks

• Disadvantages

• Advantages

What is Recursion - RecallWhat is Recursion - Recall

• A procedure defined in terms of itself

• Components:

– Base case

– Recursive definition

– Convergence to base case

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

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

return tmp;}

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

Unary RecursionUnary Recursion

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

function RecursiveFunction ( <parameter(s)> ){

if ( base case ) thenreturn base value

elsereturn RecursiveFunction ( <expression> )

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)

return 1

return n Factorial ( n - 1 )}

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

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

Copy ListCopy ListHeadPtr

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

typedef struct LinkedListRec List;

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

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

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

return newNodePtr;}

Copy NodesCopy NodesOldNodePtr

NewNodePtr

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

NewNodePtrNewNodePtr

NewNodePtrNewNodePtr NewNodePtr

Copy NodesCopy Nodes

NewNodePtr NewNodePtr

OldNodePtr

Copy NodesCopy Nodes

NewNodePtr

OldNodePtr

Recursion ProcessRecursion Process

Every recursive process consists of:

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

Types of RecursionTypes of Recursion

• Direct.

• Indirect.

• Linear.

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

StacksStacks

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

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

x = 2, n = 5

tmp = 1

x = 2, n = 5

tmp = 1

x = 2, n = 2

tmp = 1

x = 2, n = 5

tmp = 1

x = 2, n = 2

tmp = 1

x = 2, n = 1

tmp = 1

x = 2, n = 5

tmp = 1

x = 2, n = 2

tmp = 1

x = 2, n = 1

tmp = 1

x = 2, n = 0

tmp = 1

x = 2, n = 5

tmp = 1

x = 2, n = 2

x = 2, n = 1

tmp = 1

tmp = 1*1*2 = 2

x = 2, n = 5

tmp = 1

x = 2, n = 2

tmp = 2*2 = 4

x = 2, n = 5

tmp = 4*4*2 = 32

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

Stackn = 2, x = 2

Stackn = 1, x = 2

Stackn = 0, x = 2

tmp = 1

Stackn = 0, x = 2

tmp = 2

Stackn = 0, x = 2

tmp = 4

Stackn = 0, x = 2

tmp = 32

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

DisadvantagesDisadvantages

• May run slower.– Compilers– Inefficient Code

• May use more space.

AdvantagesAdvantages

• More natural.

• Easier to prove correct.

• Easier to analysis.

• More flexible.

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

Free List – Non RecursiveFree List – Non Recursivehead

0x2000 0x258a 0x4c68

0x258a 0x4c68

0x4c68

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

Free ListFree ListHead

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

Free ListFree Listlist

0x258a 0x4c680x2000

Stack in memory

0x2000

0x258a 0x4c680x2000

0x2000

0x258a

Stack in memory

0x258a 0x4c680x2000

0x2000

0x258a

0x4c68

Stack in memory

0x258a 0x4c680x2000

0x2000

0x258a

0x4c68

Stack in memory

0x258a 0x4c680x2000

0x2000

0x258a

0x4c68

Stack in memory

0x258a0x2000

0x2000

0x258a

Stack in memory

0x2000

Stack in memory

Free ListFree ListHead

0x2000

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

RevisionRevision

• Recursion

OverviewOverview

• Trees.

• Terminology.

• Traversal of Binary Trees.

• Expression Trees.

• Binary Search Trees.

TreesTrees

• Family Trees.

• Organisation Structure Charts.

• Program Design.

• Structure of a chapter in a book.

Parts of a TreeParts of a Tree

Parts of a TreeParts of a Treeparent node

Parts of a TreeParts of a Treechild

nodesparent node

Parts of a TreeParts of a Treechild

nodesparent node

root node

Parts of a TreeParts of a Treeleaf

sub-tree

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

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.

Preorder TraversalPreorder Traversal

• Visit the node.

• Traverse the left subtree.

• Traverse the right subtree.

Example: PreorderExample: Preorder

20 40 56

28 33 47 59

43 31 20 28 40 33 64 56 47 59 89

Inorder TraversalInorder Traversal

• Visit the node.

Example: InorderExample: Inorder

20 40 56

28 33 47 59

20 3128 4033 43 5647 59 64 89

Postorder TraversalPostorder Traversal

• Visit the node.

Example: PostorderExample: Postorder

20 40 56

28 33 47 59

2028 40 3133 5647 59 6489 43

Expression TreeExpression Tree

• A Binary Tree built with operands and operators.

• Also known as a parse tree.

• Used in compilers.

Example: Expression TreeExample: Expression Tree

1/3 + 6*7 / 4

NotationNotation

• Preorder– Prefix Notation

• Inorder– Infix Notation

• Postorder– Postfix Notation

Example: InfixExample: Infix

1 / 3 + *6 7 / 4

Example: PostfixExample: Postfix

Recall: Reverse Polish Notation

Example: PrefixExample: Prefix

+ / 1 3 / * 6 7 4

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.

Example 1:

20 40 56

28 33 47 59

key is an integer

Example 1:

20 40 56

28 33 47 59

key is an integer

InsertInsert

• Create new node for the item.

• Find a parent node.

• Attach new node as a leaf.

InsertInsert

20 40 56

28 33 47 59

Example:57

InsertInsert

20 40 56

28 33 47 59

Example:57

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.

SearchSearch

20 40 56

28 33 47 59

Example: 59

57 found

SearchSearch

20 40 56

28 33 47 59

Example: 61

57 failed

RevisionRevision

• Binary Tree

• Preorder, Inorder, Postorder Traveral

• Expression Trees

• Prefix, Infix, and Postfix notation

• Insert and Search

OverviewOverview

• Binary Search Trees.

• Hash Tables.

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.

Example 1:

20 40 56

28 33 47 59

key is an integer

Dan Mary

Alan Eve

Bill Eric

Greg Len

Example 2: key is a string

Binary Tree NodeBinary Tree Node

link to right child nodelink to left

child node

struct TreeNodeRec{ int key;

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

typedef struct TreeNodeRec TreeNode;

Binary Search Tree Node Binary Search Tree Node

Example 1:

Example 2:

Binary Search Tree Node Binary Search Tree Node

#define MAXLEN 15

struct TreeNodeRec{ char key[MAXLEN];

Recall:

maximumstring length

is fixed

#define MAXLEN 15

struct TreeNodeRec{ char key[MAXLEN];

struct TreeNodeRec{ char* key;

Example 3:

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.

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

typedef struct BookRec Book;

Book Record

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

Example 4: Binary Search Tree Node

struct TreeNodeRec{ float key;

Tree NodeTree Node

#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

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

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

0x2000

newNodePtr NULL

0x2000newNodePtr

0x20000x2000newNodePtr 3.3

NULL NULL

value 3.3

InorderInorder

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

void printInorder(TreeNode* nodePtr){

initially, pointerto root node

InorderInorder

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

InorderInorder

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

InorderInorder

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

InorderInorder

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

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

InorderInorder

nodePtr

SearchSearch

20 40 56

28 33 47 59

Example: 59

57 found

SearchSearch

20 40 56

28 33 47 59

Example: 61

57 failed

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.

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

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

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

2.71.4

0.4 0.7

0.80.3

Find 0.7nodePtr

SearchSearch

1.81.1

2.71.4

0.4 0.7

0.80.3

Find 0.7nodePtr

SearchSearch

1.81.1

2.71.4

0.4 0.7

0.80.3

Find 0.7nodePtr

SearchSearch

1.81.1

2.71.4

0.4 0.7

0.80.3

Find 0.7nodePtr

SearchSearch

1.81.1

2.71.4

0.4 0.7

0.80.3

Find 0.5nodePtr

SearchSearch

1.81.1

2.71.4

0.4 0.7

0.80.3

Find 0.5nodePtr

SearchSearch

1.81.1

2.71.4

0.4 0.7

0.80.3

Find 0.5nodePtr

SearchSearch

1.81.1

2.71.4

0.4 0.7

0.80.3

Find 0.5nodePtr

SearchSearch

1.81.1

2.71.4

0.4 0.7

0.80.3

Find 0.5nodePtr

InsertInsert

20 40 56

28 33 47 59

Example:57

InsertInsert

20 40 56

28 33 47 59

Example:57

InsertInsert

• Create new node for the item.

• Find a parent node.

• Attach new node as a leaf.

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.

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

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

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

2.71.4

0.4 0.7

0.80.3

Insert 0.9nodePtr

InsertInsert

1.81.1

2.71.4

0.4 0.7

0.80.3

Insert 0.9nodePtr

InsertInsert

1.81.1

2.71.4

0.4 0.7

0.80.3

Insert 0.9nodePtr

InsertInsert

1.81.1

2.71.4

0.4 0.7

0.80.3

Insert 0.9nodePtr

InsertInsert

1.81.1

2.71.4

0.4 0.7

0.80.3

Insert 0.9nodePtr

SortingSorting

To sort a sequence of items:

• Insert items into a Binary Search Tree.

• Then Inorder Traverse the tree.

Sorting: AnalysisSorting: Analysis

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

~ log2 n

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

SortSort

Sort the following list into a binary search tree

0.51.0 0.7 2.12.5 3.6

SortSort

0.51.0 0.7 2.12.5 3.6

SortSort

0.51.0 0.7 2.12.5 3.6

SortSort

0.51.0 0.7 2.12.5 3.6

2.50.5

SortSort

0.51.0 0.7 2.12.5 3.6

2.50.5

SortSort

2.50.5

0.7 3.6

0.51.0 0.7 2.12.5 3.6

SortSort

0.51.0 0.7 2.12.5 3.6

2.50.5

0.7 3.62.1

Sorting: AnalysisSorting: Analysis

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

Example:

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

• Worst Case: O(n2)

RevisionRevision

• Binary Search Tree

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

• Tree sort.

OverviewOverview

• Divide and Conquer

• Merge Sort

• Quick Sort

SearchSearch

Divide and ConquerDivide and Conquer

SearchSearch

Recall: Binary Search

SortSort

SortSort SortSort

SortSort SortSort SortSort SortSort

CombineCombine

CombineCombine CombineCombine

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

Merge SortMerge Sort

Sort Sort

array:array:

sizesize

tmp:tmp:

tmpArrayPtr:tmpArrayPtr:

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

midmid (size - mid)(size - mid)

firstPart : array

secondPart : array + mid

mergeListmergeList

tmp:tmp:

array:array:

tmp:tmp:

array:array:

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

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

mergeArraysmergeArrays

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

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

Example:

tmp:tmp:

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

Example:

tmp:tmp:

i=0i=0

k=0k=0

j=0j=0

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 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 28 30 10 14 22 43 50a:a: b:b:

Example:

3 5tmp:tmp:

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

k=2k=2

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

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

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

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

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

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

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

28 43 50

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

Merge Sort and Linked ListsMerge Sort and Linked Lists

Sort Sort

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.

Quick SortQuick Sort

x < p p p <= x

Partition

Sort Sort

Quick SortQuick SortExample:

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

size: 11size: 11

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

“pivot element”

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

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

index: 4index: 4

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

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

Partition: ChecklistPartition: Checklist

p x < p p <= x

px < p p <= x

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

array:array:

k=1k=1

15 89 35 14 24 5 37 13 20 7 70

array:array:

k:1k:1

15 89 35 14 24 5 37 13 20 7 70

index:0index:0

array:array:

k:2k:2

15 89 35 14 24 5 37 13 20 7 70

index:0index:0

array:array:

k:3k:3

15 89 35 14 24 5 37 13 20 7 70

index:0index:0

array:array:

k:3k:3

15 89 35 14 24 5 37 13 20 7 70

index:1index:1

array:array:

k:4k:4

15 14 35 89 24 5 37 13 20 7 70

index:1index:1

array:array:

k:5k:5

15 14 35 89 24 5 37 13 20 7 70

index:1index:1

array:array:

k:5k:5

15 14 35 89 24 5 37 13 20 7 70

index:2index:2

array:array:

k:6k:6

15 14 89 24 37 13 20 7 70

index:2index:2

5 35 37

array:array:

k:7k:7

15 14 89 24 37 13 20 7 70

index:2index:2

etc...

array:array:

k:11k:11

15 14 13 7 37 89 20 24 70

index:4index:4

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

index:4index:4

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

index:4index:4

5 35157

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

Example:

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

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

pivot now incorrect position

Example:

14 13 37 89 20 24 705 357

14 1357 37 89 20 24 7035

Sort Sort

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

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.

RevisionRevision

• Merge Sort

• Quick Sort

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

Documents

csi33 data structuresfsw01.bcc.cuny.edu/george.leibman/fall...

boas 3ed solucionario

fm 3ed sem.docx

clinica obstetrica - guariglia 3ed

csi33 data structuresfsw01.bcc.cuny.edu/george.leibman/fall...

cryptographytheoryandpractice 3ed e

yokochi fotografico 3ed

revista anima 3ed

csi33 data structures - fsw01.bcc.cuny.edu...

whiting crane handbook 3ed

csi33 data structures - city university of new...

understanding exposure 3ed

bala devi chandrashekar

ecuaciones.diferenciales.aplicadas.murray spiegel 3ed

transferenciadecalor yunuscengel-3ed

cgv lab manual by chandrashekar m a

jackson_classical electrodynamics (3ed)

macroeconomics_assignment_egmp-38_rahul chandrashekar

biochemistry 3ed - mathews

chandrasekhar raghavan pinko marketing chandrashekar...