一棵排序二叉树，令 f=(最大值+最小值)/2，设计一个算法，找出距离f值最近、大于f值的结点。 复杂度如果是O(n2)则不得分。

一棵排序二叉树，令 f=(最大值+最小值)/2，设计一个算法，找出距离f值最近、大于f值的结点。

复杂度如果是O(n2)则不得分。

分析： 二叉排序树  具有（左子树< 根结点 < 右子树）性质

 (1) 二叉排序树的构建过程中总是将新节点插入到叶子结点。

（2）二叉排序树的最小结点是该二叉排序树的最左边的结点。

（3）二叉排序树的最大结点是该二叉排序树的最右边的结点。

（4）查找首个大于给定值的结点（本题就是这个）。 

      分以下几种情况：

0.比较根结点的值与指定的值，若果根结点的值大于指定的值 则转 1， 否者（otherwise）转2. 

1. 当根节点的值大于该值，

（a) 根结点的左子树为空，则根结点为所求。

                        （b）若左子树不为空， 

                            （i）若左子树的最大结点的值 不大于 指定的值， 则根结点为所求。

                            （ii）若左子树的最大结点的值 大于 指定的值， 则所求结点在左子树中。将左子树的根节点替换根结点转0.

                 2. 当根结点值 不大于 指定的值时，

                            （a） 若根结点的右子树为空，则不存在， 返回NULL。

                            （b)  若根结点的右子树不为空， 在右子树中找到首个大于指定值得结点，并用这个结点替换根结点，然后转0.

其实，是一个循环不变式！时间复杂度应该小于 O(h*lgn)， 因为

h 为树的高度，每一次根节点的比较，使树的规模至少减少一半（若果是平衡二叉排序树的话）。

（5）查找小于指定值的首个结点，方法类似于（4），关键找到那个循环不变式。//右子树的最小结点。

（6）补充, 查找值在指定区间[a, b] 内的所有结点。

实现如下：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <assert.h>


typedef  int item_t;

typedef struct node  {
    item_t item;
    struct node *left;
    struct node *right;
} node_t;

typedef node_t * BSTree;
typedef void (*printFuncPtr)(item_t item);

void print(item_t item);
BSTree createBinarySearchTree(BSTree *root, int size, item_t min, item_t max);
void destroyBinarySearchTree(BSTree root);


void postOrderTravel(BSTree root, printFuncPtr print);
void midOrderTravel(BSTree root, printFuncPtr print);
void preOrderTravel(BSTree root, printFuncPtr print);

node_t *minNodeOfBinarySearchTree(BSTree root);
node_t *maxNodeOfBinarySearchTree(BSTree root);
node_t *findNearestBigNode(BSTree root, item_t item);
node_t *findNearestSmallNode(BSTree root, item_t item);

node_t *insertNode(BSTree *root, item_t item);


int main()
{
    int i;
    int len = 20;
    item_t minItem;
    item_t maxItem;
    item_t midItem;
    BSTree root = NULL;
    node_t *max_node_ptr;
    node_t *min_node_ptr;
    node_t *nearest_big_node_ptr;
    node_t *nearest_small_node_ptr;

    for(i=1; i<len; i++) {
        root = createBinarySearchTree(&root, i, 0, i);
        printf("root=%p\n",  root);
        printf("<%d> midOrderTravel: ", i);
        midOrderTravel(root, print);
        printf("\n");

        printf("<%d> preOrderTravel: ", i);
        preOrderTravel(root, print);
        printf("\n");

        printf("<%d> postOrderTravel: ", i);
        postOrderTravel(root, print);
        printf("\n");

        min_node_ptr = minNodeOfBinarySearchTree(root);
        max_node_ptr = maxNodeOfBinarySearchTree(root);
        if(min_node_ptr) {
            minItem = min_node_ptr->item;
            printf("The min node of the tree is %p : %d\n", min_node_ptr, minItem);
        }
        if(max_node_ptr) {
            maxItem = max_node_ptr->item;
            printf("The max node of the tree is %p : %d\n", max_node_ptr, maxItem);
        }

        midItem = (maxItem + minItem) >> 1;
        nearest_big_node_ptr = findNearestBigNode(root, midItem);
        if(nearest_big_node_ptr) {
            printf("find the nearest midItem (%d) big node %p: itsItem is %d \n", midItem, nearest_big_node_ptr, nearest_big_node_ptr->item);
        }

        nearest_small_node_ptr = findNearestSmallNode(root, midItem);
        if(nearest_small_node_ptr) {
            printf("find the nearest midItem (%d) small node %p: itsItem is %d \n", midItem, nearest_small_node_ptr, nearest_small_node_ptr->item);
        }

        printf("\n\n");
        if(root) {
            destroyBinarySearchTree(root);
            root = NULL;
        }


    }


    return 0;
}

/*
int getRandom(int min, int max) {
    assert(max>=min);
    srand((unsigned) time(NULL));

    return min + rand()%(max-min);
}
*/

void print(item_t item) {
    printf("%d ", item);
}

node_t *insertNode(BSTree *rootPtr, item_t item) {
    node_t *tmp = (node_t *) malloc(sizeof(node_t));
    assert(tmp!=NULL);
    if(!tmp) fprintf(stderr, "error: There is not enough memory to use!!\n");
    if(tmp)  {
        tmp->item = item;
        tmp->left = NULL;
        tmp->right = NULL;
    }

    if(!*rootPtr) {
        if(tmp) *rootPtr = tmp;
        return tmp;
    }

    BSTree root = *rootPtr;
    while(root) {
        if(root->item >= item) {
            if(root->left == NULL) { //是叶子节点
                root->left = tmp;
                return tmp;
                //break;
            }

            root = root->left;
        }else {
            if(root->right == NULL) { //是叶子节点
                root->right = tmp;
                return tmp;
                //break;
            }

            root = root->right;
        }
    }

}

BSTree createBinarySearchTree(BSTree *rootPtr, int size, item_t min, item_t max) {
    int i;
    item_t item;
    printf("size= %d \n", size);
    srand((unsigned) time(NULL));

    for(i=0; i<size; i++) {
        item = min + rand()%(max-min);
        printf("%d ", item);
        insertNode(rootPtr, item);

    }

    printf("\n");
    return *rootPtr;
}

void destroyBinarySearchTree(BSTree  root){
    if(root) { //后续遍历
        destroyBinarySearchTree(root->left);
        destroyBinarySearchTree(root->right);
        free(root);
    }

    /*
    if(root) { //中序遍历
            destroyBinarySearchTree(root->left);
            node_t *right = root->right;
            free(root);
            destroyBinarySearchTree(right);

    }
    */

    /*
    if(root){ //前序遍历
        node_t *left = root->left;
        node_t *right = root->right;
        free(root);
        free(left);
        free(right);

    }
    */
}

void preOrderTravel(BSTree root, printFuncPtr print) {
    if(root) {
        print(root->item);
        preOrderTravel(root->left, print);
        preOrderTravel(root->right, print);
    }
}

void midOrderTravel(BSTree root, printFuncPtr print) {
    if(root) {
        midOrderTravel(root->left, print);
        print(root->item);
        midOrderTravel(root->right, print);
    }
}

void postOrderTravel(BSTree root, printFuncPtr print) {
    if(root) {
        postOrderTravel(root->left, print);
        postOrderTravel(root->right, print);
        print(root->item);
    }
}


node_t *minNodeOfBinarySearchTree(BSTree root) {
        if(!root) return NULL;

        while(root){
            if(root->left == NULL) return root;
            root = root->left;
        }

}


node_t *maxNodeOfBinarySearchTree(BSTree root) {
        if(!root) return NULL;

        while(root){
            if(root->right == NULL) return root;
            root = root->right;
        }

}


node_t *findNearestBigNode(BSTree root, item_t item) {
    while(root) {
        if(root->item > item) {
            if(root->left) {
                node_t * maxNodePtr = maxNodeOfBinarySearchTree(root->left);
                if(maxNodePtr && maxNodePtr->item <= item) return root;

                root = root->left;
            }else {
                return root;
            }
        }
        else {
            if(root->right) {
                root = root->right;
            }else {
                return NULL;
            }


        }

    }

}

node_t *findNearestSmallNode(BSTree root, item_t item) {
    while(root) {
        if(root->item < item) {
            if(root->right) {
                node_t * minNodePtr = minNodeOfBinarySearchTree(root->right);
                if(minNodePtr && minNodePtr->item >= item) return root;

                root = root->right;
            }else {
                return root;
            }
        }
        else {
            if(root->left) {
                root = root->left;
            }else {
                return NULL;
            }
        }

    }

}