# 基本数据结构(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];
{
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]出发调整败者树。
}