c语言数据结构轮子

1、head.h

//文件名：head.h
//预定义常量及常用头文件
#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<malloc.h>
#include<math.h>
#include<process.h>
#define TURE 1;
#define FALSE 0;
#define OK 1;
#define ERROR 0;
#define INFEASIBLE -1;//不可行
typedef int Status;//Status是函数的类型，其值是函数结果的状态代码，如OK等
typedef int Boolean;//布尔类型，值为TURE 或 FALSE
typedef int ElemType;//数据元素定义，用户在使用该数据类型也可自行定义

2、单链表

//文件名：linklist.h
#include"head.h"
typedef struct LNode
{
    int data;
    struct LNode*next;
}LNode,*LinkList;  //LinkList L:L是一个指向LNode类型变量的指针

//1、初始化
//函数：InitList(LinkList &L)
//功能：构造一个空单链表，指分配一个节点的存储空间，并令指针域节点为空 
void InitList(LinkList &L)
{
    L=(LinkList)malloc(sizeof(LNode));//？？？
    if(!L)exit(1); //exit():用在子程序中终结程序用的，exit(0)：表示正常退出；exit(1):表示异常退出
    L->next=NULL;
}

//2、求链长
//函数：ListLenth(LinkList L)
//功能：返回带头节点单链表长度
int ListLenth(LinkList L)
{
    int len=0;
    LinkList p=L->next;
    while(p!=NULL)
    {
        ++len;
        p=p->next;
    }
    return len;
}


//3、判断空
//函数：ListEmpty(LinkList L)
//功能：判断单链表是否为空
int ListEmpty(LinkList L)
{
    if(L->next==NULL)return TURE;
    return FALSE;
}


//4、取元素
//函数:GetELem(LinkList L,int i,ElemType &e)
//功能:当第i个元素存在时，赋值给e，返回1，否则返回0；
int GetELem(LinkList L,int i,ElemType &e)//ELemType为元素类型，用户自定（默认int） 
{                                        //int &e为引用，效果相当于int *e，详见博客。
    //L:带头节点的单链表的头指针
    int j;
    LinkList p;
    p=L->next;j=1;//初始化p指向第一个节点,j:节点计数器
    while(p||j<i)//顺着指针向后查找，直到p指向第i个元素或p为空
    {
        p=p->next;
        j++;
    }
    if(!p||j>i)return ERROR;
    e=p->data;
    return OK;
}


//5、插入节点
//函数：ListInsert(LinkList &L,int i,ElemType e)
//功能：在带头节点的单链表L第i-1与i个位置之间插入元素e
int ListInsert(LinkList &L,int i,ElemType e)
{
    LinkList p=L,s;
    int j=0;
    while (p||j<i-1)
    { p=p->next; j++;}//寻找第i-1个节点
    if(!p||j>i-1)return ERROR;
    s=(LinkList)malloc(sizeof(LNode));//创建新节点
    s->data=e;
    s->next=p->next;        //插入
    p->next=s;
    return OK;
}

////////////////////////////////////////////////////////////////
//有时候LinkList &L会报错，将上函数改成以下即可，功能一样：
LinkList ListInsert(LinkList L,int i,int e)
{
    LinkList p=L,s;
    int j=0;
    while (p&&j<i-1)
    { p=p->next; j++;}//寻找第i-1个节点
    if(!p||j>i-1)return 0;
    s=(LinkList)malloc(sizeof(LNode));//创建新节点
    s->val=e;
    s->next=p->next;        //插入
    p->next=s;
    return p;
}


//6、删除节点
//函数：ListDelete(LinkList &L,int i,ElemType &e)
//功能：删除带头节点的单链表L的第i个节点，并用e返回被删除节点的值
int ListDelete(LinkList &L,int i,ElemType &e)
{
    LinkList p=L,q;
    int j=0;
    while (p||j<i-1)
    { p=p->next; j++;}//寻找第i-1个节点
    if(!p||j>i-1)return ERROR;
    q=p->next;
    p->next=q->next;
    e=q->data;
    free(q);
    return OK;

}


//7、按值查找
//书有错，自改之
//函数：LocateElem(LinkList L,ElemType e)
//功能：按值查找，从头指针开始遍历，依次将被遍历到的结点的值与给定值比较，
//如果相等返回首次出现与给定值相等的数据元素序号，成为查找成功，否则返回0表示失败。
int LocateElem(LinkList L,ElemType e)
{
    int i=1;
    LinkList p=L->next;//p的初值为第一个节点的指针
    while (p&&p->data!=e)
    {
        ++i;
        p=p->next;
    }
    if(i<=ListLenth(L))return i;
    else return 0; 
    
}



//8、新建链表
//函数：CreateList(LinkList &L,int n)
//功能：逆序输入n个元素的值，建立带表头节点的单链表La
void CreateList(LinkList &L,int n)
{
    LinkList p;int i;
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;   //这两句给初始化了个带头节点的空单链表，L定义完就行，不用InitList
    for(i=n;i>0;i--)
    {
        p=(LinkList)malloc(sizeof(LNode));//产生新节点
        scanf("%d",&p->data);             //输入元素值
        p->next=L->next;                  //插入到表头
        L->next=p;
    }
    
}

3、栈

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef struct
{
    int *base;
    int *top;
    int stacksize;
}SqStack;


//函数：InitStack(SqStack &S)
//功能：构造一个空栈
int InitStack(SqStack &S)
{
    S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));
    if(!S.base)exit(1);//overflow
    S.top=S.base
    S.stacksize=STACK_INIT_SIZE;
    return OK;
}


//函数：入栈
//功能：插入元素e为新的栈顶元素
int Push(SqStack &S,SElemtype e)
{
    if(S.top-S.base>=S.stacksize)
    {
        S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!S.base)exit(1);//overflow
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;//先将e赋给S.top所指向元素，S.top再自增
    return OK;
}


//函数：出栈
//功能：出栈
int Pop(SqStack &S,SElemType &e)
{
    if(S.top==S.base) return ERROR;//栈空不能出栈
    e=*--S.top;//S.top先自减再做*运算
    return OK;
}

4、对列

#include"head.h"
#define MAXSIZE 1024
typedef struct 
{
    ElemType*base;//顺序列表基址
    int rear,front;//队尾队头指针
}SqQueue;


//函数：InitQueue(SqQueue &Q)
//功能：初始化循环队
int InitQueue(SqQueue &Q)
{
    Q.base=(ElemType*)malloc(MAXSIZE*sizeof(ElemType));
    Q.front=Q.rear=0;
    return OK;
}

//函数：EnQueue(SqQueue &Q,ElemType e)
//功能：将e入队
int EnQueue(SqQueue &Q,ElemType e)
{
    if(Q.rear==(Q.rear+1)%MAXSIZE)return ERROR;//队列满
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXSIZE;
    return OK; //入队完成
}


//函数：DeQueue(SqQueue &Q,ElemType &e)
//功能：若对列不空，删除队头元素，用e返回其值
int DeQueue(SqQueue &Q,ElemType &e)
{
    if(Q.front==Q.rear+1)return ERROR;
    e=Q.base[Q.front];
    Q.front=(Q.front+1)%MAXSIZE;
    return OK;
}