Algorithms: Treap树

Treap(树)其实就是二叉树的加强版，只不过多了一个优先级，并要求其优先级满足堆序！

/*--------------------------------------------------------------------------------------
 * Project: Main.cpp
 * Name: zwp
 * Date: 2014/4
 *--------------------------------------------------------------------------------------*/



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


int main(int argc, char* argv[])
{
	Treap T = Initialize();


	for(int index = 0; index < 10; ++ index)
		Insert(index, T);

	Travse(T);

	system("pause");
	return 0;

}



 
 
/*----------------------------------------------------------------------------------
 * Project: Treap.h
 * Name: zwp
 * Date: 2014/4
 *----------------------------------------------------------------------------------*/



#ifndef TREAP_H_
#define TREAP_H_



typedef int ElementType;

struct TreeNode;
typedef struct TreeNode *Treap;



/*
** 初始化
*/
Treap Initialize(void);

/*
** 判空
*/
bool IsEmpty(Treap T);


/*
** 插入
*/
Treap Insert(ElementType item, Treap T);


/*
** 删除
*/
Treap Remove(ElementType item, Treap T);

/*
** 搜索
*/
Treap Search(ElementType item, Treap T);

/*
** 遍历
*/
void Travse(Treap T);



#endif



 
/*------------------------------------------------------------------------------------
 * Project: Treap.cpp
 * Name: zwp
 * Date: 2014/4
 *------------------------------------------------------------------------------------*/


#include "Treap.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>

/*
** define  Treap Tree
*/
struct TreeNode
{
	ElementType Element;
	TreeNode* Left;
	TreeNode* Right;
	int       Priority;
};



static int Random(void)
{
	srand(time(0));

	return rand();
}



/*
** 右旋转
*/
static Treap SingleRotateWithLeft(Treap K2)
{
	Treap K1;

	K1 = K2->Left;
	K2->Left = K1->Right;
	K1->Right = K2;

	return K1;
}


/*
** 左旋转
*/
static Treap SingleRotateWithRight(Treap K2)
{
	Treap K1;

	K1 = K2->Right;
	K2->Right = K1->Left;
	K1->Left = K2;
	 
	return K1;
}


/*
** 初始化
*/
Treap Initialize(void)
{
	TreeNode* N = (TreeNode*)malloc(sizeof(struct TreeNode));
	if(N == NULL)
		printf("Out of space....\n");

	N->Left = N->Right = NULL;
	N->Element = 0;
	N->Priority = 0;

	return N;
}



/*
** 判空
*/
bool IsEmpty(Treap T)
{
	return T ? false : true;
}



/*
** 插入
*/
Treap Insert(ElementType item, Treap T)
{
	if(T == NULL)
	{
		/* Create and return a one-node tree */
		T = (TreeNode*)malloc(sizeof(struct TreeNode));
		if(T == NULL)
			printf("Out of space...\n");
		else
		{
			T->Element = item;
			T->Left = T->Right = NULL;
			T->Priority = Random();				/* 优先级为随机数 */
		}
	}
	else if(item < T->Element)
	{
		T->Left = Insert(item, T->Left);
		if(T->Left->Priority < T->Priority)		/* 优先级要满足堆序 */
			T = SingleRotateWithLeft(T);		/* 右旋转 */

	}
	else if(item > T->Element)
	{
		T->Right = Insert(item, T->Right);
		if(T->Right->Priority < T->Priority)
			T = SingleRotateWithRight(T);		/* 左旋转 */

	}
	/* Otherwise, it‘s already in Treap-Tree */
	
	return T;
}


/*
** 删除
*/
Treap Remove(ElementType item, Treap T)
{
	if(T != NULL)
	{
		if(item < T->Element)
			T->Left = Remove(item, T->Left);
		else if(item > T->Element)
			T->Right = Remove(item, T->Right);
		else
		{
			/* 左子枝的优先级小于右子枝的优先级 则执行右旋 */
			if(T->Left->Priority < T->Right->Priority)
				T = SingleRotateWithLeft(T);
			/* 负责执行左旋 */
			else
				T = SingleRotateWithRight(T);

			/* 删除它 */
			if(T != NULL)
				T = Remove(item, T);
			else
			{
				/* 在树叶子上 */
				free(T->Left);
				T->Left = NULL;
			}
		}
	}
	return T;
}




/*
** 删除
*/
Treap Search(ElementType item, Treap T)
{
	if(T != NULL)
	{
		if(item < T->Element)
			T->Left = Search(item, T->Left); 
		else if(item > T->Element)
			T->Right = Search(item, T->Right);
		else
			return T;
	}
	else
	{
		printf("The TreapTree is Empty....\n");
		return NULL;
	}

}



/*
** 遍历
*/
void Travse(Treap T)
{
	if(T != NULL)
	{
		Travse(T->Left);
		printf("%d  \n", T->Element);
		Travse(T->Right);

	}
}



 
 
Algorithms: Treap树,布布扣,bubuko.com
Algorithms: Treap树
原文：http://blog.csdn.net/qqzwp/article/details/23612515