顺序表链表的各种操作

每日N题
typedef struct{//顺序表的结构体
  int length;
  int *data;
}Sqlist;


typedef struct node{//节点的结构体
  int data;
  LNode*next,*prior;
}LNode,*Lisklist;


   



1、在带头节点的单链表L中，删除所有值为x的节点，并释放空间，假设值为x的结点不唯一，编写算法实现操作
void deletelist(Linklist &L, Elemtype  x)
{	
LNode * per=L,*p=L->next,*q;//per是p的前驱，p用来遍历链表，q用来删除节点
    while(p!=NULL){
         if(p->data==x){
                q=p;
                p=p>next;
                per->next=p;
                free(q);
            }
        else{
            per=p;
            p=p>next;
     }

    }
}


2、将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表

bool guibing(Sqlist L1,Sqlist L2, Sqlist &L3)
{
	if(L1.length+L2.length>L3.length)return false;
	else{
		int i=0,j=0,k=0;
		while(i<L1.length1&&j<L2.length2){
			if(L1.data[i]<L2.data[j])L3.data[k++]=L1.data[i++];
			else L3.data[k++]=L2.data[j++];
		}
		while(i<length1)L3.data[k++]=L.data[i++];
		while(j<length2)L3.data[k++]=L.data[j++];
		L3.length=k;	
	}
	return  true;
	
	
	 } 


3、使用头插法建立一个单链表
Lisklist createlist(Lisklist &L)//头插法创建链表 
{
	Lisklist p;
	L=(Lisklist)malloc(sizeof(LNode));//创建头节点
	L->next=NULL;
	scanf("%d",&data);
	while(data!=-1){
		p=(Lisklist)malloc(sizeof(LNode));//创建有效节点
		p->data=data;
		p->next=NULL;
		p->next=L->next;//节点连接起来
		L->next=p;
		scanf("%d",&data);	
	} 
	return L;
}


4、设计算法逆置顺序表中的所有元素
void reverse(Sqlist &L)//法一
{
    for(int i=0;i<L.length/2;i++){
        int temp=L.data[i];
        L.data[i]=L.data[length-i-1];
        L.data[length-i-1]=L.data[i];
    }
}


void reverse(Sqlist &L,int low,int high)//法二
{
     if(low<high)swap(L.data[low],L.data[high]);
     reverse(L,low+1,high-1])；
}


void reverse(int q[],int low,int high)//法三
{
    while(low<high){
        swap(q[low],q[high]);
        low++,high--;
    }
}


5、设计算法删除链表中的最小元素
Lisklist Delete_min(Lisklist &L)
    {
        LNode*ple=L,*p=L->next;//p指针用来遍历链表，ple是p的前驱
        LNode*minple=ple,*minp=p;//
        while(p!=NULL){
            if(p->data<minp->data){
                minp=p;
                minple=ple;//找最小元素
            }
            ple=p;
            p=p->next;
        }    
        minple->next=minp->next;//删
        free(minp);
        return L;
    }


6、删除顺序表中的所有值为x的元素
void Delete(Sqlist &L,int x)//法一
{
    while{
        int k=0,i=0;
        if(L.data[i]==x)k++;
        else L.data[i-k]=L.data[i];//基本思想，前面有几个x就向前移动几位
    }
        L.length=L.length-k;
}


void Delete(Sqlist &L,int x)//法二
{
    int k=0;
    for(int i=0;i<length;i++)
        if(L.data[i]!=x)
        L.data[k++]=L.data[i];
    L.length=k;
}


7、删除顺序表中从值为s到t(s<t)之间的元素，如果s或t的值不合理则返回错误信息
bool Delete(Sqlist &L,int s,int t)
{
    int k=0;
    if(s>=t||L.length==0)return false;
    else{
        for(int i=0;i<L.length;i++){
            if(L.data[i]>s&&L.data[i]<t)k++;
            else L.data[i-k]=data[i];//基本思想
        }
        L.length=L.length-k;
        
    }
    return true;
}


8、删除有序的顺序表中的重复元素 ，使表中元素不重复
void Delete(Sqlist &L)
{
    if(L.length==0) return ;
    for(i=0,j=1;j<length;j++){
        if(L.data[i]==L.data[j])
        L.data[++i]=L.data[j];
    }
    L.length=i+1;
}


9、假设有两个按元素值递增次序排列的线性表，均以单链表的形式存储，编写算法将两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原本两个单链表的节点存放在归并后的单链表
void  mergelist(Lisklist &A,Lisklsit &B)
{
    LNOde *p=A->next;
    LNode *q=B->next;//一直头插法
    A->next=NULL;
while(p&&q){
	if(p->data<q->data){
		r=p->next;
		p->next=A->next;
		A->next=p;
		p=r;
	}
	else{
		r=q->next;
		q->next=A->next;
		A->next=q;
		q=r;
	}
}
while(p){
	r=p->next;
	p->next=A->next;
	A->next=p;
	p=r;
	
}
while(q){
	r=q->next;
	q->next=A->next;
	A->next=q;
	q=r;					
}
}


10、将一个带头结点的单链表A分解为两个带头结点的单链表A和B，使得A表中含有原表中序号为奇数的元素，而B表中含有原表中序号为偶数的元素，且保持其相对顺序不变 
Lisklist resolve(Lisklist &A)//一直尾插法
{
    LNode *ra=A;
    LNode *B=(LNode*)malloc(sizeof(LNode));
    rb=B,LNode *q=NULL,B->next=NULL;
    while(p){
        if(p->data%2==0){
            q=p;
            p=p->next;
            rb->next=q;//
            rb=q;
        }
        else{
            q=p;
            p=p->next;
            ra->next=q;
            ra=q;
        }
        ra->next=NULL;
        rb->next=NULL;
        return B;
    }
}


11、已知在一维数组A[m+n]中依次存放两个线性表{a1,a2,am}和{b1,b2,bm}试编写一个函数，将数组中两个顺序表的位置互换，即变成{b1,b2,bn,a1,a2,am}
void reverse(int q[],int m,int n)//法一
{
    int length=m-n+1;
    for(int i=0;i<length/2;i++){
        int temp=q[i];
        q[i]=q[length-i-1];
        q[length-i-1]=q[i];
    }
}

void exchange(int q[],int m,int n)
{
    reverse(A,0,m-1);
    reverse(A,m,m+n-1);
    reverse(A,0,m+n-1);
}


void reverse(int q[],int m,int n)//法二
{
    while(m<n){
    if(m<n)swap(q[m],q[n]);
    m++,n--;
    }
}

void exchange(int q[],int m,int n)
{   reverse(A,0,m-1);
    reverse(A,m,m+n-1);
    reverse(A,0,m+n-1);
}


void reverse(int q[],int m,int n)
{
    if(m<n)swap(q[m],q[n]);
    reverse(q[m+1],q[n-1]);
}

void exchange(int q[],int  m,int n)
{
     reverse(A,0,m-1);
    reverse(A,m,m+n-1);
    reverse(A,0,m+n-1);
}


12、

void reverse(int q[],int m,int n)
{
    int length=n-m+1>>1;
    for(int i=m;i<length;i++){
        int temp=q[i];//会简单的逆置算法
        q[i]=q[length-i-1];
        q[length-i-1]=q[i];
    }
}

void exchange(int q[],int n,int p)
{
    reverse(R,0,p-1);
    reverse(R,p-1,n-1);
    reverse(R,0,n-1);
}


13、编写算法逆置带有头节点的单链表并保证辅助空间的复杂度为O（1）
Lisklist reverse(Lisklist &L)
{
    LNode *p=L->next,*q=NULL;
    while(p){
        q=p->next;
        q=p;
        L->next=q;
        p=q;
    }
    return L;
}


14、


Lisklist Deletelist(Lisklist &L,int m,int n)
{
    LNode*per=L,*p=L->next;
    LNode *q=NULL;
    while(p){
        if(p->data>m&&p->data<n){
            q=p;
            p=p->next;
            per->next=p;
            free(q);
        }
        else{
            per=p;
            p=p->next;
        }
    }
}

15、

Lisklist findlist(Lisklist &A,Lisklist &B)
{
    if(A.length>B.length){
        int k=A.length-B.length;
        p=A->next;
        q=B->next;
    }
    else{
        int k=B.length-A.length;
        p=B->next;
        q=A->next;
    }
    while(k--)p=p->next;
    while(p){
        if(p==q)return p
        else{
            p=p->next;
            q=q->next;
        }
    }
}

16、


Lisklist creatnewlist(Lisklist &A,Lisklist &B)
{
    LNode *p=A->next,*q=B->next;
    Lisklist C=Lisklistmalloc(sizeof(LNode));
    Lisklist r=c;
    while(p&&q){
        if(p->data<q->data)p=p->next;
        else if(q->data<p->data)q=q->next;
        else{
            Lisklist s=(Lisklist)malloc(sizeof(LNode));
            s->next=NULL;
            s->data=p->data;
            r->next=s;
            r=s;
            p=p->next;
            q=q->next;
            
        }
        r->next=NULL;
        return C;
    }
}

17、


Lisklist Samedata(Lisklist &A,lisklist &B)
{
    LNode *p=A->next,*q=B->next,*ra=A,*rb=B,*s;
    while(p&&q){
        if(p->data<q->data){
            s=p;
            p=p->next;//p小就释放p
            free(s);
        }
        else if(q->data<p->data){
            s=q;
            q=q->next;//q小就释放q 
            free(s);
        }
        else{//p和q相等，保留p释放q
            ra->next=p ;
            ra=p;
            p=p->next;
            s=q;
            q=q->next;
            free(s);
        }
    }
    while(p){
        s=p;
        p=p->next;
        free(s);
    }
    while(q){
        s=q;
        q=q->next;
        free(s);
    }
    ra->next=NULL;
    free(B);
    return A;
}

18、


bool Lisklist(Lisklist A,lisklist B)
{
    LNode*p=A->next,*q=B->next;
    while(q&&p){
        if(p->data!=q->data){
            q=B->next;
            p=p->next;
        }
        else{
            p=p->next;
            q=q->next;
        }
    }
    if(q==NULL)return true;
    else return false;
}

19、


bool duichen(Lisklist &L)
{
    LNode *p=L->piror,*q=L->next;
    while(p!=q){
        if(q->data==p->data){
            p=p->next;
            q=q->piror;
        }
        else return false;
    }
    return 1;
}

20、


Lisklist  lisk(Lisklist &L1,Lisklist &L2)
{
    LNode*p=L1,q=L2;
    while(p->next!=L1){
        p=p->next;
    }
    while(q->next!=L2)q=q->next;
    p->next=L2;
    q->next=L1;
    return L1;
}