1.描述以下三个概念的区别：头指针、头结点、首元素结点.
头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针；
头结点是在链表的首元结点之前附设的一个结点；数据域内只放空表标志和表长等信息（内放头指针?那还得另配一个头指针!）
首元素结点是指链表中存储线性表中第一个数据元素a1的结点.
2.设计一个高效的算法。从顺序表L中删除所有介于x和y之间的所有元素，要求空间复杂度为O(1)
// An highlighted block
#include<stdio.h>
#include<stdlib.h>
#define X 3
#define Y 4
#define N 8
int a[N]={0,1,2,3,4,5,6,7};
void output(int *a,int n)
{
printf("%d\n",n);
int i=0;
for( i=0;i<n;i++)
{
printf("%d",*(a+i));//a[i]=*(a+i)
}
}
void del(int *a,int *n,int x,int y)
{
int i,j;
for(i=j=0;i<*n;i++)
if(a[i]>y||a[i]<x)
a[j++]=a[i];//选择合适的筛选条件，
*n=j;
}
int main()
{ int n;
n=N;
output(a,n);
del(a,&n,X,Y);//理解&的用法
output(a,n);
}
3.已知一个元素值递增有序的单链表L(允许出现值重复的结点)，设计算法删除值重复的结点。
void Simplification(List *head) { // 去除相同的集合元素
List *p,*q,*s;
p = head->next;
q = p->next;
while(q != head) {
if(p->num == q->num) {
p->next = q->next;
s = q;
q = q->next;
free(s);
}
else {
p = p->next;
q = q->next;
}
}
}
4.已知顺序表L中的元素为int，请写一时间复杂度O（n）、空间复杂度为O（1）的程序，将L中的奇数元素排在前面，偶数元素排在后面
Status exchangeEvenOddNumbers(SeqList &S){
int j = 0,k = 0;
for(int i = 0;i<=S.last;i++){
if(S.elem[i]%2 == 1){
k = S.elem[j];
S.elem[j] = S.elem[i];
S.elem[i] = k;
j++;
}else{
continue;
}
}
return OK;
};
5.编写算法，在一非递减的顺序表L中，删除所有值相等的多余元素。要求时间复杂度O（n），空间复杂度为O（1）
Status delExcrescentValue(SeqList &S){
int flag = 0,val = S.elem[0];//记录值不等的下标
//printf("%d\n",S.elem[0]);
for(int i = 1;i<=S.last;i++){
if(val != S.elem[i]){
val = S.elem[i];
flag+=1;
S.elem[flag] = val;
printSeqList(S);
}
}
S.last = flag;
return OK;
}
6. 已知线性表中的元素（整数）以值递增有序排列，并以单链表做存储结构。试写一个程序，删除表中所有大于mink且小于maxk的元素（若表中存在这样的元素）。
7.试分别以不同的存储结构实现线性表的就地逆置算法，即在原表的存储空间将线性表（a1, a2..., an）逆置为（an, an-1,..., a1）。
（1） 以一维数组作存储结构。 （2） 以单链表作存储结构。
8.已知一个带有表头结点的单链表，结点结构为data-next。假设链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点（k为正整数）。若查找成功，算法输出该结点的data域的值，并返回1；否则，则返回0.
9.假设两个按元素值递增有序排列的线性表A和B，均以单链表作为存储结构，请编写算法，将A表和B表归并成一个按元素值递减的有序排列的线性表C，并要求利用原表（即A表和B表的）结点空间存放表C，并要求利用原表（即A表和B表的）结点空间存放表C。
10.假设有一个循环链表的长度大于1，且表中既无头结点也无头指针。已知s为指向链表某个结点的指针，试编写算法在链表中删除指针s所指结点的前驱结点。
11.已知由单链表表示的线性表中含有三类字符的数据元素（如字母字符、数字字符和其它字符），试编写算法来构造三个以循环链表表示的线性表，使每个表只含有某一类的字符，且利用原表中的结点空间作为这三个表的结点空间，头结点可另辟空间。
12.将一个用循环链表表示的稀疏多项式分解成两个多项式，使这两个多项式中各自仅含奇次项或偶次项，并要求利用原链表中的结点空间来构成这两个链表。
13.编写一个算法,删除单链表L(L中元素值各不相同)的最大值所对应的结点,并返回该值
voidRemove(LinkListL,DataTypex)//设L是带头结点的单链表
{
Node*p=L,*q;
while(p->next!=NULL&&p->next->data!=x)p=p->next;
if(p->next!=NULL)
{
q=p->next;
p->next=q->next;
deleteq;
}
}
14.给出栈的两种存储结构的形式名称,在这两种栈的存储结构中如何判别栈空与栈满
(1)顺序栈 （top用来存放栈顶元素的下标）
判断栈S空：如果S->top==-1表示栈空。
判断栈S满：如果S->top==Stack_Size-1表示栈满。
(2) 链栈（top为栈顶指针，指向当前栈顶元素前面的头结点） 判断栈空：如果top->next==NULL表示栈空。
判断栈满：当系统没有可用空间时，申请不到空间存放要进栈的元素，此时栈满。
15.带头结点的循环链表表示队列, 并且只设一个指针指向队尾元素结点， 试编写相应的队列初始化,入队列和出队列的算法
//链式队列的初始化
Status InitLinkQueue(LinkQueue * L)
{
(*L)=(LinkQueue)malloc(sizeof(QNode));
if((*L)==NULL)
{
printf("内存分配失败！\n");
return OK;
}
(*L)->rear=(*L);
return OK;
}
//入队操作
Status EnQueue(LinkQueue * L,QElemType e)
{
LinkQueue P;
P=(LinkQueue)malloc(sizeof(QNode));
P->data=e;
P->next=(*L);
(*L)->rear->next=P;
(*L)->rear=P;
return OK;
}
//出队操作
Status DeQueue(LinkQueue * L,QElemType * e)
{
LinkQueue temp;
*e=(*L)->next->data;
temp=(*L)->next;
(*L)->next=(*L)->next->next;
delete(temp);
return OK;
}
16.要求循环队列不损失一个空间全部都能得到利用，设置一个标志域tag，以tag为0或1来区分头尾指针相同时队列
int EnQueue(SCQueue *SCQ,ElemType e)
{
if(SCQ->front == SCQ->rear && SCQ->tag == 1)
{
return 0;
}
else
{
SCQ->queue[SCQ->rear] = e;
SCQ->rear = SCQ->rear + 1;
SCQ->tag = 1;
return 1;
}
}
int DeQueue(SCQueue *SCQ,ElemType *e)
{
if(QueueEmpty(*SCQ)/*SCQ->front == SCQ->rear && SCQ->tag == 0*/)
{
return 0;
}
else
{
*e = SCQ->queue[SCQ->front];
SCQ->front = SCQ->front + 1;
SCQ->tag = 0;
return 1;
}
}
17.设有4个元素1、2、3、4依次进栈，而出栈操作可随时进行（进出栈可任意交错进行，但要保证进栈次序不破坏1、2、3、4的相对次序），请写出所有不可能的出栈次序和所有可能的出栈次序。
可能的次序：1243 1234 1324 1342 1432
2134 2143 2314 2341 2431
3214 3241 3421 4321
不可能的次序：1423
2413
3124 3142 3412
4312 4231 4213 4123 4132
