王道线性表
2.2.3顺序表
typedef struct LNode{
int data[100];
int length;
}LinkNode,*LinkList;
int deletemin(LinkList T,int min){
if(L.length==0){
printf("表空");
return;
}
int min=T[0];
int i=1;
int count=0;
while(i<L.length){
if(min>L.data[i])
{
count=i;
min=L.data[i++];
}
else
i++;
}
L.data[count]=L.data[--length];
return min;
}
void Reverse(LinkList L){
int temp,i=0;
for(i=0;i<L.length/2;i++){
temp=L.data[i];
L.data[i]=L.data[length-1-i];
L.data[length-1-i]=temp;
}
}
void DeleteAll(LinkList L,int x){
int k=0,c=0;
while(i<L.length){
if(L.data[i]==x)
{
c++;
i++;
}
else
L.data[i-c]=L.data[i++];
}
L.length-=c;
while(i<L.length){
if(L.data[i]!=x){
L.data[c]=L.data[i++];
c++;
}
}
L.length=c;
}
void deleteOrder(LinkList L,int s,int t){
if(s>t){
printf("s,t不合法");
return;
}
if(L.length==0){
printf("表空");
return;
}
int i=0,k=0;
while(i<L.length){
if(L.data[i]>s){
if(L.data[i]<t)
k++;
else
L.data[i-k]=L.data[i];
}
i++;
}
L.length-=k;
}
bool Delete_s_t(LinkList L,int s,int t){
int i,j;
for(i=0;i<L.length;i++)
if(L.data[i]>s)
break;
if(i>L.Length)
return false;
for(j=i;j<L.length&&L.data[j]<=t;j++);
for(;j<L.length;j++)
L.data[i++]=L.[j];
L.length=i;
return true;
}
void deleteinOrder(LinkList L,int s,int t){
if(s>t){
printf("s,t不合法");
return;
}
if(L.length==0){
printf("表空");
return;
}
int i=0,c=0;
while(i<L.length){
if(L.data[i]>s && L.data[i]<t){
c++;
}
else
L.data[i-c]=L.data[i];
i++;
}
L.length-=c;
}
bool deleteSame(LinkList L){
if(L.length==0)
return false;
LinkList P;
int i=0,j=0;
for(i=1;i<L.length;i++){
if(L.data[i]!=L.data[i-1]){
P.data[j++]=L.data[i-1];
}
}
for(int k=0;k<j;k++){
L.data[k]=P.data[k];
}
L.length=j;
return true;
for(i=0,j=1;j<L.length;j++){
if(L.data[i]!=L.data[j]){
L.data[++i]=L.data[j];
}
}
L.length=i+1;
return true;
}
LinkNode* Combine(LinkList LA,LinkList LB){
int i=0,j=0,temp;
LinkNode *Lc;
Lc.length=A+B;
int k=0;
if(LA.length==0 && LB.Length==0)
return NULL;
if(LA.length==0)
return LB;
if(LB.Length==0)
return LA;
while(i<LA.length && j<LB.length){
if(LA.data[i]>LB.data[j])
Lc.data[k++]=LB.data[j++];
else
Lc.data[k++]=LA.data[i++];
}
while(i<LA.length)
Lc.data[k++]=LA.data[i++];
while(j<LB.length)
Lc.data[k++]=LB.data[j++];
Lc.length=k;
return Lc;
}
bool Combine(LinkList LA,LinkList LB,LinkList &Lc){
if(LA.length+LB.Length>Lc.Maxsize)
return false;
int i=0,j=0,k=0;
while(i<LA.length && j<LB.length){
if(LA.data[i]>LB.data[j])
Lc.data[k++]=LB.data[j++];
else
Lc.data[k++]=LA.data[i++];
}
while(i<LA.length)
Lc.data[k++]=LA.data[i++];
while(j<LB.length)
Lc.data[k++]=LB.data[j++];
Lc.length=k;
return true;
}
void Reverse(LinkList A,int low,int high){
if(low>high)
return ;
int i,temp;
for(i=low;i<=low+high/2;i++){
temp=A.data[i];
A.data[i]=[high-i];
A.data[high-i]=temp;
}
}
Reverse(A,0,n-1);
Reverse(A,n,m+n-1);
Reverse(A,0,m+n-1);
void Reverse(LinkList A,int low,int high,int arraysize){
if(low>high || high>arraysize)
return ;
int i,mid=low+high/2;
for(i=0;i<=mid-low;i++){
temp=A.data[low+i];
A.data[low+i]=[high-i];
A.data[high-i]=temp;
}
}
Reverse(A,0,m+n-1,arraysize);
Reverse(A,0,n-1,arraysize);
Reverse(A,n,m+n-1,arraysize);
bool Findx(LinkList L,int x){
if(L.length==0)
return false;
int low=0,high=L.length-1;
int mid;
while(low<high){
mid=low+high/2;
if(x>L.data[mid])
low=mid;
else if(x<L.data[mid])
high=mid;
else{
if(mid!=L.length-1){
L.data[mid]=L.data[mid+1];
L.data[mid+1]=x;
return true;
}
}
}
}
if(low>high)
for(j=L.length-1;j>high;j--)
L.data[j]=L.data[j-1];
L.data[high]=x;
return true;
}
void search_x(int A[],int x){
int low=0,high=n-1,mid;
while(low<=high){
mid=low+high/2;
if(x==A[mid])
break;
else if(x<A[mid])
high=mid-1;
else
low=mid+1;
}
if(mid!=n-1&&x==A[mid]){
A[mid]=A[mid+1];
A[mid]=x;
}
if(low>high){
for(int j=n-1;j>high;j--)
A[j+1]=A[j];
A[j+1]=x;
}
for(int j=n-1;j>high;j--)
A[j+1]=A[j];
A[j+1]=x;
}
void LeftSWIFT(int R[],int p){
int A[p];
for(int i=0;i<p;i++){
A[i]=R[i];
}
for(int i=0;i<n-p;i++){
R[i]=R[p+i];
}
int j=0;
while(i<n)
R[i++]=A[j++]
}
void Reverse(int A[],int left,int right){
int mid=left+right/2;
for(int i=0;i<=mid-left;i++){
int temp=A[left+i];
A[left+i]=A[right-i];
A[right-i]=temp;
}
}
Reverse(A,0,p-1);
Reverse(A,p,n-1);
Reverse(A,0,n-1);
int midnumber(LinkList A,LinkList B){
if(A.length==0)
return;
if(A.data[length-1]>=B.data[0])
return B.data[length-1];
if(B.data[length-1]>=A.data[0])
return A.data[length-1];
int i=0,j=0,count=0;
while(count<=A.length){
if(A.data[i]>B.data[j])
j++;
else
i++;
count++;
}
if(A.data[i]<B.data[j])
return A.data[i];
else
return B.data[j];
}
int midNumber(LinkList A,LinkList B){
int s1=0,t1=n-1,s2=0,t2=n-1,m1,m2;
while(s1!=d1 || s2!=d2){
m1=s1+d1/2;
m2=s2+d2/2;
if(A[m1]==B[m2])
return A[m1];
else
if(A[m1]>b[m2]){
if((s2+d2)%2==0){
d1=m1;
s2=m2;
}
else{
d1=m1;
s2=m2+1;
}
}
else{
if((s1+d1)%2==0){
d2=m2;
s2=m1;
}
else{
d2=m2;
s1=m1+1;
}
}
}
return A[s1]<B[s2]?A[s1]:B[s2];
}
int FoundMain(int A[]){
int i=0;
int count[];
for(i=0;i<n;i++){
count[i]=0;
for(int j=1;j<n;j++){
if(A[i]==A[j])
count[i]++;
}
}
int flag=0;
while(i<n){
if(count[i]<n/2)
flag++;
else
return A[i];
}
if(flag==n)
return -1;
}
int Majority(int A[],int n){
int count=1,i=0,c;
c=A[0];
for(i=1;i<n;i++){
if(A[i]==c)
count++;
else{
if(count>0)
count--;
else{
c=A[i];
count=1;
}
}
}
if(count>0)
for(i=count=0;i<n;i++)
if(A[i]==c)
count++;
if(count>n/2)
return c;
return -1;
}
int FoundMin(int A[], int n) {
int num = 1;
int i = 0;
for (i = 0; i < n; i++) {
if (A[i] > 0) {
if (A[i] == num) {
num++;
}
}
}
return num;
}
int FoundMin(int A[], int n) {
int num = 1;
int i = 0;
for (i = 0; i < n; i++) {
if (A[i] > 0) {
if (A[i] == num) {
num++;
FoundMin(A, i);
}
}
}
if (num == A[0])
num++;
return num;
}
int FoundMin(int A[]){
int num=1,*B;
B=(int *)malloc(sizeof(int)*n);
int i=0,j=0;
memset(B,0,sizeof(int)*n);
for(i=0;i<n;i++){
if(A[i]>0&&A[i]<=n){
B[A[i]-1]=1;
}
}
for(j=0;j<n;j++){
if(B[j]!=1)
break;
}
return j+1;
}
思想描述,分别找三个数组的中位数,0,-10,17,-->0,10,9,-->9,10,9
int n1,n2,n3;
int mid[3];
void FindMinDistance(int S1[],int S2[],int S3[]){
mid[0]=FindMid(S1[],n1);
mid[1]=FindMid(S2[],n2);
mid[2]=FindMid(S3[],n3);
if(mid[0]>mid[1]&&mid[0]<mid[2]){
}
}
int FindMax_Min(int S[]){
if(S[0]>S[1]&&S[0]<S[2])
return
}
int FindMid(int Num[],int length){
int low=0,high=length-1,mid;
mid=low+high/2;
return Num[mid];
for(int i=low;i<=low+high/2;i++){
mid=low+high/2;
if()
}
}
#define INT_MAX 0x7fffffff
int abs_(int a){
if(a<0) return -a;
return a;
}
bool xIs_min(int a,int b,int c){
if(a<b&&a<c) return true;
return false;
}
int FindMinOfTrip(int A[],int n,int B[],int m,int C[],int p){
int i=0,j=0,k=0,D_min=INT_MAX;
while(i<n&&j<m&&k<p&&D_min>0){
D=abs_(A[i]-B[j])+abs_(B[j]-C[k])+abs_(C[k]-A[i]);
if(D<D_min) D_min=D;
if(xls_min(A[i],B[j],C[k])) i++;
else if(xls_min(B[j],A[i],C[k]))
j++;
else
k++;
}
return D_min;
}
2.3.7链表
typedef struct LinkNode{
int data;
struct LinkNode *next;
}LinkNode,*LinkList;
void Delete_x(LinkList &L,int x){
if(L==NULL)
return;
if(L->data==x){
LinkNode *s;
s=L;
L=s->next;
free(s);
}
else
Delete_x(L->next,x);
}
void Delete_x(LinkList &L,int x){
LinkNode *p;
p=L;
while(p->next!=NULL){
if(p->next->data==x){
LinkNode *q=p->next;
p->next=q->next;
free(q);
}
p=p->next;
}
}
void delete_x1(LinkList &L,int x){
LinkNode *p=L->next,*pre=L,*q;
while(p!=NULL){
if(p->data==x){
q=p;
p=p->next;
pre->next=p;
free(q);
}
else{
pre=p;
p=p->next;
}
}
}
void delete_x2(LinkList &L,int x){
LinkNode *p=L->next,*r=L,*q;
while(p!=NULL){
if(p->data!=x){
r->next=p;
r=p;
p=p->next;
}
else{
q=p;
p=p->next;
free(q);
}
}
r->next=NULL;
}
void OutPut(LinkList L){
LinkNode *p=L->next;
while(p!=NULL){
if(p->next==NULL)
printf("%d",p->data);
else
printf("%d->",p->data);
}
}
int GetLength(LinkList L){
int i=0;
while(L->next!=NULL){
i++;
L=L->next;
}
return i;
}
void ReverseOutput(LinkList L){
LinkNode *p,*N;
if(L==NULL)
return ;
p=L->next;
if(p->next==NULL){
printf("%d",p->data);
}
while(p!=NULL){
LinkNode *s=p;
s->next=N->next;
N->next=s;
p=p->next;
}
OutPut(N);
}
void ReverseOutput(LinkList L){
LinkNode *p;
p=L->next;
Length=GetLength(L);
if(Length==0)
return;
int *B,i=0;
B=(int *)malloc(sizeof(int)*Length);
while(p!=NULL){
B[length-i-1]=p->data;
p=p->next;
}
int j;
while(j<Length){
if(j+1==Length)
printf("%d",B[j]);
else
printf("%d->",B[j]);
}
}
void R_Print(LinkList L){
if(L->next!=NULL)
R_Print(L->next);
if(L!=NULL)
print(L->data);
}
void R_Ignore_head(LinkList L){
if(L->next!=NULL)
R_Print(L->next);
}
int Delete_Min(LinkList L){
int min;
LinkList *p;
p=L->next;
if(p==NULL)
return ;
min=p->data;
while(p->next!=NULL){
if(p->next->data<min)
min=p->next->data;
}
return min;
}
LinkList DeleteMIN(LinkList &L){
LinkNode *pre=L,*p=pre->next;
LinkNode *minp=p,*minpre=pre;
while(p!=NULL){
if(p->data<minp->data){
minp=p;
minpre=pre;
}
pre=p;
p=p->next;
}
minpre->next=minp->next;
free(minp);
return L;
}
void ReverseList(LinkList &L){
Length=GetLength(L);
LinkList *p=L->next;
if(p==NULL|| p->next==NULL)
return;
int i=0;
while(p!=NULL){
int temp=Getdata[length-1-i];
p->data
}
}
void ReverseList(LinkList &L){
LinkList *p=L->next;
if(p==NULL|| p->next==NULL)
return;
L->next=NULL;
while(p!=NULL){
LinkNode *s=p;
p=s->next;
s->next=L->next;
L->next=s;
}
}
void Reverse2(LinkList &L){
LinkNode *pre,*p=L->next;*r=p->next;
p->next=NULL;
while(r!=NULL){
pre=p;
p=r;
r=r->next;
p->next=pre;
}
L->next=p;
}
void AscendOrder(LinkList &L){
LinkNode *p;
p=L->next;
L->next=NULL;
Length=GetLength(L);
if(Length==0||Length==1)
return ;
int min[Length];
int i=0;
while(p!=NULL){
min[i++]=p->data;
p=p->next;
}
for(int j=0;j<Length;j++){
for(int k=1;k<Length;k++){
if(min[j]<min[k]){
int temp=min[j];
min[j]=min[k];
min[k]=min[j];
}
}
}
k=0;
while(k<Length){
LinkNode *q;
q->data=min[k++];
q->next=L->next;
L->next=q;
}
}
void Sort(LinkList &L){
LinkNode *p=L->next,*pre;
LinkNode *r=p->next;
p->next=NULL;
p=r;
while(p!=NULL){
r=p->next;
pre=L;
while(pre->next!=NULL&&pre->next->data<p->data)
pre=pre->next;
p->next=pre->next;
pre->next=p;
p=r;
}
}
void delete_s_t(LinkList &L,int s,int t){
if(s>t)
return;
LinkNode *p;
p=L;
if(p->next==NULL)
return;
while(p->next!=NULL){
if(p->next->data>s&&p->next->data<=t){
LinkNode *q=p->next;
p->next=q->next;
free(q);
}
p=p->next;
}
}
void FindSame(LinkList &La,LinkList Lb){
L1=GetLength(La);
L2=GetLength(Lb);
LinkNode *p1,*p2;
p1=La->next;
p2=Lb->next;
while(p1!=NULL){
int flag=0;
while(p2!=NULL){
if(p2->data==p1->data){
flag=1;
break;
}
else
p2=p2->next;
}
if(flag==1)
p1=p1->next;
else{
LinkNode *s=p1;
p1=p1->next;
free(s);
}
}
}
LNode* Public(LinkList L1, LinkList L2) {
int len1 = GetLength(L1);
int len2 = GetLength(L2);
if (len1 == 0 || len2 == 0)
return NULL;
if (len1 > len2) {
int i=0;
while (i < len1 - len2) {
L1 = L1->next;
i++;
}
}
else {
int i = 0;
while (i < len1 - len2) {
L2 = L2->next;
i++;
}
}
while (L1!=NULL) {
if(L1==L2)
return L1;
else {
L1 = L1->next;
L2 = L2->next;
}
}
return NULL;
}
void AscendOutput(LinkList &head) {
LNode* PA = head->next, * prea = head;
while (PA != NULL) {
LNode* p = PA, * pre = prea;
LNode* minp = PA, * minpre = prea;
while (p != NULL) {
if (minp->data > p->data) {
minp = p;
minpre = pre;
}
pre = p;
p = p->next;
}
print(minp->next);
LNode* s = minp;
minpre->next = s->next;
free(s);
}
free(head);
}
void Min_Delete(LinkList &head){
while(head->next!=NULL){
LinkNode *p=head->next,*pre=head;
while(p!=NULL){
if(p->next->data<pre->next->data)
pre=p;
p=p->next;
}
print(pre->next);
LinkNode *s=pre->next;
pre->next=s->next;
free(s);
}
free(head);
}
void DividedList(LinkList &A,LinkList &B){
LinkNode *p=A->next,*pre=A,*pb=B;
while(p!=NULL){
if(p->data%2==0){
pre->next=p->next;
p->next=pb->next;
pb->next=p;
p=pre->next;
pb=pb->next;
}
pre=p;
p=p->next;
}
}
void Divided_C(LinkList hc,LinkList &A,LinkList &B){
LinkNode *pc=hc->next,*pa=A,*pb=B;
int i=1;
while(pc!=NULL){
LinkNode *s=pc;
pc=pc->next;
if(i%2==1){
s->next=pa->next;
pa->next=s;
pa=s;
}
else{
s->next=pb->next;
pb->next=s;
pb=s;
}
i++;
}
}
void DeleteSame(LinkList L){
LinkNode* p=L->next,*pre=L;
while(p!=NULL&&p->next!=NULL){
if(p->data==p->next->data){
pre=p;
p=p->next->next;
}
else{
pre=p;
p=p->next;
}
}
}
void CombineDscend(LinkList &A,LinkList &B){
LinkNode *pa=A->next,*pb=B->next,*r;
A->next=NULL;
while(pa!=NULL&&pb!=NULL){
if(pa->data<pb->data){
r=pa->next;
pa->next=A->next;
A->next=pa;
pa=r;
}
else{
r=pb->next;
pb->next=A->next;
A->next=pb;
pb=r;
}
}
while(pa!=NULL){
r=pa->next;
pa->next=A->next;
A->next=pa;
pa=r;
}
while(pb!=NULL){
r=pb->next;
pb->next=A->next;
A->next=pb;
pb=r;
}
free(pb);
}
void FindSameToC(LinkList &lc,LinkList A,LinkList B){
LinkNode *pa=A->next,*pb=B->next,*pc=lc;
while(pa!=NULL&&pb!=NULL){
if(pa->data==pb->data){
LinkNode *s;
s->data=pa->data;
s->next=pc->next;
pc->next=s;
pb=pb->next;
}
else{
if(pa->data>pb->data)
pb=pb->next;
else
pa=pa->next;
}
}
}
void FindSame3(LinkList &A,LinkList B){
LinkNode *pa=A->next,*pb=B->next,*pc=lc,*p=A;
A->next=NULL;
while(pa!=NULL&&pb!=NULL){
if(pa->data==pb->data){
LinkNode *s=pa,*r=pa->next;
s->next=p->next;
p->next=s;
p=s;
pa=r;
pb=pb->next;
}
else{
if(pa->data>pb->data)
pb=pb->next;
else
pa=pa->next;
}
}
}
bool Is_child(LinkList A,LinkList B){
LinkNode *pa=A->next,*pb=B->next;
int flag=0;
while(pa && pb){
if(pa->data!=pb->data)
pa=pa->data;
else{
flag++;
pa=pa->next;
pb=pb->next;
}
}
int l=GetLength(B);
if(flag==l)
return true;
else
return false;
}
typedef struct DNode{
int data;
struct DNode* pre;
struct DNode* next;
}Dnode,*Dlink;
bool Is_Symtem(Dlink A){
DNode *p=A->next,*pre=A->pre;
int i=0;count=0;
if(p=pre)
return ;
while(p->next!=pre&& p!=pre){
if(p->data==pre->data){
p=p->next;
pre=pre->pre;
}
else
return false
}
return true;
}
int Is_SymDNode(DinkList L) {
DNode* pre=L->pre,*red=L->next;
if (L->next == L)
return;
while (pre!=L && red) {
if (pre->data == red->data) {
pre = pre->pre;
red = red->next;
}
else {
return -1;
}
}
return 1;
}
void Combine(LinkList &h1,LinkList h2){
LinkNode *p1=h1->next,*p2=h2->next;
while(p1!=h1)
p1=p1->next;
while(p2!=h2)
p2=p2->next;
p1->next=h2->next;
p2->next=h1;
free(h2);
}
void deleteMin(LinkList &L){
LinkList *p=L->next,*pre=L;
int min;
while(L->next!=L){
LinkList *p=L->next,*pre=L;
while(p->next!=L){
if(pre->next->data>p->next->data)
pre=p;
p=p->next;
}
print(pre->next->data);
LinkNode *u=pre->next;
pre->next=u->next;
free(u)
}
free(L);
}
LinkNode* Located(LinkList L,int x){
LinkList *p=L->next,*s;
while(p!=NULL){
if(p->data==x)
break;
}
if(p->data==x){
p->fred++;
*s=p;
p=p->pre;
while(p!=L){
if(p->fred>s->fred){
s->pre->next=s->next;
s->next->pre=s->pre;
p->next->pre=s;
s->next=p->next;
p->next=s;
s->pre=p;
}
else{
p=p->pre;
}
}
if(p==L){
s->pre->next=s->next;
s->next->pre=s->pre;
L->next->pre=s;
s->next=L->next;
L->next=s;
s->pre=L;
}
}
return s;
}
LinkList Is_Circuit(LinkList L){
LinkNode *SL=L,*FA=L->next->next;
while(FA&&FA->next){
if(SL->data==FA->data)
break;
else{
SL=SL->next;
FA=FA->next->next;
}
}
if(SL==NULL|| FA==NULL)
return NULL;
LinkNode *p=L,*p1=SL;
while(p!=p1){
p=p->next;
p1=p1->next;
}
return p;
}
int Find_repK(LinkList list, int x,int k) {
int length = GetLength(list);
int i = 0;
LNode* p = list->next;
if (k > length||k<1||length==0)
return 0;
while (i < length - k) {
p = p->next;
}
x = p->data;
return 1;
}
LNode* FindNode(LinkList A, LinkList B) {
LNode* pa = A->next, * pb = B->next;
int l1 = GetLength(A), l2 = GetLength(B);
int i = 0;
if (l1 == 0 || l2 == 0)
return NULL;
if (l1 > l2) {
while (i < l1 - l2)
pa = pa->next;
}
else
while (i < l2 - l1)
pb = pb->next;
while (pa != NULL) {
if (pa == pb)
break;
else {
pa = pa->next;
pb = pb->next;
}
}
if (pa)
return pa;
else
return NULL;
}
int fabs(int i) {
if (i < 0)
return -i;
return i;
}
#define N 0xffffff
void DeleteFabs(LinkList L,int n) {
int length = GetLength(L),i=0;
int* data;
data = (int*)malloc(sizeof(int) * (n + 1));
for (int i = 0; i < n + 1; i++) {
data[i] = 0;
}
LNode* p = L->next,*pre=p;
while (p != NULL) {
int temp = fabs(p->data);
if (data[temp] == 0){
data[temp] == 1;
pre = p;
p = p->next;
}
else {
LNode* s = p;
pre->next = s->next;
free(s);
p = pre->next;
}
}
free(data);
}
LNode* ReOrder(LinkList L) {
LNode* p = L->next, *pre,* r=p->next;
while (p != r&& p->next!=r) {
pre = p;
while (pre->next != r) {
pre = pre->next;
}
pre->next = r->next;
r->next = p->next;
p->next = r;
p = r->next;
r = pre;
}
return L;
}
LinkNode* fun(LinkList L)
{
LinkNode* j = L->next, * i = L->next, * r = L, * q = i->next;
if (!i)
return NULL;
while (j)
j = j->next;
if (!q)
return NULL;
while(i->next != j || i->next->next != j) {
while (r->next != j) r = r->next;
j->next = q;
i->next = j;
j = r;
r = L;
i = q;
q = q->next;
}
return L;
}
LNode* Change_list(LinkList L) {
LNode* p, * q, * r, * s;
p = q = L;
if (!q)
return NULL;
while (q->next != NULL) {
p = p->next;
q = q->next;
if (q->next != NULL) q = q->next;
}
q = p->next;
p->next = NULL;
while (q != NULL) {
r = q->next;
q->next = p->next;
p->next = q;
q = r;
}
s = L->next;
q = p->next;
p->next = NULL;
while (s != NULL) {
r = q->next;
q->next = s->next;
s->next = q;
s = q->next;
q = r;
}
return L;
}