基本数据结构(C)

栈：

#include "stdio.h"
#include "stdlib.h"
#define MAX_SIZE 100
typedef struct stack
{
    int *base;
    int top;
}Stack;
int InitStack(Stack *stack)
{
    stack->base=(int *)malloc(MAX_SIZE*sizeof(int));
    if(!stack->base) return -1;
    stack->top=0;
    return 1;
}
int IsEmpty(Stack *stack)
{
    if(0==stack->top) return 1;
    return 0;
}
int IsFull(Stack *stack)
{
    if(MAX_SIZE-1==stack->top) return 1;
    return 0;
}
int Push(Stack *stack,int e)
{
    if(!IsFull(stack))
    {
        stack->base[stack->top]=e;stack->top+=1;
        return 1;
    }
    return -1;
}
int Pop(Stack *stack)
{
    if(!IsEmpty(stack))
    {
        stack->top-=1;
        return stack->base[stack->top];
    }
    return -1;
}
void main()
{
    int i=1;
    Stack *stack=(Stack *)malloc(sizeof(Stack));
    if(InitStack(stack))
    {
        while(i<=10)
        {
            Push(stack,i);
            i++;
        }
    }
    printf("栈中元素出栈(先进后出)：\n");
    while(!IsEmpty(stack))
    printf("%d\t",Pop(stack));
}

队列：

#include "stdio.h"
#include "stdlib.h"
#define MAX_SIZE 10//虽然容量是10，但注意该循环队列只能保存9个整数
typedef struct queue
{
    int *base;
    int rear;
    int front;
}SqQueue;
//初始化循环队列
int InitQueue(SqQueue *sqqueue)
{
   sqqueue->base=(int *)malloc(MAX_SIZE*sizeof(int));
   if(!sqqueue->base)return -1;
   sqqueue->rear=0;
   sqqueue->front=0;
   return 1;
}
//入队
int EnQueue(SqQueue *sqqueue,int e)
{
    if((sqqueue->rear+1)%MAX_SIZE==sqqueue->front)return -1;
    sqqueue->base[sqqueue->rear]=e;
    sqqueue->rear=(sqqueue->rear+1)%MAX_SIZE;
    return 1;
}
//获取对头元素
int FrontQueue(SqQueue *sqqueue)
{
    if(Empty(sqqueue))return -1;
    return sqqueue->base[sqqueue->front];
}
//出队
int DeQueue(SqQueue *sqqueue)
{
    int i=0;
    if(sqqueue->rear==sqqueue->front)return -1;
    i=FrontQueue(sqqueue);
    sqqueue->front=(sqqueue->front+1)%MAX_SIZE;
    return i;
}
//判断队列是否为空。注意空和满的条件
int Empty(SqQueue *sqqueue)
{
     if(sqqueue->rear==sqqueue->front)
        return 1;
     else
        return 0;
}
void main()
{
    int i=1;
    SqQueue *sqqueue=(SqQueue *)malloc(sizeof(SqQueue));
    if(InitQueue(sqqueue))
    {
        while(i<=10)//最后一次入队失败。因为要损失一个空间存放尾指针
        {
             EnQueue(sqqueue,i);
             i++;
        }


    }
    printf("打印队列元素\n");
    while(!Empty(sqqueue))
        printf("%d\n",DeQueue(sqqueue));


}

败者树：

#include "stdio.h"
#define K 8
#define MINKEY -1//比所有关键字都小的一个值
#define MAXKEY 1000//比所有关键字都大的一个值
int b[K];
void Adjust(int ls[K],int s)//败者树存储在ls[1]~ls[K-1]中，s为记录所在的归并段号
{
    int t,temp;
    t=(s+K)/2;//t为b[s]的父节点所在败者树中的下标，K是归并段数
    while(t>0)//没有到达树根则继续
    {
        if(b[s]>b[ls[t]]){//与父节点指示的数据进行比较
            temp=s;s=ls[t];//指示胜者，胜者将去参加更上一层比较
            ls[t]=temp;//ls[t]记录败者所在的段号
        }
        t=t/2;//向树根回退一层
    }
    ls[0]=s;//ls[0]记录本趟最小关键字所在的短号
}
int Get_next(int i)
{


}
void K_merger(int ls[K])
/*ls[0]~ls[K-1]是败者树的内部节点。b[0]~b[K-1]分别存储K个初始归并段的当前记录*/
/*函数Get_next(i)从第i个归并段读取并返回当前记录，若归并段为空，则返回MAXKEY*/
{
    int b[K+1],i,q;
    for(i=0;i<K;i++)
        b[i]=Get_next(i);//分别读取K个归并段的第一个关键字
    b[K]=MINKEY;
    for(i=0;i<K;++i)ls[i]=K;//创建败者树，设置ls中败者的初值。
    for(i=K-1;i>=0;--i)//依次从b[K-1],b[K-1]..b[0]出发调整败者树。
        Adjust(ls,i);
    while(b[ls[0]]!=MAXKEY)//ls[0]记录本趟最小关键字所在的段号
    {
        q=ls[0];//q是当前最小关键字的所在的归并段。
        printf("%d",b[q]);
        b[q]=Get_next(q);
        Adjust(ls,q);
    }
}