二叉排序树

#ifndef _AVL_TREE_H__
#define _AVL_TREE_H__

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

typedef int ETYPE;
typedef struct AVLNode{
	ETYPE elem;
	int hight;
	struct AVLNode *lchild;
	struct AVLNode *rchild;
}AVLNode,*AVLTree;

void avl_tree_init(AVLTree *proot);//创建平衡二叉树
bool avl_tree_empty(AVLTree root);//判断是否为空
size_t avl_tree_size(AVLTree root);//元素个数
size_t avl_tree_hight(AVLTree root);//树的高度

int avl_tree_insert(AVLTree *proot,ETYPE elem);//插入元素
int avl_tree_delete(AVLTree *proot,ETYPE elem);//删除元素

void avl_tree_front_travel(AVLTree root,void (*travel)(ETYPE));//前序遍历 先根  后左右子树 
void avl_tree_mid_travel(AVLTree root,void (*travel)(ETYPE));//中序 先左  再根  最后右子树 
void avl_tree_back_travel(AVLTree root,void (*travel)(ETYPE));//后序先左右子树 最后根结点 
//AVTree tree = NULL;  avl_tree_clear(&tree);
void avl_tree_clear(AVLTree *proot);
void avl_tree_destroy(AVLTree *proot);

#endif //_AVL_TREE_H__

#include "avltree.h"

//插入的结点作为叶子结点 
static struct AVLNode *avl_tree_create_node(ETYPE elem){
	struct AVLNode *node = (struct AVLNode *)malloc(sizeof(struct AVLNode));
	if(node!=NULL){
		node->elem = elem;
		node->hight = 1;
		node->lchild = NULL;
		node->rchild = NULL;
	}
	return node;
}


#define HIGHT(node) (node==NULL?0:node->hight)
#define REHIGHT(node) (HIGHT(node->lchild)>HIGHT(node->rchild)?HIGHT(node->lchild)+1:HIGHT(node->rchild)+1)
enum BALANCE{LL=2,RR=-2}; 
/*
	     |                                           |
	   node                                        left 
	   /  \            node结点进行右旋           /    \
	left  right                                  ll    node
	/ \                                                /  \
   ll  lr                                             lr   right
*/
static struct AVLNode *LL_rotate(AVLNode *node){
	struct AVLNode *left = node->lchild;
	node->lchild = left->rchild;
	left->rchild = node;
	node->hight = REHIGHT(node);
	left->hight = REHIGHT(left);
	return left;
}
/*
         |                                                |
       node                                             right 
       /  \                   node结点进行左旋          /   \
     left  right                                      node   rr
            / \                                       /  \
           rl  rr                                   left  rl
*/
static struct AVLNode *RR_rotate(AVLNode *node){
	struct AVLNode *right = node->rchild;
	node->rchild = right->lchild;
	right->lchild = node;
	node->hight = REHIGHT(node);
	right->hight = REHIGHT(right);
	return right;
}
/* 
         |                              |                                   |
       node                            node                                lr  
       /  \                            /   \                              /   \
	left   right    --left左旋        lr   right       node进行右旋      left  node
	/  \                             /                                   /       \
   ll   lr                          left                               ll        right
                                    /
                                  ll
*/
static struct AVLNode *LR_rotate(AVLNode *node){
	node->lchild = RR_rotate(node->lchild);
	return LL_rotate(node);
}
/* 
         |                              |                                   |
       node                            node                                 rl  
       /  \                            /   \                              /   \
	left  right    --right右旋       left   rl       node进行左旋       node   right
           /  \                              \                           /       \
          rl  rr                             right                     left       rr
                                                \
                                                rr   
*/
static struct AVLNode *RL_rotate(AVLNode *node){
	node->rchild = LL_rotate(node->rchild);
	return RR_rotate(node);
}



static void avl_tree_repair(AVLTree *proot){
	int lh = HIGHT((*proot)->lchild);
	int rh = HIGHT((*proot)->rchild);
	if(lh-rh==LL){
		struct AVLNode *left = (*proot)->lchild;
		int llh = HIGHT(left->lchild);
		int lrh = HIGHT(left->rchild);
		if(llh>=lrh){//LL 
			*proot = LL_rotate(*proot);
		}else{//LR
			*proot = LR_rotate(*proot);
		}
	}else if(lh-rh==RR){
		struct AVLNode *right = (*proot)->rchild;
		int rlh = HIGHT(right->lchild);
		int rrh = HIGHT(right->rchild);
		if(rlh>rrh){//RL
			*proot = RL_rotate(*proot);
		}else{//RR
			*proot = RR_rotate(*proot);
		}
	}
}

int avl_tree_insert(AVLTree *proot,ETYPE elem){
	//用栈保存比较的每一个结点   插入成功之后  取出栈中所有结点 依次调整高度 如果失衡进行调整
	if(*proot == NULL){
		*proot = avl_tree_create_node(elem);
		if(*proot == NULL){
			return -2;//申请内存失败 
		} 
		return 0;//插入成功    return *proot == NULL ? -2 : 0; 
	} 
	int ret = 0;
	if(elem < (*proot)->elem){
		ret = avl_tree_insert(&(*proot)->lchild,elem);
	}else if(elem > (*proot)->elem){
		ret = avl_tree_insert(&(*proot)->rchild,elem);
	}else{
		return -1;//插入相同的元素  直接失败 
	}
	if(ret == 0){//插入成功  修复平衡  调整高度 
		avl_tree_repair(proot);
		(*proot)->hight = REHIGHT((*proot)); 
	}
	return ret;
}
int avl_tree_delete(AVLTree *proot,ETYPE elem){
	if(*proot == NULL){
		return -1;
	}
	int ret = 0;
	if(elem == (*proot)->elem){
		struct AVLNode *node = *proot;
		if(node->lchild!=NULL && node->rchild!=NULL){
			for(node = node->lchild;node->rchild!=NULL;node=node->rchild);
			(*proot)->elem = node->elem;
			//去删除右子树中的最大值 
			ret = avl_tree_delete(&(*proot)->lchild,node->elem);//必须用递归调用去删除 
		}else{
			*proot = node->lchild!=NULL?node->lchild:node->rchild;
			free(node);
			return 0;
		}
	}
	if(elem < (*proot)->elem){
		ret = avl_tree_delete(&(*proot)->lchild,elem);
	}else{
		ret = avl_tree_delete(&(*proot)->rchild,elem);
	}
	if(ret == 0){
		avl_tree_repair(proot);
		(*proot)->hight = REHIGHT((*proot)); 
	}
	return ret;
}


void avl_tree_init(AVLTree *proot){
	*proot = NULL; 
}
bool avl_tree_empty(AVLTree root){
	return root == NULL;
}
size_t avl_tree_size(AVLTree root){
	if(root==NULL)
		return 0;
	return 1+avl_tree_size(root->lchild)+avl_tree_size(root->rchild);
}
size_t avl_tree_hight(AVLTree root){
	return root==NULL?0:root->hight;
}


void avl_tree_front_travel(AVLTree root,void (*travel)(ETYPE)){
	if(root!=NULL){
		travel(root->elem);
		avl_tree_front_travel(root->lchild,travel);
		avl_tree_front_travel(root->rchild,travel);
	}
}
void avl_tree_mid_travel(AVLTree root,void (*travel)(ETYPE)){
	if(root!=NULL){
		avl_tree_mid_travel(root->lchild,travel);
		travel(root->elem);
		avl_tree_mid_travel(root->rchild,travel);
	}
}
void avl_tree_back_travel(AVLTree root,void (*travel)(ETYPE)){
	if(root!=NULL){
		avl_tree_back_travel(root->lchild,travel);
		avl_tree_back_travel(root->rchild,travel);
		travel(root->elem);
	}	
}
void avl_tree_clear(AVLTree *proot){
	if(*proot!=NULL){
		avl_tree_clear(&(*proot)->lchild);
		avl_tree_clear(&(*proot)->rchild);
		free(*proot);
		*proot = NULL;
	}
}
void avl_tree_destroy(AVLTree *proot){
	avl_tree_clear(proot);
}

#ifndef _QUEUE_H__
#define _QUEUE_H__

#include "binsorttree.h"

typedef struct BNode * BNT;

typedef struct Queue{
	BNT *data;
	size_t cap;
	size_t size;
	size_t first;
}Queue;

int queue_init(Queue *pq,size_t cap);//初始化队列
bool queue_empty(Queue *pq);//判断是否为空
bool queue_full(Queue *pq);//是否满了
int queue_push(Queue *pq,BNT elem);//压入数据
BNT queue_pop(Queue *pq);//弹出数据
void queue_destroy(Queue *pq);//销毁队列



#endif //_QUEUE_H__

#include "queue.h"
/*
typedef struct Queue{
	BNT *data;
	size_t cap;
	size_t size;
	size_t first;
}Queue;
*/
int queue_init(Queue *pq,size_t cap){
	pq->data = malloc(sizeof(BNT)*cap);
	if(pq->data == NULL)
		return -1;
	pq->cap = cap;
	pq->size = 0;
	pq->first = 0;
	return 0;
}
bool queue_empty(Queue *pq){
	return pq->size == 0;
}
bool queue_full(Queue *pq){
	return pq->size == pq->cap;
}
int queue_push(Queue *pq,BNT elem){
	if(queue_full(pq))
		return -1;
	pq->data[(pq->first+pq->size)%pq->cap] = elem;
	++pq->size;
	return 0;
}
BNT queue_pop(Queue *pq){
	if(queue_empty(pq))
		return NULL;
	BNT data = pq->data[pq->first];
	++pq->first;
	if(pq->first>=pq->cap)
		pq->first = 0;
	--pq->size;
	return data;
}
void queue_destroy(Queue *pq){
	free(pq->data);
}

#ifndef _STACK_H__
#define _STACK_H__

#include "binsorttree.h"

typedef struct BNode * ET;

typedef struct Stack{
	ET *data;
	size_t cap;
	size_t size; 
}Stack;

int stack_init(Stack *ps,size_t cap);//初始化栈
bool stack_empty(Stack *ps);//判断是否为空
bool stack_full(Stack *ps);//判断是否满了
int stack_push(Stack *ps,ET data);//压入数据
ET stack_pop(Stack *ps);//弹出数据
void stack_destroy(Stack *ps); //销毁栈

#endif //_STACK_H__

#include "stack.h"
int stack_init(Stack *ps,size_t cap){
	ps->data = malloc(sizeof(ET)*cap);
	if(ps->data == NULL){
		return -1;
	}
	ps->cap = cap;
	ps->size = 0;
}

bool stack_empty(Stack *ps){
	return ps->size == 0;
}
bool stack_full(Stack *ps){
	return ps->size == ps->cap;
}
int stack_push(Stack *ps,ET data){
	if(stack_full(ps))
		return -1;
	ps->data[ps->size++] = data;
	return 0;
}
ET stack_pop(Stack *ps){
	return ps->data[--ps->size];
}
void stack_destroy(Stack *ps){
	free(ps->data);
}