链表堆栈C实现

链表顺序结构

链表结构

typedef int ElementType;
typedef struct{
        ElementType Data[MAXSIZE];
        int Last; 
}List;

创建一个空顺序表

List* MakeEmpty(){
    List *Ptrl;
    Ptrl = (List*)malloc(sizeof(List));
    Ptrl->Last = -1;
    return Ptrl;
}

插入

void Insert(ElementType X,int i ,List* Ptrl){
    int j;
    if(Ptrl->Last == MAXSIZE - 1){
        printf("表满");
        return;
    }
    if(i < 1 || i > Ptrl->Last + 2){ //检查插入位置的合法性
        printf("位置不合法");
        return;
    }
    for(j = Ptrl->Last ; j >= i - 1 ; j --) //将a(i) ~ a(n)顺序向后移动
        Ptrl->Data[j + 1] = Ptrl->Data[j];
    Ptrl->Data[i - 1] = X;//新元素插入
    Ptrl->Last ++; //Last指向最后
    return;
}

查找

//成功返回索引值，否则返回-1
int Find(ElementType X ,List* Ptrl){
    int i = 0;
    while(i <= Ptrl->Last && Ptrl->Data[i] != X)
            i ++;
    if(i > Ptrl->Last) //没找到
        return -1;
    else
        return i;
}

删除

void Delete(int i,List *Ptrl){
    int j;
    if( i < 1 || i >Ptrl->Last + 1){          //检查空表及删除位置的合法性
        printf("不存在第%d个元素",i);
        return;
    }
    for(j = i ; j <= Ptrl->Last ; j ++)
        Ptrl->Data[j - 1] = Ptrl->Data[j];  //将a(i + 1) ~ a(n)顺序向前移动
    Ptrl->Last --; //Last 指向最后元素
    return;
}

链表链式结构实现

结构

typedef int ElementType;
typedef struct Node{
    ElementType Data;
    struct Node*Next;
}List;

创建链表

//创建链表,返回一个值为零的链表头
List* CreateNode(){
    List *p = (List*)malloc( sizeof(List) );
    p->Data = 0;
    p->Next = NULL;
    return p;
}

按序号查找

//返回第K个指针,没有就返回NULL
List* FindKth(int K,List* Ptrl){
    List *p = Ptrl->Next;
    int i = 1;
    while(p != NULL && i < K){
        p = p->Next;
        i ++;
    }
    if(i == K)
        return p;
    else
        return NULL;
}

按值查找

List* Find(ElementType X,List *Ptrl){
    List *p = Ptrl->Next;
    while(p != NULL && p->Data != X)
        p = p->Next;
    return p;
}

指定位序插入

List* Insert(ElementType X , int i , List* Ptrl){ //思路:找到i - 1个结点，若存在，申请新结点插入，否则结束
    List *p = NULL,*s = NULL;
    if(i == 1){
        s = (List*)malloc(sizeof(List));
        s->Data = X;
        s->Next = Ptrl->Next;
        Ptrl->Next = s;
        return Ptrl;
    }
    p = FindKth(i - 1 , Ptrl);
    if(p == NULL){
        printf("参数i错");
        return NULL;
    }
    else{
        s = (List*)malloc(sizeof(List));
        s->Data = X;
        s->Next = p->Next;
        p->Next = s;
        return Ptrl;
    }
}

删除指定位序元素

List* Delete(int i,List *Ptrl){ //思路:首先找到i - 1，也就是前一个结点，然后删除并释放空间
    List *p = NULL,*s = NULL;

    if(i == 1){
        s = Ptrl->Next;
        Ptrl->Next = s->Next;
        free(s);
        return Ptrl;
    }
    p = FindKth(i - 1,Ptrl);
    if(p == NULL){
        printf("第%d个结点不存在",i - 1);
        return NULL;
    }else if( p->Next == NULL){
        printf("第%d个结点不存在",i);
        return NULL;
    }else{
        s = p->Next;
        p->Next = s->Next;
        free(s);
        return Ptrl;    
    }
}

打印链表

void PrintNode(List* Ptrl){
    List* p = Ptrl->Next;
    while(p){
        printf(" %d ",p->Data );
        p = p->Next;
    }
}

栈

栈的结构

#define ERROR -1
typedef int ElementType;
typedef struct{
    ElementType Data[MaxSize];
    int Top;
}Stack;

创建栈

Stack* CreateStack(){
    Stack *s = NULL;
    s = (Stack*)malloc(sizeof(Stack));
    s->Top = -1;
    return s;
}

入栈

void Push(Stack* PtrS,ElementType item){
    if(PtrS->Top == MaxSize - 1){
        printf("栈满");
        return;
    }else{
        PtrS->Data[++ (PtrS->Top)] = item;
        return;
    }
}

出栈

ElementType Pop(Stack * PtrS){
    if(PtrS->Top == -1){
        printf("栈空");
        return ERROR;   //ERROR 是ElementType 特殊值，标志错误
    }else
        return(PtrS->Data[(PtrS->Top) -- ]);
}

判断栈空

int IsEmpty(Stack* S){
    if(S->Top == -1)
        return 1;
    else
        return 0;
}

队列

队列结构

#define ERROR -1
typedef int ElementType;
typedef struct{
    ElementType Data[MaxSize];
    int rear;
    int front;
}Queue;

创建队列

Queue* CreateQueue(){
    Queue * q;
    q = (Queue*)malloc(sizeof(Queue) );
    q->rear = -1;
    q->front = -1;
    return q;
}

入队

void AddQ(Queue* PtrQ, ElementType item){
    PtrQ->Data[++ (PtrQ->rear)] = item;
}

出队

ElementType DeleteQ(Queue* PtrQ){
    if(PtrQ->front == PtrQ->rear){
        printf("队列空");
        return ERROR; //错误的标志
    }else{
        return PtrQ->Data[++ PtrQ->front];
    }
}