线性表试题中的操作代码

参考资料：《算法与数据结构考研试题精析》《2018数据结构考研复习指导》，如果有误还请提出来~~~>W<

在指针p所指结点之前插入s所指结点：

两个结点交换

s->next=p->next
p->next=s
p->data<--->s->data

Q=P
while(p->next!=Q){
    P=P->next;
}
S->next=P->next;
P->next=S

带头结点的双向循环链表L为空表的条件是 

L->prior=L->next=L

删除p所指结点的后继结点

q=p->next
p->next=q->next
free(q)

带头结点的单循环链表L仅有一个头结点的条件是 

L->next->next=L&&L->next!=L

带头结点的双向循环链表L仅有一个头结点的条件是 

L->next->next=L&&L->next!=L&&L->prior->prior=L

双向循环链表中，p所指的结点之后插入指针f所指的结点

f->next=p->next
f->prior=p
p->next->prior=f
p->next=f

链表合并，Lisa放入Listb尾部

typedef struct node{
    dataType data;
    struct node *link;
}*Linklist
void Solve(Linklist lista,Linklist listb){
    Linklist p;
    for(p=lista;p->link;p=p->link);
    p->link=listb
}

无头指针单链表，结点有数据域data，指针域next，表头指针h，使得链接方向逆转，h指向原来链表的最后一个节点

Inverse(&h){
    if(!h) return;
    p=h->next;
    pr=NULL;
    while(p){
        h->next=pr;pr=h;h=p;p=p->next;
    }
    h->next=pr;
}

带头结点的单链表数据结点的逆序连接

void reverse(pointer h){
    pointer p,q;
    p=h->next;
    h->next=null;
    while(p!=null){
        q=p;p=p->next;q->next=h->next;h->next=q;
    }
}

单链表中元素按插入排序，L为头结点指针

typedef struct node{
    dataType data;
    struct node *next;
}*link,linknode
void Solve(link L){
    link p,q,r,u;
    p=L->next;L->next=NULL;
    while(p!=NULL){
        r=L;q=L->next;
        while(p!=q&&q->data<=p-data){
            r=q;q=>next;
        }
        u=p->next;p->next=r->next;r->next=p;p=u;
    }
}

双向循环链表结点，在指针p所指的结点之前插入s结点

s->pre=p->pre;s->next=p;
p->pre->next=s;p->pre=s;

无表头结点单链表逆置

(Londe *L){
    p=L;
    q=NULL;
    while(p!=NULL){
        r=p->next;
        p->next=q;
        q=p;p=r;
    }
    L=q;
}

带有表头结点的单链表，只给出了list，查找链表中倒数第k位置的结点

while(p&&i<k){
    i++;p=p->link;
}
if(p==null){printf("")}
while(p){q=q->link;p=p->link;}
return 1;

两个增序的单链表，归为一个递减的单链表，并只能用原来的两个链表

p=la->next;q=lb->next;
la->next=null;
while(p&&q){
    if(p->data<=q->data){
        r=p->next;
        p->next=la->next;
        p=r;
    }
}else{//*q链入结果表中}
    if(p) q=p;
    while(q!=null){
        r=q->next;q->next=la->next;la->next=q;q=r;
    }

两个整数序列A=a1,a2,a3...,am 和B=b1,b2,b3,...bn已经存在单链表中，判断B是否是A的子序列

while(p&&q){
    if(p->data==q->data) {p=p->next;q=q->next}
    else{pre=pre->next;p=pre;q=B}
}
if(q==null) return 1;
else return 0;

带头结点的单链表逆置

while(p!=null){
    r=p->next;
    p->next=head->next;
    head->next=p;
    p=r;
}

循环链表逆置

while(p!=la){
    r=p->next;p->next=la->next;
    la->next=p;p=r;
}

删除重复结点，单链表有data和next两个域

while(pre!=null){
  m=pre->data;q=pre;p=pre->next;
  while(p!=null){
    if(p->data==m){u=p;p=p->next;free(u)}
    else {q->next=p;q=p;p=p->next}
  }
  q->next=p;
  pre=pre->next;
}

指针P所指结点与其后继结点，HEAD是该链表头指针，P指向该链表的某一结点

pre=HEAD;q=HEAD->next;
while(q!=null&&q!=P){
    pre=q;q=q->next;
}
if(P->next==null){P无后继结点}
else{
    q=P->next;
    pre->next=q;
    P->next=q->next;
    q->next=P;
}

ha为单向链表，hb为单向循环链表，合并成一个，且算法复杂度与链表长度无关

q=hb->next;
hb->next=ha->next;
ha->next=q->next;
free(q);

线性表顺序LA，LB元素按非递减有序，将LB合并到LA中，LA保持非递减有序，最大限度的避免移动元素

k=m+n-1;i=m-1;j=n-1;
while(i>=0&&j>=0){
    if(LA[i]>=LB[j]) LA[k--]=LA[i--];else LA[k--]=LB[j--];
}
while(j>=0) LA[k--]=LB[j--];

线性表n顺序存储，时间复杂度O(n)，空间复杂度O(1),删除元素值是item的元素

while(i<j){
    while(i<j&&A[i]!=item) i++;
    while(i<j&&A[j]==item) j--;
    if(i<j) A[i++]=A[j--];
}
要求相对顺序不变
i=-1;i=0;
while(i<n){
    if(A[i]==item) i++;else A[++j]=A[i++];
}

将链表数据最小的结点移到链表最前面，不得申请新结点

p=list->list;pre=list;
q=p;
while(p->link){
    if(p->link->data<q->data){pre=p;q=p->link}
    p=p->link;
}
if(q!=list->link){
    pre->link=q->link;q->link=list->link;
    list->link=q;
}

带头表结点的双向循环链表是否对称相等

struct Node{
    elem data;
    Node *Link,*Rlink;
}
while(p!=q&&p->Rlink!=q){
    if(p->data==q->data){p=p->Rlink;q=q->Llink}
    else{cout<<""}
}
if(p==q){cout<<""}
else if(p->data==q->data){cout<<""}