示例#1
0
AvlTree Insert(ElementType e, AvlTree t)
{
    if(t == NULL){
        t = malloc(sizeof(struct AvlNode)); 
        t->e = e;
        t->height = 0;
        t->left = NULL;
        t->right = NULL;
    }
    if(e < t->e){
        t->left = Insert(e, t->left); 
        if(Height(t->left) - Height(t->right) == 2){
            if(e < t->left->e){
                t = SingleRotateWithLeft(t); 
            }else{
                t = DoubleRotateWithLeft(t); 
            }
        }
    }else if(e > t->e){
        t->right = Insert(e, t->right); 
        if(Height(t->right) - Height(t->left) == 2){
            if(e > t->right->e){
                t = SingleRotateWithRight(t); 
            }else{
                t = DoubleRotateWithRight(t); 
            } 
        }
    }
    t->height = Max(Height(t->left), Height(t->right)) + 1;
    return t;
}
示例#2
0
AvlTree Insert(ElementType X,AvlTree T){
	//T为空树
	if(T == NULL){
        T = malloc(sizeof(AvlTree));
        if(T == NULL){
            fatalError("out of space");
        }

        T -> Element = X;
        T -> Left = NULL;
        T -> Right = NULL;
	}

    //此处遇到问题 应该如何分情况讨论呢 我需求的是X插入位置的节点情况 但是此时只有根节点T
    //所以插入应该递归地分左右插入 并且在插入后计算高度差值 差值2位中断情况 
    if(X < T-> Element){
        //再次遇到问题 用什么变量存left 要不要return
        //答案是直接递归修改left的值 最终改变的是叶节点指针 而非根节点
        T -> Left =  Insert(X , T -> Left);
        if(Height(T->Left) - Height(T->Right) == 2){
            //分情况
            if(X < T->Left->Element){
                T = SingleRotateWithLeft(T);
            }else{
                T = DoubleRotateWithLeft(T);
            }
        }

    }else{

    }

    return T;
}
示例#3
0
文件: AvlTree.cpp 项目: wfwei/coding
AvlTree Insert(int x, AvlTree root){
  if(root==NULL){
    root = (AvlNode *)malloc(sizeof(AvlNode));
    if(root == NULL){
      printf("Out of memory");
    }else{
      root->val = x;
      root->right = root->left = NULL;
    }
  } else if(x < root->val){
    root->left = Insert(x, root->left);
    if(Height(root->left)-Height(root->right) == 2){
      if(x<root->left->val)
        root = SingleRotateWithLeft(root);
      else
        root = DoubleRotateWithLeft(root);
    }
  } else if(x > root->val){
    root->right = Insert(x, root->right);
    if(Height(root->right)-Height(root->left) == 2){
      if(x>root->right->val)
        root = SingleRotateWithRight(root);
      else
        root = DoubleRotateWithRight(root);
    }
  }

  root->height = Max(Height(root->left), Height(root->right)) + 1;
  return root;
}
示例#4
0
文件: avltree.c 项目: chenckang/notes
AvlTree
Insert(ElementType X, AvlTree T)
{
  if (T == NULL)
  {
    T = malloc(sizeof(struct AvlNode));
    if (T == NULL)
    {
      Error("No additional memory!!");
      exit(1);
    }
    else {
      T->Element = X;
      T->Height = 0;
      T->Left = T->Right = NULL;
    }
  }
  else
  if (X < T->Element){
    T->Left = Insert(X, T->Left);
    if (Height(T->Left) - Height(T->Right) == 2)
    {
      if(X < T->Left->Element)
      {
        T = SingleRotateWithLeft(T);
      }
      else
      {
        T = DoubleRotateWithLeft(T);
      }
    }
  }
  else
  if (X > T->Element)
  {
    T->Right = Insert(X, T->Right);
      // printf("%d%s%d\n", Height(T->Right) - Height(T->Left), "Right", X);
    if (Height(T->Right) - Height(T->Left) == 2)
    {
      // printf("%d|%d\n", X, T->Right->Element);
      if (X > T->Right->Element)
      {
        T = SingleRotateWithRight(T);
      }
      else
      {
        T = DoubleRotateWithRight(T);
      }
    }
  }

  T->Height = Max(Height(T->Left), Height(T->Right)) + 1;
  return T;
}
示例#5
0
	struct AvlTreeNode *CAvlTree::InsertNode(const int key
		, struct AvlTreeNode *node)
	{
		if (node == NULL)
		{
			node = new struct AvlTreeNode;
			if (node == NULL)
			{
				std::cerr << "out of memory" << std::endl;
			}
			else
			{
				node->key = key;
				node->height = 0;
				node->left = node->right = NULL;
			}
		}
		else if (key < node->key)
		{
			node->left = this->InsertNode(key, node->left);
			if (this->Height(node->left) - this->Height(node->right) >= 2)
			{
				if (key < node->left->key)
				{
					node = SingleRotateWithLeft(node);
				}
				else
				{
					node = DoubleRotateWithLeft(node);
				}
			}
		}
		else if (key > node->key)
		{
			node->right = this->InsertNode(key, node->right);
			if (this->Height(node->right) - this->Height(node->left) >= 2)
			{
				if (key > node->right->key)
					node = SingleRotateWithRight(node);
				else
					node = DoubleRotateWithRight(node);
			}
		}
		/// \note else key is in the tree already, we will do nothing.
		node->height = std::max(this->Height(node->left)
			, this->Height(node->right)) + 1;
		return node;
	}
示例#6
0
void insert_tree(int data,AVLTree &node)
{
    if (node == NULL)
    {
        node = (AVL*)malloc(sizeof(AVL));
        node->data = data;
        node->height = 0;
        node->lchild = node->rchild = NULL;
        printf("test01\n");
        return;
    }
    else if (data < node->data)
    {
        insert_tree(data, node->lchild);
    }
    else if (data > node->data)
    {
        insert_tree(data, node->rchild);
    }
    
    node->height = Max(Height(node->lchild), Height(node->rchild)) + 1;
    
    if (Height(node->lchild) - Height(node->rchild) == 2)
    {
        if (node->lchild->data > data)
        {
            SingleRotateWithLeft(node);
        }
        else
        {
            DoubleRotateWithLeft(node);
        }
    }
    else if (Height(node->rchild) - Height(node->lchild) == 2)
    {
        if (node->rchild->data < data)
        {
            SingleRotateWithRight(node);
        }
        else
        {
            DoubleRotateWithRight(node);
        }
    }
}
示例#7
0
AvlTree Insert( ElementType X, AvlTree T )
{
    if( T == NULL )
    {
        /* Create and return a one-node tree */
        T = malloc( sizeof( struct AvlNode ) );
	T->Element = malloc(sizeof(int)*RULE_SIZE);        
	if( T == NULL )
            FatalError( "Out of space!!!" );
        else
        {
            memcpy(T->Element,X,RULE_SIZE*sizeof(int));
	    	T->Height = 0;
            T->Left = T->Right = NULL;
        }
    }
    else
        if(compareLeaf(X, T->Element)==-1 )
        {
            T->Left = Insert( X, T->Left );
            if( Height( T->Left ) - Height( T->Right ) == 2 )
                if( compareLeaf(X,T->Left->Element)==-1 )
                    T = SingleRotateWithLeft( T );
                else
                    T = DoubleRotateWithLeft( T );
        }
        else
            if( compareLeaf(X,T->Element)==1 )
            {
			
                T->Right = Insert( X, T->Right );
                if( Height( T->Right ) - Height( T->Left ) == 2 )
                    if( compareLeaf(X,T->Right->Element)==1 )
                        T = SingleRotateWithRight( T );
                    else
                        T = DoubleRotateWithRight( T );
            }
            /* Else X is in the tree already; we'll do nothing */
 
            T->Height = Max( Height( T->Left ), Height( T->Right ) ) + 1;
            return T;
}
//先把书上的avl插入函数手打一遍
AvlTree Insert(ElementType X, AvlTree T)
{
	if(T == NULL)
	{
		T = (AvlTree*)malloc(sizeof(struct AvlTree));
		if(T == NULL)
			printf("Out of space!\n");
		else
		{
			T->Height = 0;
			T->Right = NULL;
			T->Left = NULL;
			T->Element = X;
		}
	}
	else if(X < T->Element)
	{
		T->Left = Insert(X, T->Left);
		if(Height(T->Left) - Height(T->Right) == 2)
			if(X < T->Left->Element)
				SingleRotateWithLeft(T->Left);
			else
				DoubleRotateWithLeft(T->Left);
	}
	else if(X > T->Element)
	{
		T->Right = Insert(X, T->Right);
		if(Height(T->Right) - Height(T->Left) == 2)
			if(X > T->Right->Element)
				SingleRotateWithRight(T->Right);
			else
				DoubleRotateWithRight(T->Right);
	}

	T->Height = Max(Height(T->Left), Height(T->Right)) + 1;

	return T;
}
示例#9
0
AvlTree Insert(ElementType X, AvlTree T)
{
    if(T == NULL)
    {
        T = malloc(sizeof(struct AvlNode));
        if(T == NULL)
            FatalError("Out of space!!!");
        else
        {
            T->Element = X;
            T->Height = 0;
            T->Left = T->Right = NULL;
        }
    }
    else if(X < T->Element)
    {
        T->Left = Insert(X, T->Left);
        if(Height(T->Left) - Height(T->Right) == 2)
            if(X < T->Left->Element)
                T = SingleRotateWithLeft(T);
            else
                T = DoubleRotateWithLeft(T);
    }
    else if(X > T->Element)
    {
        T->Right = Insert(X, T->Right);
        if(Height(T->Right) - Height(T->Left) == 2)
            if(X > T->Right->Element)
                T = SingleRotateWithRight(T);
            else
                T = DoubleRotateWithRight(T);
    }

    T->Height = Max(Height(T->Left), Height(T->Right)) + 1;
    return T;
}
示例#10
0
void delete_node(AVLTree& root, int data)
{
    if (root == NULL) {
        printf("NULL to delete\n");
        return;
    }
    if (root->data == data) {
        AVLTree node = root;
        
        printf("begin to delete\n");
        if (root->lchild == NULL && root->rchild == NULL)
        {
            root = NULL;
        }
        else if(root->rchild != NULL && root->lchild != NULL)
        {
            AVLTree loop = root->rchild;
            while (loop->lchild != NULL) {
                loop = loop->lchild;
            }
            root->data = loop->data;
            delete_node(root->rchild, loop->data);
        }
        else
        {
            if (root->lchild == NULL) {
                root = root->rchild;
            }
            else
            {
                root = root->lchild;
            }
        }
        free(node);
    }
    else if (root->data < data)
    {
        delete_node(root->rchild, data);
    }
    else
    {
        delete_node(root->lchild, data);
    }
    
    if (root == NULL) {
        return;
    }
    
    root->height = Max(Height(root->lchild), Height(root->rchild)) + 1;
    
    if (Height(root->lchild) - Height(root->rchild) == 2)
    {
        if (Height(root->lchild->lchild) > Height(root->lchild->rchild))
        {
            SingleRotateWithLeft(root);
        }
        else
        {
            DoubleRotateWithLeft(root);
        }
    }
    if (Height(root->rchild) - Height(root->lchild) == 2)
    {
        if (Height(root->rchild->rchild) > Height(root->rchild->lchild))
        {
            SingleRotateWithRight(root);
        }
        else
        {
            DoubleRotateWithRight(root);
        }
    }
    
}