数据结构与算法分析4.1 二叉树的各自操作以及平衡二叉树的旋转调整

root@ubuntu:data-struct# cat tree.c 

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

struct TreeNode;
typedef struct TreeNode *Position;
typedef struct TreeNode *SearchTree;
typedef unsigned int ElementType; 

SearchTree make_empty( SearchTree t );
Position tree_find( ElementType x, SearchTree t );
Position tree_find_min( SearchTree t );
Position tree_find_max( SearchTree t);
SearchTree tree_insert( ElementType x, SearchTree t);
SearchTree tree_delete( ElementType x, SearchTree t);
ElementType tree_retrieve( Position p);

struct TreeNode {
    ElementType element;
    SearchTree left;
    SearchTree right;
    int height;
};

static int tree_height(SearchTree t)
{
    if (t == NULL) return -1;
    else return t->height;
}

SearchTree avl_insert(ElementType x, SearchTree t)
{
    if (t == NULL) {
        t = malloc(sizeof(struct TreeNode));

        if (t == NULL) exit(-1);
        else {
            t->element = x; 
            t->height = 0;
            t->left = t->right = NULL;
        }
    }
    else if (x < t->element) {
        t->left = tree_insert(x, t->left);
        if (tree_height(t->left) - tree_height(t->right) == 2) {
            if (x < t->left->element) t = SingleRotateWithLeft(t);
            else t = DoubleRotateWithiLeft(t);
        }
    }
    else if (x > t->element) {
        t->right = tree_insert(x, t->right);
        if (tree_height(t->right) - tree_height(t->left) == 2) {
            if (x > t->right->element) t = SingleRotateWithRight(t);
            else t = DoubleRotateWithRight(t);
        }
    }
    else {
        //x in tree
    }


    t->height = (tree_height(t->left) > tree_height(t->right) ? 
    tree_height(t->left) : tree_height(t->right) ) + 1;

    return t;
}

static SearchTree SingleRotateWithLeft(SearchTree k2)
{
    SearchTree k1;
    k1 = k2->left;
    k2->left = k1->right;
    k1->right = k2;

    k2->height = (tree_height(k2->left) > tree_height(k2->right) ?
    tree_height(k2->left) : tree_height(k2->right)) + 1;
    k1->height = (tree_height(k1->left) > tree_height(k1->right) ?
    tree_height(k1->left) : tree_height(k1->right)) + 1;

    return k1;
}

static SearchTree SingleRotateWithRight(SearchTree k2)
{
        SearchTree k1;
        k1 = k2->right;
        k2->right = k1->left;
        k1->left = k2;

        k2->height = (tree_height(k2->left) > tree_height(k2->right) ?
                        tree_height(k2->left) : tree_height(k2->right)) + 1;
        k1->height = (tree_height(k1->left) > tree_height(k1->right) ?
                        tree_height(k1->left) : tree_height(k1->right)) + 1;

        return k1;
}

static SearchTree DoubleRotateWithLeft( SearchTree k3 )
{
    //Rotate between k1:k3->left and k2:k3->left->right
    k3->left = SingleRotateWithRight(k3->left);

    //Rotate between k3 and new k3->left
    return SingleRotateWithLeft(k3);
}

static SearchTree DoubleRotateWithRight( SearchTree k3 )
{
        //Rotate between k1:k3->right and k2:k3->right->left
        k3->right = SingleRotateWithLeft(k3->right);


        //Rotate between k3 and new k3->right
        return SingleRotateWithRight(k3);
}

SearchTree make_empty( SearchTree t)
{
    if ( t != NULL) {
        make_empty(t->left);
        make_empty(t->right);
        free(t);
    }

    return NULL;
}
Position tree_find( ElementType x, SearchTree t )
{
    if (t == NULL) return NULL;
    if (x > t->element) {
        return tree_find(x, t->right);
    }
    else if (x < t->element) {
        return tree_find(x, t->left);
    }
    else {
        return t;
    }
}

Position tree_find_min( SearchTree t )
{
    if (t == NULL) return NULL;
    if (t->left) {
        return tree_find_min( t->left );
    }
    else 
        return t; 
}

Position tree_find_max( SearchTree t)
{
    if (!t) return NULL;
    while (t->right) {
        t = t->right;
    }

    return t;
}

SearchTree tree_insert( ElementType x, SearchTree t)
{
    SearchTree t1 = t;
    if ( !t ) {
        t1 = malloc(sizeof(struct TreeNode));
        t1->left = t1->right = NULL;
        t1->element = x;
        t = t1; 
    }
    else {
        if (t->element < x) {
            tree->right =  tree_insert(x, t->right);
        }
        else if (x < t->element) {
            tree->left = tree_insert(x, t->left);
        }
        else {
            //equal
        }
    }

    return t;
}

SearchTree tree_delete( ElementType x, SearchTree t)
{
    SearchTree t1;
    if (!t) return NULL;
    if (x < t->element) {
        t->left = tree_delete(x, t->left);
    }
    else if (x > t->element) {
        t->right = tree_delete(x, t->right);
    }
    else if (t->left && t->right ) {
        t1 = tree_find_min(t->right); 
        t->element = t1->element;
        t->right = tree_delete(t1->element, t->right); 
    }
    else {
        t1 = t;
        if (t->left == NULL) {
            t = t->right;
        }
        else if (t->right == NULL) {
            t = t->left;
        }

        free(t1);
    }

    return t;
}

void print_space(int n)
{
    int i;
    for (i = 0; i < n; i++) {
        putchar(' ');
    }
}

ElementType tree_prev_retrieve( Position p, int space_cnt)
{
    ElementType tmp;
    if (p) {
        //print_space(space_cnt++);
        printf(" %d ", p->element);
        tmp = p->element;
        tree_prev_retrieve( p->left, space_cnt);
        tree_prev_retrieve( p->right, space_cnt );
        return tmp;
    }
}

ElementType tree_mid_retrieve( Position p)
{
    ElementType tmp;
    if (p) {
            tree_mid_retrieve( p->left );
            printf(" %d ", p->element);
            tmp = p->element;
            tree_mid_retrieve( p->right );
            return tmp;
    } 
}

ElementType tree_back_retrieve( Position p)
{
        ElementType tmp;
        if (p) {
                tree_back_retrieve( p->left );
                printf("");
                tree_back_retrieve( p->right );
                printf(" %d ", p->element);
                tmp = p->element;
                return tmp;
        }
}