C / C++ / MFC

ForNow wrote:

So if Unicode is character representation by 2 bytes. what is multi byte ?

int minValue(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL) return -1;
    else {
        while (current->left != NULL)
            current = current->left;
        return current->num;
    }
}

int maxValue(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL)
        return -1;
    else
     {
        while (current->right != NULL)
            current = current->right;
        return current->num;
     }
}

int min = minValue(root)
int max = maxValue(root));
printf("Min Val: %d Max Val: %d\n", min, max);

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct treenode {
    int num;
    struct treenode * left;
    struct treenode * right;
} TreeNode;

int recLookup (TreeNode *, int);
int lookUp(TreeNode *, int);
int sizeRec(TreeNode *);
int maxDepth(TreeNode *);
int minValue(TreeNode *);
int maxValue(TreeNode *);
int hasPathSum(TreeNode *, int);

TreeNode * createNode (int);
TreeNode * insertRec(TreeNode *, int);
TreeNode * buildTree();

void deleteRec(TreeNode *);
void printIncreasing(TreeNode *);
void printPostOrder(TreeNode *);
void printPaths(TreeNode *);
void printPathRecur(TreeNode *, int[], int);

enum { FALSE, TRUE };


int main (void) {
    TreeNode * root = buildTree();
    printf("Size: %d\n", sizeRec(root));
    printf("Max Depth: %d\n", maxDepth(root));
    printf("Min Value: %d\n", minValue(root));
    printf("Max Value: %d\n", maxValue(root));
    printIncreasing(root); puts("");
    printPostOrder(root); puts("");
    printf("Has path sum 15: %d\n", hasPathSum(root, 15));
    printPaths(root);
    // not sure why line below throws segmentation core
    printf("Min Val: %d Max Val: %d\n", minValue(root), maxValue(root));

    deleteRec(root);


    return 0;
}

void printPaths(TreeNode * root) {
    int path[10];
    int pathLen = 0;
    printPathRecur(root, path, pathLen);
}

void printPathRecur(TreeNode * node, int path[], int pathLen) {
    if (node == NULL) return;
    path[pathLen] = node->num;
    pathLen++;
    if (node->right == NULL && node->left == NULL) {
        int i;
        for (i = 0; i < pathLen; i++)
            printf("%d ", path[i]);
        puts("");
    }
    else {
        printPathRecur(node->left, path, pathLen);
        printPathRecur(node->right, path, pathLen);
    }
}

int hasPathSum(TreeNode * root, int num) {
    TreeNode * current = root;
    if (current == NULL)
        return num == 0;
    else {
        int n = num - current->num;
        return
            hasPathSum(current->left, n) ||
            hasPathSum(current->right, n);
    }
}


void printPostOrder(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL) return;
    printPostOrder(current->left);
    printPostOrder(current->right);
    printf("%d ", current->num);
}

void printIncreasing(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL) return;
    printIncreasing(current->left);
    printf("%d ", current->num);
    printIncreasing(current->right);
}

int minValue(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL) return -1;
    else {
        while (current->left != NULL)
            current = current->left;
        return current->num;
    }
}

int maxValue(TreeNode * root) {
    TreeNode * current = root;
    if (current == NULL)
        return -1;
    else
     {
        while (current->right != NULL)
            current = current->right;
        return current->num;
     }
}

int maxDepth (TreeNode * root) {
    if (root == NULL) return 0;
    else {
        int lDepth = maxDepth(root->left);
        int rDepth = maxDepth(root->right);
        if (lDepth > rDepth) return (lDepth + 1);
        else return (rDepth + 1);
    }
}

void deleteRec(TreeNode * root) {
    if (root == NULL) return;
    else {
        deleteRec(root->right);
        deleteRec(root->left);
        free(root);
    }
}

int sizeRec (TreeNode * root) {
    if (root == NULL) return 0;
    else
        return 1 + sizeRec(root->right) + sizeRec(root->left);
}

TreeNode * buildTree() {
    TreeNode * root = insertRec(root, 4);
    root = insertRec(root, 3);
    root = insertRec(root, 6);
    return root;
}

TreeNode * insertRec (TreeNode * node, int num) {
    if (node == NULL)
        return createNode(num);
    else {
        if (num <= node->num) node->left = insertRec(node->left, num);
        else node->right = insertRec(node->right, num);
    }
    return node;
}

TreeNode * createNode(int num) {
    TreeNode * newNode = (TreeNode *) malloc (sizeof (TreeNode));
    newNode->num = num;
    newNode->right = NULL;
    newNode->left = NULL;
    return newNode;
}

int lookUp(TreeNode * node, int num) {
    while (node != NULL) {
        if (node->num == num) return TRUE;
        else {
            if (num < node->num) node = node->left;
            else node = node->right;
        }
    }
    return FALSE;
}


int recLookup (TreeNode * node, int num) {
    if (node == NULL)
        return FALSE;
    else {
        if (node->num == num) return TRUE;
        else {
            if (num < node->num) return recLookup(node->left, num);
            else return recLookup(node->right, num);
        }
    }
}

TreeNode * root = insertRec(NULL, 4);