程序设计

/*-----------------------------------------------------------
        SBTree的ADT实现
        作Author: QingXiaoming, 12-05, 2007([url]http://www.cublog.com/augustusqing/[/url]
        您可以自由拷贝，修改，传播这份代码，但请注明原作者
-------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include "include/SBTree_ADT.h"

struct SBTreeNode {
       Item item;
       SBTreeLink lchild;
       SBTreeLink rchild;
       int size;
       };
struct SBTree {
       SBTreeLink root;
       };
      
static SBTreeLink NEW(Item item)
{
       SBTreeLink x = NULL;
       x = malloc(sizeof(*x));
       if (!x){perror("Get memory for Node error");return NULL;}
       x->item = item;
       x->lchild = x->rchild = NULL;
       x->size = 1;
       return x;
}

SBTree initSBTree()
{
       SBTree x = NULL;
       x = malloc(sizeof(*x));
       if (!x){perror("Get memory for tree error");return NULL;}
       x->root = NULL;
       return x;
}

int emptySBTree(SBTree tree)
{
    return tree->root == NULL;
}
void showSBTreeNode(SBTreeLink x)
{
     printf("Item=%d, Size=%d, Left=%d, Right=%d\n",x->item, x->size, (NULL != x->lchild)?x->lchild->item:-1,(NULL != x->rchild)?x->rchild->item:-1);
}

int sizeSBTree(SBTree tree)
{
    if(!tree || !tree->root){perror("Size a NULL tree");return -1;}
    return tree->root->size;
}

Item maxSBTree(SBTree tree)
{
     if(!tree || !tree->root){perror("Max a NULL tree");return -1;}
     return seqSBTree(tree, sizeSBTree(tree));
}

Item minSBTree(SBTree tree)
{
     if(!tree || !tree->root){perror("Min a NULL tree");return -1;}
     return seqSBTree(tree, 1);
}

SBTreeLink findSBTree(SBTree tree, Item item)
{
    SBTreeLink x  = tree->root;
    while (x && item != x->item)
    {
          x = (item < x->item) ? x->lchild : x->rchild;
    }
    return x;
}

Item preSBTree(SBTree tree, Item item)
{
     int r;
     SBTreeLink x = findSBTree(tree, item);
     if (!x){printf("No item %d in the tree", item);return -1;}
     r = rankSBTree(tree, x);
     if (1 == r){printf("item %d is No.1, Can't Pre this item", item);return -1;}
     return seqSBTree(tree, r - 1);  
}

Item sucSBTree(SBTree tree, Item item)
{
     int r;
     SBTreeLink x = findSBTree(tree, item);
     if (!x){printf("No item %d in the tree", item);return -1;}
     r = rankSBTree(tree, x);
     if (sizeSBTree(tree) == r){printf("item %d is No.MAX, Can't Suc this item", item);return -1;}
     return seqSBTree(tree, r + 1);
}

static void pretravseSBTreeNode(SBTreeLink link)
{
       if (link)
       {
           showSBTreeNode(link);
           pretravseSBTreeNode(link->lchild);
           pretravseSBTreeNode(link->rchild);
       }
}

void pretravseSBTree(SBTree tree)
{
     return pretravseSBTreeNode(tree->root);
}

static void midtravseSBTreeNode(SBTreeLink link)
{
       if (link)
       {
           midtravseSBTreeNode(link->lchild);
           showSBTreeNode(link);
           midtravseSBTreeNode(link->rchild);
       }
}
void midtravseSBTree(SBTree tree)
{
     return midtravseSBTreeNode(tree->root);
}

static void Left_Rotate(SBTreeLink *link)
{
       SBTreeLink y, x = *link;
       if (!x || !x->rchild){perror("Cant Right Rotate NULL node or NULL lchild");return;}
       y = x->rchild;
       x->rchild = y->lchild;
       *link = y;
       y->lchild = x;
       y->size = x->size;
       x->size = ((x->lchild != NULL) ? x->lchild->size: 0) + ((x->rchild != NULL) ? x->rchild->size: 0) + 1;
}

static void Right_Rotate(SBTreeLink *link)
{
       SBTreeLink y, x = *link;
       if (!x || !x->lchild){perror("Cant Right Rotate NULL node or NULL lchild");return;}
       y = x->lchild;
       x->lchild = y->rchild;
       *link = y;
       y->rchild = x;
       y->size = x->size;
       x->size = ((x->lchild != NULL) ? x->lchild->size: 0) + ((x->rchild != NULL) ? x->rchild->size: 0) + 1;
}

static void maintainSBTree(SBTreeLink *link, int flag)
{
       SBTreeLink t = *link;
       if(!t)return;
       if (!flag)
       {
           if (t->lchild && t->lchild->lchild && (!t->rchild || t->lchild->lchild->size > t->rchild->size))
           {
                Right_Rotate(link);
           }
           else if (t->lchild && t->lchild->rchild && (!t->rchild || t->lchild->rchild->size > t->rchild->size))
           {
                Left_Rotate(&(t->lchild));
                Right_Rotate(link);
           }
           else return;
       }
       else
       {
           if (t->rchild && t->rchild->rchild && (!t->lchild || t->rchild->rchild->size > t->lchild->size))
           {
                Left_Rotate(link);
           }
           else if (t->rchild && t->rchild->lchild && (!t->lchild || t->rchild->lchild->size > t->lchild->size))
           {
                Right_Rotate(&(t->rchild));
                Left_Rotate(link);
           }
           else return;
       }
       maintainSBTree(&(t->lchild), 0);
       maintainSBTree(&(t->rchild), 1);
       maintainSBTree(link, 0);
       maintainSBTree(link, 1);
}
static void insertSBTreeNode(SBTreeLink *link, Item item)
{
      SBTreeLink x = *link;
      if (!x)
      {
          *link = NEW(item);
          return;
      }
      else
      {
          x->size += 1;
          insertSBTreeNode((item < x->item) ? &(x->lchild) : &(x->rchild), item);
          maintainSBTree(link, item > x->item);
      }
}

void insertSBTree(SBTree tree, Item item)
{
      SBTreeLink x = findSBTree(tree, item);
      if (x)
      {
          //printf("Cant insert a Exist item into tree!\n");
          return;
      }
      return insertSBTreeNode(&tree->root, item);
}

SBTreeLink deleteSBTree(SBTree tree, Item item)
{
    Item t;
    SBTreeLink n, m, z, y, x = tree->root;
    if (!x){perror("Cant delete node from NULL tree");return NULL;}
    if (item == x->item && !x->rchild)
    {
        tree->root = x->lchild;
        return x;
    }// find the node with item
    while (x && (item != x->item))
    {
          z = x;
          x = (item < x->item) ? x->lchild : x->rchild;        
    }//find the x's father node
    if (x)
    {
          if (x->rchild)
          {
              z = x;
              y = x->rchild;
              while (y->lchild)
              {
                    z = y;
                    y = y->lchild;
              }
          }// find y, the node will really be deleted, and his father
          else
          {
              y = x;
          }
    }
    else
    {
        printf("No item %d in the SBTree\n", item);
        return NULL;
    }
    //handle the y's child
    m = y->lchild ? y->lchild : y->rchild;
    if (y == z->lchild)
    {
          z->lchild = m;
    }
    else
    {
          z->rchild = m;
    }
    n = tree->root;
    while (n != z)
    {
          n->size--;
          n = item < n->item ? n->lchild : n->rchild;
    }//modify the size, from root the the y's parent
    z->size--;// also y's father
    if(x != y)
    {
         t = x->item; x->item = y->item; y->item = t;
    }
    return y;
}

static Item seqSBTreeNode(SBTreeLink link, int i)
{
    int r;
    if (!link){perror("You want to Seq a non-exist number Node");return -1;}
    r = (NULL != link->lchild) ? (link->lchild->size + 1) : 1;
    if (i == r){return  link->item;}
    else return (i < r) ? seqSBTreeNode(link->lchild, i) : seqSBTreeNode(link->rchild, i-r);
}
Item seqSBTree(SBTree tree, int i)
{
    return seqSBTreeNode(tree->root, i);
}

int rankSBTree(SBTree tree , SBTreeLink link)
{
    int r = 0;
    SBTreeLink x = tree->root;
    if(!tree->root || !link){perror("You want to Rank a non-exist Node or NULL tree");return -1;}
    while (x != link)
    {
          if (link->item > x->item)
          {
              r += (NULL != x->lchild) ? (x->lchild->size + 1) : 1;
              x = x->rchild;
          }
          else
          {
              x = x->lchild;
          }   
    }
    r += (NULL != x->lchild) ? (x->lchild->size + 1) : 1;
    return r;
}

void destroySBTree(SBTree tree)
{
     SBTreeLink y, x = tree->root;
     while (x)
     {
           y = deleteSBTree(tree, x->item);
           free(y);
           x = tree->root;
     }
}

/*-----------------------------------------------------------
        Treap的ADT实现
        作者： QingXiaoming, 12-04, 2007([url]http://www.cublog.com/augustusqing/[/url])
        您可以自由的传播，修改这份代码，转载处请注明原作者
-------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include "include/Treap_ADT.h"

struct treapnode {
       Item item;
       TreapLink parent;
       TreapLink lchild;
       TreapLink rchild;
       int prio;
       };
struct treap {
       TreapLink root;
       };

static int priobase = 1;
static TreapLink NEW(Item item, TreapLink parent);
static void Left_Rotate(Treap tree, TreapLink x);
static void Right_Rotate(Treap tree, TreapLink x);
static void pretravseTreapNode(TreapLink root);
static void midtravseTreapNode(TreapLink root);

static TreapLink NEW(Item item, TreapLink parent)
{
       TreapLink x = NULL;
       x = malloc(sizeof(*x));
       if (!x){perror("Get memory for Node error");return NULL;}
       x->item = item;
       x->parent = parent;
       x->lchild = NULL;
       x->rchild = NULL;
       x->prio = rand()%priobase;
       return x;
}

Treap initTreap(int N)
{
      Treap x = NULL;
      x = malloc(sizeof(*x));
      if (!x){perror("Get memory for Treap error");return NULL;}
      x->root = NULL;
      priobase = N;
      return x;
}

int emptyTreap(Treap tree)
{
    return tree->root == NULL;
}

TreapLink findTreapNode(Treap tree, Item item)
{
    TreapLink x = tree->root;
    while (NULL != x && item != x->item)
    {
          x = (item < x->item) ? x->lchild : x->rchild;
    }
    return x;
}

static void Left_Rotate(Treap tree, TreapLink x)
{
       TreapLink y;
       if (!x || !x->rchild){perror("Cant Left_Rotate NULL  or NULL rchild");exit(-1);}
       y = x->rchild;
       x->rchild = y->lchild;
       if (y->lchild)
       {
           y->lchild->parent = x;
       }
       y->parent = x->parent;
       if (x == tree->root)
       {
           tree->root = y;
       }
       else
       {
           if ( x == x->parent->lchild)
           {
                x->parent->lchild = y;
           }
           else
           {
               x->parent->rchild = y;
           }
       }
       y->lchild = x;
       x->parent = y;
}

static void Right_Rotate(Treap tree, TreapLink x)
{
       TreapLink y;
       if (!x || !x->rchild){perror("Cant Right_Rotate NULL  or NULL rchild");exit(-1);}
       y = x->lchild;
       x->lchild = y->rchild;
       if (y->rchild)
       {
           y->rchild->parent = x;
       }
       y->parent = x->parent;
       if (x == tree->root)
       {
           tree->root = y;
       }
       else
       {
           if ( x == x->parent->lchild)
           {
                x->parent->lchild = y;
           }
           else
           {
               x->parent->rchild = y;
           }
       }
       y->rchild = x;
       x->parent = y;
}

static void fixinsertTreap(Treap tree, TreapLink link)
{

    while (NULL != link->parent && link->prio < link->parent->prio)
    {
          if (link == link->parent->lchild)
          {
              Right_Rotate(tree, link->parent);
          }
          else
          {
              Left_Rotate(tree, link->parent);
          }
    }
}

void insertTreap(Treap tree, Item item)
{
     TreapLink y, x = tree->root;
     if (!tree->root)
     {
         x = tree->root = NEW(item, tree->root);
         return;
     }
     while (NULL != x)
     {
           y = x;
           x = (item < x->item) ? x->lchild : x->rchild;
     }
     if (item < y->item)
     {
         x = y->lchild = NEW(item, y);
     }
     else
     {
         x = y->rchild = NEW(item, y);
     }
     fixinsertTreap(tree, x);
}

TreapLink deleteTreap(Treap tree, Item item)
{
    TreapLink z, y, x = findTreapNode(tree, item);
    Item t;
    if (!x){printf("Cant find item:%d to delete!\n", item);return NULL;}
    if (NULL != x->rchild)
    {
        y = x->rchild;
        while (NULL != y->lchild)
        {
              y = y->lchild;
        }
    }
    else
    {
        y = x;
    }
    z = (NULL != y->lchild) ? y->lchild : y->rchild;
    if (NULL != z)
    {
        z->parent = y->parent;
    }
    if (NULL != y->parent)
    {
        if (y == y->parent->lchild)
        {
            y->parent->lchild = z;
        }
        else
        {
            y->parent->rchild = z;
        }
    }
    else
    {
        tree->root = z;
    }
    if (y != x)
    {
          t = x->item;
          x->item = y->item;
          y->item = t;
    }
    return y;
}

static void midtravseTreapNode(TreapLink root)
{
     if (NULL != root)
     {
         midtravseTreapNode(root->lchild);
         printf("Item:%5d, Prio:%5d\n", root->item, root->prio);
         midtravseTreapNode(root->rchild);        
     }
}

static void pretravseTreapNode(TreapLink root)
{
     if (NULL != root)
     {
         printf("Item:%5d, Prio:%5d\n", root->item, root->prio);
         pretravseTreapNode(root->lchild);
         pretravseTreapNode(root->rchild);        
     }
}

void midtravseTreap(Treap tree)
{
     midtravseTreapNode(tree->root);
}

void pretravseTreap(Treap tree)
{
     pretravseTreapNode(tree->root);
}

void destroyTreap(Treap tree)
{
     TreapLink x;
     for (x = tree->root; NULL != x; x = tree->root)
     {
           x = deleteTreap(tree, x->item);
           free(x);
     }
     free(tree);
}