alwayswords

[alwayswords]

bucket sort

Uses bucket sort on an array of integers. Prereq: void printArray(int [], int).

void bucketSort(int array[]) {     int buckets[10][SIZE] = {0};     int largest = array[0];     int divider = 10;     int count = 0;     int place_value = 1;     int digit = 0;    

    for (int x = 0; x <= SIZE - 1; x++)     {         if (array[x] > largest)             largest = array[x];     }    

    while (largest >= divider)     {         for (int x = 0; x <= SIZE - 1; x++)         {             count = 0;             if (place_value == 1)             {                 while (buckets[array[x] % divider][count])                     count++;

                buckets[array[x] % divider][count] = array[x];             }             else if (place_value > 1)             {                 digit = (array[x] / divider) % 10;

                while (buckets[digit][count])                     count++;

                buckets[digit][count] = array[x];             }         }        

        count = 0;        

        for (int x = 0; x <= 9; x++)         {             for (int y = 0; y <= SIZE - 1; y++)             {                 if (buckets[x][y])                 {                     array[count] = buckets[x][y];                     buckets[x][y] = 0;                     count++;                 }             }         }        

        if (place_value > 1)             divider *= 10;        

        place_value++;     }

    printArray(array); }

[alwayswords]

prints a double array

Prints a double array.

void printDoubleArray(int array[][SIZE]) {     for (int x = 0; x <= 9; x++)     {         for (int y = 0; y <= SIZE - 1; y++)             printf("%5d ", array[x][y]);        

        printf("\n");     }    

    printf("\n"); }

[alwayswords]

merge sort

Uses merge sort on an array of integers. Prereqs: printArray(int [], int, int) & merge(int [], int, int, int, int).

void sortSubArray(int array[], int low, int high) {     int middle1, middle2;    

    if (low != high)     {         middle1 = (low + high) / 2;         middle2 = middle1 + 1;        

        printf("LEFT: ");         printArray(array, low, middle1);         printf("RIGHT: ");         printArray(array, middle2, high);        

        sortSubArray(array, low, middle1);         sortSubArray(array, middle2, high);        

        merge(array, low, middle1, middle2, high);     }    

    printf("\n"); }

[alwayswords]

merge into array

Merges two ordered sections of an array. Prereq: void printArray(int [], int, int).

void merge(int array[], int left, int middle1, int middle2, int right) {     int temp[7] = {};     int count = 0;     int start = left;     int end = right;    

    while (left <= middle1)     {         if ((middle2 <= right) && (array[left] > array[middle2]))         {             temp[count] = array[middle2];             middle2++;         }         else         {             temp[count] = array[left];             left++;         }        

        count++;     }    

    while (middle2 <= right)     {         temp[count] = array[middle2];         count++;         middle2++;     }    

    for (int x = start; x <= end; x++)     {         array[x] = temp[x - start];     }    

    printArray(array, 0, 6); }

[alwayswords]

prints array (selective)

Prints a certain section of an array.

void printArray(int array[], int start, int end) {     for (int x = start; x <= end; x++)     {         printf("%d ", array[x]);     }    

    printf("\n"); }

[alwayswords]

insertion sort

Uses insertion sort on an array of integers. Prereq: void printArray(int[], int).

void insertionSort(int array[], int length) {     int insert = 0;     int temp = 0;     int count = 0;    

    for (int x = 1; x < length; x++)     {         int y = 0;        

        while ((array[y] < array[x]) && (y < x))             y++;        

        insert = y;

        if (insert != x)         {             temp = array[insert];             array[insert] = array[x];            

            count = x;

            while (count > insert + 1)             {                 array[count] = array[count - 1];                 count--;             }            

            array[count] = temp;         }        

        printArray(array, length);     } }

[alwayswords]

selection sort

Uses selection sort on an array of integers. Prereqs: void swap(int [], int, int) & void printArray(int [], int).

void selectionSort(int array[], int length) {     int smallest = array[0];     int index_smallest = 0;    

    for (int x = 0; x <= length - 1; x++) //goes through the entire array     {         smallest = array[x];         index_smallest = x;        

        for (int y = x; y <= length - 1; y++)         {             if (array[y] < smallest)             {                 smallest = array[y];                 index_smallest = y;             }         }        

        if (index_smallest != x)             swap(array, x, index_smallest);        

        printArray(array, length);     }     }

[alwayswords]

printArray

Prints an array.

void printArray(int array[], int size) {     for (int x = 0; x < size; x++)     {         printf("%d ", array[x]);     }    

    printf("\n"); }

[alwayswords]

swap members of an array

Swaps two members of an array.

void swap(int array[], int first, int second) {     int temp;

    temp = array[first];     array[first] = array[second];     array[second] = temp; }

[alwayswords]

tree: printing

Prints a tree as it is.

void outputTree(TreeNode *t, int space) {     TreeNode *current = t;    

    while (current != NULL)     {         if (current->right)             outputTree(current->right, space + 5);        

        for (int x = 0; x <= space - 1; x++)         {             printf(" ");         }        

        printf("%d\n", current->data);

        current = current->left;         space += 5;     } }

[alwayswords]

tree: by level

Prints a tree according to the levels of the nodes. Prereqs: void enqueue(QueueNode **, TreeNode **) & TreeNode *dequeue(QueueNode **)

void levelOrder(TreeNode *tree) {     QueueNode *line = NULL;     TreeNode *current = tree;    

    enqueue(&line, current);

    while (line != NULL)     {         current = dequeue(&line);         printf("%d ", current->data);

        if (current->left)             enqueue(&line, current->left);         if (current->right)             enqueue(&line, current->right);     } }

[alwayswords]

dequeue (tree version)

Removes a tree from a queue.

TreeNode *dequeue(QueueNode **back) {     QueueNode *currentPtr = *back;     QueueNode *previousPtr = NULL;     TreeNode *value = NULL;    

    while (currentPtr->nextPtr)     {         previousPtr = currentPtr;         currentPtr = currentPtr->nextPtr;     }    

    value = currentPtr->tree;     if (currentPtr != *back)         free(currentPtr);     else         *back = NULL;

    if (previousPtr)         previousPtr->nextPtr = NULL;    

    return value; }

[alwayswords]

enqueue (tree version)

Inserts a tree into a queue.

void enqueue(QueueNode **back, TreeNode *t) {     QueueNode *node = malloc(sizeof(struct queueNode));     node->tree = t;    

    if (!*back)         node->nextPtr = NULL;     else         node->nextPtr = *back;    

    *back = node; }

[alwayswords]

circle

Parent Class: GraphicObject

@interface Circle : GraphicObject

- (void) setRadius: (int) r; - (void) setCenter: (XYPoint *) c; - (int) radius; - (XYPoint *) center; - (int) circumference; - (int) area;

@end

#import "Circle.h" #import "XYPoint.h"

@implementation Circle {     int radius;     XYPoint *center; }

- (void) setRadius: (int) r {     radius = r; }

- (int) radius {     return radius; }

- (void) setCenter: (XYPoint *) c {     if (!center)         center = [[XYPoint alloc] init];    

    center.x = c.x;     center.y = c.y; }

- (XYPoint *) center {     return center; }

- (int) circumference {     return 2 * 3.1416 * radius; }

- (int) area {     return 3.1416 * radius * radius; }

@end

[alwayswords]

triangle

Parent Class: Graphic Object.

Prereq: XYPoint.

#import "GraphicObject.h" #import "XYPoint.h"

@interface Triangle : GraphicObject

@end 

#import "Triangle.h" #import "XYPoint.h"

@implementation Triangle {     int side;     int altitude;     XYPoint *center; }

- (void) setSide: (int) s {     side = s; }

- (int) side {     return side; }

- (void) setAltitude: (int) a {     altitude = a; }

- (int) altitude {     return altitude; }

- (void) setCenter: (XYPoint *) c; {     if (!center)         center = [[XYPoint alloc] init];

    center.x = c.x;     center.y = c.y; }

- (XYPoint *) center {     return center; }

- (int) perimeter {     return side * 3; }

- (int) area {     return side * altitude / 2; }

@end

[alwayswords]

graphic object

Subclasses: Circle, Rectangle, Triangle.

@interface GraphicObject : NSObject

- (void) setFillColor: (int) i; - (int) fillColor; - (void) setFilled: (BOOL) b; - (BOOL) filled; - (void) setLineColor: (int) i; - (int) lineColor;

@end 

#import "GraphicObject.h"

@implementation GraphicObject {

    int fillColor;     BOOL filled;     int lineColor; }

- (void) setFillColor: (int) i {     fillColor = i; }

- (int) fillColor {     return fillColor; }

- (void) setFilled: (BOOL) b {     filled = b; }

- (BOOL) filled {     return filled; }

- (void) setLineColor: (int) i {     lineColor = i; }

- (int) lineColor {     return lineColor; }

@end

[alwayswords]

X-Y Point

@interface XYPoint : NSObject

@property int x, y;

- (void) print

@end 

#import "XYPoint.h"

@implementation XYPoint

@synthesize x, y;

- (void) print {     NSLog(@"(%i, %i)", x, y); }

@end