链表，栈，队列代码

typedef struct node
{
    ElemType data;
    struct node*prior, *next;
}dlink;

void initlist(slink *&sq)
{
    sq = (slink*) malloc(sizeof(slink));
    sq->next = NULL;
}

int getlen(slink*sq)
{
    int i = 0;
    slink*p = sq->next;//sq->next;
    while (p != NULL)
    {
        i++;
        p = p->next;
    }
    return i;
}

slink*getelem(slink*sq, int i)
{
    int j = 1;
    slink*p = sq->next;
    if (i<1 || i>sq.getlen(sq))
        return NULL;
    while (j < i)
    {
        p = p->next;
        j + +;
    }
    return p;//返回第二个结点的指针
}

slink*locate(slink*sq, ElemType x)
{
    slink*p = sq->next;
    while (p != null && p->data != x)
        p = p->next;
    return p;
}

int inselem(slink*sq, ElemType x, int i)
{
    int j = 1;
    slink*p = sq, *s;
    s = (slink*) malloc(sizeof(slink));
    s->data = x;
    s->next = NULL;
    if (i<1 || i>getlen(sq) + 1)
        return 0;
    while (j < i)//查找第i-1个结点，用p指向它，sq应该是头结点
    {
        p = p->next;
        j++;
    }
    s->next = p->next;
    p->next = s;
    return 1;
}

int delelem(slink *sq, int i)
{
    int j = 1;
    slink*p = sq, *q;
    if (i<1 || i>getlen(sq))
        return 0;
    while (j < i)
    {
        p = p->next;
        j++;
    }
    q = p - next;//q=p->next;p->next=q->next;
    p->next = q->next;
    free(p);
    return 1;
}

void displist(slink*sq)
{
    slink*p = sq->next;
    while (p != NULL)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

void move(sqlist A)//从左向右找A.data[i],从右向左找A.data[j]，直到i>j为止，巧妙的方式
{
    int i = 0, j = A.len - 1, k;//线性表，每个元素都是整数，用最少时间把所有为负数的元素移到全为正数的前面
    ElemType temp;
    while (i <= j)
    {
        while (A.data[i] <= 0)
            i++;//统计负数的个数
        while (A.data[j] >= 0)
            j--;//统计正数的个数
        if (i < j)
        {
            temp = A.data[i];
            A.data[i] = A.data[j];
            A.data[j] = temp;
        }
    }
}

void sort(sqlist s.sqlist t)
{
    sqlist r;
    int i = 0, j = 0, k = 0;
    while (i < s.len && j < t.len)
    {
        if (s.data[i] < t.data[j])
        {
            r.data[k] = s.data[i];
            i++;
            k++;
        }
        else if (s.data[i] > t.data[j])
        {
            r.data[k] = t.data[j];
            j++;
            k++;
        }
        else
        {
            r.data[k] = s.data[i];
            i++;
            k++;
            r.data[k] = t.data[j];
            j++;
            k++;
        }
    }
    while (i < s.len)
    {
        r.data[k] = s.data[i];
        i++;
        k++;
    }
    while (j < t.len)
    {
        r.data[k] = t.data[k];
        i++;
        k++;
    }
}

struct pointer
{
    int number;
    struct pointer*next;
};
void combine(struct pointer*&f, struct pointer*g)
{
    struct pointer *h, *p;
    h = (struct pointer*)malloc(sizeof(struct pointer));
    h->next = NULL;
    p = h;
    while (f != NULL && g != NULL)
    {
        if (f->number >= g->number)
        {
            p->next = f;
            p = p->next;
            f = f->next;
        }
        else
        {
            p->next = g;
            p = p->nex;
            g = g->next;
        }
        if (f == NULL)
            p->next = g;
        if (g == NULL)
            p->next = f;
        f = h->next;//f指向合并链表的开始结点，非头结点
        free(h);
    }
}

const int StackSize = 100;
typedef struct sqst
{
    ElemType data[StackSize];
    int top;
}sqstack;

void initstack(sqstack *&sq)
{
    sq = (sqstack*) malloc(sizeof(sqstack));
    sq->top = -1;
}

int push(sqstack *sq, ElemType x)
{
    if (sq->top == StackSize - 1)
        return 0;
    else
    {
        sq->top++;
        sq->data[sq->top] = x;
        return 1;
    }
}

int pop(sqstack *sq, ElemType &x)
{
    if (sq->top == -1)//栈空
        return 0;
    else
    {
        x = sq->data[sq->top];
        sq->top--;
        return 1;
    }
}

int gettop(sqstack*sq, ElemType &x)
{
    if (sq->top == -1)
        return 0;
    else
    {
        x = sq->data[sq->top];
        return 1;
    }
}

int empty(sqstack *sq)
{
    if (sq->top == -1)
        return 1;
    else
    {
        return 0;
    }
}

typedef struct stnode
{
    ElemType data;
    struct stnode*next;
}lkstack;
lkstack *ls;

void initstack(lkstack*&ls)
{
    lkstack *p;
    p = (lkstack*)malloc(sizeof(lkstack));
    p->data = x;
    p->next = ls;//创建结点
    ls = p;
}

int pop(lkstack *ls, ElemType&x)
{
    lkstack *p;
    if (ls == NULL)//栈空，下溢出
        return 0;
    else
    {
        p = ls;
        x = p->data;
        ls = p->next;
        free(p);
        return 1;
    }
}

int gettop(lkstack *ls, ElemType &x)
{
    if (ls == NULL)
        return 0;
    else
    {
        x = ls->data;
        return 1;
    }
}

int empty(lkstack *ls)
{
    if (ls = NULL)
        return 1;
    else
        return 0;
}

const int QueueSize = 20;
typedef struct sqqueue
{
    ElemType data[QueueSize];
    int front, rear;
}squeue;
squeue *qu;

void initqueue(squeue*&qu)
{
    qu = (squeue*) malloc(sizeof(squeue));
    qu->rear = qu->front = 0;
}

int enqueue(squeue*sq, ElemType x)
{
    if ((sq->rear + 1)%QueueSize == sq->front)
        return 0;
    sq->rear = (sq->rear + 1)%QueueSize;//队尾指针进1
    sq->data[sq->rear] = x;
    return 1;
}

#define MAXSIZE 100
typedef struct
{
    ElemType elem[MAXSIZE];
    int top;
}SqStack;

void InitStack(SqStack *s)
{
    s->top = -1;
}

int StackEmpty(SqStack *s)
{
    if (s.top == -1)
        return 1;
    else
        return 0;
}

void Push(SqStack *s, ElemType e)
{
    if（s->top = MAXSIZE - 1）
    {
        printf("StackSize is full\n");
        return;
    }
    s->top++;
    s->elem[s->top] = e;
}

void Pop(SqStack *s, ElemType *e)
{
    if (s->top == -1)
    {
        printf("Stack is empty");
        return;
    }
    *e = s->elem[s->top];
    s->top--;
}

void GetTop(SqStack s, ElemType *e)
{
    if (s.top == -1)
    {
        printf("The Stack  is Empty!");
        return;
    }
    *e = s.elem[s->top];
}

typedef struct node
{
    ElemType data;
    struct node*next;
}Node,*LinkStack;
void Push(LinkStack*s, ElemType e)
{
    Node*p;
    p = (Node*) malloc(sizeof(Node));
    p->data = e;
    p->next = *s;
    *s = p;
}

void Pop(LinkStack*s, ElemType*e)
{
    Node*p;
    if (*s = NULL)
    {
        printf("stack is empty!\n");
        return;
    }
    *e = (*s)->data;
    p = *s;
    (*s) = (*s)->next;
    free(p);
}