链表代码刷题（第三天）

1.设带头结点的单链表中每个结点的数据域只存放一个字母。请设计算法在所有值为’e’的结点前插入一个值为’W’的结点。

void insert_X(Linklist &L,char ‘e’)
{
Lnode *p=L->next;
Lnode *prep=L
while(p!=NULL)
{
if(p->data==‘e’)
{
Lnode *q=(Linklist)malloc(sizeof(Lnode));
q->next=prep->next;
prep->next=q;
}
else{
prep=p;
p=p->next;}
}

2.设计算法，在带头结点的单链表head上实现直接插入排序。

void Insertsort(LinkList &L)
{
LNode *p=L->next,*q;
LNode *r=p->next;
p->next=NULL;
p=r;
while(p!=NULL)
{
r=p->next;
q=L;
while(q->next!=NULL&&q->next->datadata)
q=q->next;//这里的直接插入排序是从第一个元素开始找有序表的插入位置
p->next=q->next;
q->next=p;
p=r;
}
}

3有一个顺序表L。编写一个时间复杂度为0(n)，空间复杂度为0(1)的函数。删除L中值在[x，y]间的所有数据元素。顺序表L的类型为:
#define maxsize 1024
typedef int datatype; /数据元素的类型/
typedef struct
{datatype data[maxsize]; /从0位置开始存放/
int last; /指示终端结点的位置/
} seqlist; /顺序表的类型/

void Delet_X(Seqlist &L)
{
int i;
for(i=0;i<L.length;i++)
{
if((L.data[i]>=x)&&(L.data[i]<=y))
{
for(j=i+1;j<L.length;j++)
L.data[j-1]=L.data[j]
L.length–;
}
}
}

4.设有两个单链表La，Lb，其中元素递增有序，编写算法将La，Lb归
并成一个按元素值递减有序的链Lc，要求用La，Lb中的原结点形成，不能重新申请结点。

void merge(LinkList &L1,LinkList &L2)
{
LNode *P=L1->next;
LNode *prep=L1;
LNode *q=L2->next;
LNode *preq=L2;
LNode *r;
prep->next=NULL;
while(p&&q)
{
if((p->data)<=(q->data))
{
r=p;
p=p->next;
prep->next=r->next;
prep->next=r;
}

       else{
       	r=q;
       	q=q->next;
       	preq->next=r->next;
       	preq->next=r;
	   }
}
	while(p)
{
	 	r=p;
       	p=p->next;
       	prep->next=r->next;
       	prep->next=r;
}
while(q)
{	r=q;
       	q=q->next;
       	preq->next=r->next;
       	preq->next=r;
}

}
}

5在一个递增有序的线性表中，有数值相同的元素存在。若存储方式为单链表，设计算法去掉数值相同的元素，使表中不再有重复的元素。例如(7，10，10，21，30，42，42，42，51，70)将变作(7，10，21，30，42，51，70)。
void Del_same(LinkList &L)
{
LNode *p=L->next->next;
LNode *prep=L->next;
LNode *r;
while§
{
if(p->data==prep->data)
{
r=p;
p=p->next;
prep->next=p;
free®;
}
else
{
p=p->next;
prep=prep->next;
}
}
}

6.有一个顺序表L，其中有多个值为x的数据元素。设计一个在时间和空间两个方面都尽可能高的算法，删除L中所有值为x的数据元素。顺序表L的类型为:
void Del_x(SeqList &L,int x)
{
int i=0;
int j=0;
for(i=0;i<L.length;i++)
{
if(L.data[i]!=x)
L.data[j++]=L.data[i]
}
L.length=j;
}

7.设计算法，在带头结点的单链表中删除所有值为偶数的结点。链表中结点的类型定义如下:

void DeL_x(Linklist &L)
{
LNode *p=L->next;
LNode *pre=L;
LNode *r;
while§
{
if((p->data)%2==0)
{
r=p;
pre->next=p->next;
p=p->next;
free®;
}
else{
pre=p;
p=p->next;
}
}
}

8对于顺序表R[n+1]，试设计一个算法重排记录，将所有关键字(整数)为负数的记录放在非负数的记录之前。要求算法的时间复杂度为T(n)=O(n)，空间复杂度为S(n)=O(1)。
void Reverse(SqList &L)
{
int i=0,j=L.length-1;
int temp;
while(i<j)
{
while(i<j&&L.data[i]<0)
i++;
while(i<j&&L.data[j]>0)
j–;

	    temp=L.data[i];
	        L.data[i]=L.data[j];
	           L.data[j]=temp;
	
}

}

9.已知一个非空单链表L，设计一个算法删除该链表中一个最小值的结点(假设最小值只有一个)。其结点结构如下，结点的类型名为LNode，结点指针类型名为LinkList。
void Delete_x(Linlist &L)
{
LNode *p=L->next;
LNode *prep=L;
LNode *minp=L->nextl
LNode *minprep=L;
LNode *r;
while§
{
if(p->datadata)
{
minp=p;
minprep=prep;
}
else{
minp=p;
p=p->next;

	   }
	   }
 	r=minp;
 	minp->next=minp->next;
 	minp=minp->next;
 	free(r);

}

10已知长度为n的线性表A采用顺序存储结构，请写一时间复杂度为0(n)， 空间复杂度为0(1)的算法，该算法删除线性表中值大于mink且小于maxk的所有数据元素 ( mink和maxk 是给定的两个参数，其值可以和表中的元素相同，也可以不同)。
void Del_x(SeqList &L,int x)
{
int i=0;
int j=0;
for(i=0;i<L.length;i++)
{
if(L.data[i]<=mink||L.data[i]>=maxk)
L.data[j++]=L.data[i]
}
L.length=j;
}

11.已知长度为 n 的线性表 A 采用顺序存储结构，设计算法，删除线性表中所有值相同的多余元素，使所有元素值均不相同。例如，对线性表（2,8,9,5,5,6,8,7,2） 执行此算法后变为（2,8,9,5,6,7)
void Del_x(Seqlist &L)
{
int i,j;
for(i=0;i<L.length-1;i++)
{
for(j=i+1;j<L.length;j++)
{
if(L.data[j]==L.data[i])
{
for(j=i+1;j<L.length;j++)
L.data[j]=L.data[j+1];
L.length–;
}
}
}
}

12 假设该链表只给出了头指针，在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点

int Serach_X(Linklist &L,int k)
{
Lnode *p=L->next;
Lnode *q=L->next;
while(k!=0)
{
p=p->next;
}
while§
{
p=p->next;
q=q->next;
}
return q->data ;
}