数据结构习题解答1-3

//L为带头节点的单链表的头指针，本算法返回链表中元素的个数
p=L; n=0;
while (p->next)
{ p=p->next; n++; }
return n;
}
2.21
void InvertSqList (SqList a){
for (i=0; i<=a.length/2-1;i++)
a.elem[i]<->a.elem[a.length-1-i];
va.elem=newbase;
va.listsize+=LISTINCREMENT;
}
p=va.elem+va.length-1;
while(p>=va.elem && *p>x ){
*(p+1)=*p;
p--;
}
++p=x; va.length++;
return OK;
} //InsertOrderList
if (tws.top1= =tws.base+STACKSIZE-1) return ERROR;
tws.top1++;}
return OK
}// pop操作可以有返回值，也可以没有。教材中pop操作有返回值，而本题不要求有返回值
3.24
int g (int m, int n)
{
if ( m< 0 || n<0) return INFEAIBLE; //返回-1,参数无意义
栈和队列
3.1
（1）123，132，213，231，321
（2）435612不可能得到，由于4第一个出栈，所以必须先将1，2，3依次连续进栈；1在栈底，不可能先于2出栈，故不能得到出栈序列435612。
135426可以得到，操作序列为SXSSXSSXXXSX
3.2
栈和线性表的差别是操作定义不同。栈是限定仅在表尾进行插入或删除操作的线性表。
f = rear->next ; // f指向头节点
p = f->next; //p指向首节点
e = p->data;
f->next=p->next; //摘除首节点
if ( p= =rear) rear=f; //队列中只有一个元素，删除后为空队列
free (p);
return OK;
}
3.30
//循环队列类型定义
if (m= =0 ) return 0;
return g (m-1,2*n)+n;
}
g (5,2) =62;
3.28
Status InitQueue (QueuePtr &rear)//QueuePtr为指针类型，教材中为结构体类型LinkQueue
{
//带头节点的循环链式队列初始化，rear为其尾指针
2.1头指针是指向链表中最前面的节点的指针。
若链表带头节点，则头指针恒指向头节点。
若链表不带头节点，则当链表非空时，头指针指向首元节点；链表为空时，头指针也为空。
头节点是为了方便链表的操作而在链表头部附设的一个节点，其数据域可以不存任何信息，也可以存储表长等信息。
首元节点为链表中存储线性表第一个数据元素的节点，即线性表中第一个数据元素的存储映像。
void inistack ( DuStack &tws)
{
tws.top0=tws.base ; tws.top1=tws.base+ STACKSIZE-1;
}
Status push ( DuStack &tws, int i , SElemType x){
if ( tws.top0= =tws.top1+1) return ERROR //双向栈满(或tws.top0>tws.top1)
3.9《题集》p187
3.10《题集》p187-188
3.15
//双向栈顺序存储结构
#define STACKSIZE 100 //双向栈容量
typedef struct {
SElemType base [ STACKSIZE ]; //双向栈数组
SElemType * top0, *top1;
} DuStack;
if (! p) exit (OVERFLOW);
p->data=e;
p->next=rear->next;
rear->next=p;
rear=p;
return OK;
}
Status DeQueue (QueuePtr &rear, QElemType &e){
if ( rear->next= =rear) return ERROR; //空队列
return p;
}
typedef struct LNode{
ElemType data;
Struct LNode *next;
} *LinkList, *position;
说明：position定义见教材P87，也可以根据《题集》P16写成Linklist
2.14
int ListLength ( LinkList L) {
Status EnQueue ( SqQueue &Q, QElemType e)
{
if ( Q.length= =MAXSIZE) return ERROR; //队列满
Q.rear=(Q.rear+1) % MAXQSIZE;
Q.base[Q.rear] = e;
Q.length++;
return OK;
}
//a.length/2为顺序表前一半的元素个数，再减1为前一半的最后下标
2.31
void Deletepre ( LinkList s) {
po=s; p=s->next;
while ( p->next !=s)
{ po=p; p=p->next; }
po->next=s; free (p);
}
rear= (QueuePtr) malloc (sizeof (QNode));
if (! rear) exit (OVERFLOW);
rear->next=rear;
return OK;
}
Status EnQueue (QueuePtr &rear, QElemType e)
{
p=( QueuePtr) malloc (sizeof (QNode));
}
Status DeQueue ( SqQueue &Q, QElemType &e)
{
if (Q.length= =0) return ERROR; //队列空
e=Q.base[(MAXSIZE+Q.rear-Q.length+1)%MAXSIZE];
Q.length--;
return OK;
}
2.3需要经常根据位序对元素进行随机存取。
2.9
（1）若无头节点的单链表 中至少有两个节点，则将首节点删去并将其插入到表尾。（题集P182）
（2）已知 和 分别指向单循环链表中的两个节点，算法将其拆成分别包含 节点和 节点的两个单循环链表。
例如：
2.11
Status InsertOrderList (SqList &va, ElemType x){
if( va.length>=va.listsize) //空间已满，增加分配
{ newbase=(ElemType*) realloc ( va.elem,
(va.listsize+LISTINCREMENT)*sizeof(Elemtype));
if(!newbase) exit(OVERFLOW);
#define MAXQSIZWE 100 //最大队列长度
typeபைடு நூலகம்ef struct{
QElemType base[MAXSIZE]; //存放队列元素的数组
int rear; //队尾指针，若队列不空，指向当前队尾元素
int length; //队列长度
}
//该循环队列队满的条件为length= MAXQSIZE
if i = = 0
*tws.top0++=x;
else
*tws.top1--=x;
return OK;
}
Status pop (DuStack &tws, int i){
if (i= =0) {
if ( tws.top0= =tws.base) return ERROR;
tws.top0--;}
else{
第一章绪论
1.5
1.8(7) 或 或
(即 )时，做第1次
(即 )时，做第2次
…..…………
(即 )时，做最后一次
（8）1100
执行10次 后， 值为101，执行1次 ，故对于每一个 值 ， 语句执行11次。
1.9
设算法结束时 的值为 ，则循环体执行了 次，此时，
即：
，
算法的时间复杂度为O（ ）
第二章线性表
2.13
position LocatePos ( LinkList L, ElemType x){
//L为带头节点的单链表的头指针，本算法在表中查找第一个值
//和x相同的元素，若存在，则返回基地址，否则返回NULL
p=L->next;
while ( p && p->data!=x )
p=p->next;