链表，栈，队列代码

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);
}