第五章链表结构算法设计技术

第五章链表结构算法设计技术

例5.1单链表的遍历

void print(node*L){
    node *p=L;
    while(p!=NULL){
        cout<<p->data;
        p=p->next;
    }
}

//拓展
//1.带头结点的
void print_with_head(node*L){
    node *p=L->next;
    while(p!=NULL){
        cout<<p->data;
        p=p->next;
    }
}
//2.求链表长度
int length(node *L){
    int n=0;
    node *p=L->next;
    while(p!=NULL){
        n++;
        p=p->next;
    }
    return n;
}
//3.带头结点的单循环链表
void print_2(node *L){
    node *p=L->next;
    while(P->next!=L){
        cout<<p->data;
        p=p->next;
    }
}

例5.2求单链表长度

int len(node *L){
    p=L->next;
    j=0;
    while(p!=NULL){
		j++;
        p=p->next;
    }
}

例5.3设计算法判断链表是否的递增的

bool adjust_increase(node *L){
    pre=L->next;
    if(pre!=NULL){
        while(pre->next!=NULL){
            if(pre->data<pre->next->data)
				return false;
            pre=pre->next;
        }
    }
    return true;
}

例5.4就地实现无头结点的单链表逆置

void reverse(list *L){
    p=L;
    oldpre=NULL;
    while(p!=NULL){
        oldnext=p->next;
        p->next=oldpre;
        oldpre=p;
        p=oldnext;
    }
    L=oldpre;
}

例5.5判断是否为子集

bool isSubset(list *L1,list *L2){
    p1=l1;
    while(p1!=NULL){
        p2=L2;
        while(p2!=NULL&&p2->data!=p1->data)
            p2=p2->next;
        if(p2==NULL)
            return false;
        p1=p1->next;
    }
    return true;
}

例5.6判断带头节点的双循环链表是否对称

bool symm(dunode *L){
    pre=L->next;
    rear=L->prior;
    while(pre->data==rear->data){
        if(pre==rear)
            return true;
        pre=pre->next;
        rear=rear->priod;
    }
    return false;
}

例5.7将带头结点的双循环链表逆置

void reverse(dulink *L){
    p=L;
    do{
        t=p->next;
        p->next=p->priod;
        p->pirod=t;
        p=t;
    }while p!=t;
}

5.4.1表尾插入法建表算法

void create_list_rear(node *L){
    node *u,*r;
    datatype x;
    r=L;
    cin>>x;
    while(x!=end_of_num){
        u=new node;
        u->data=x;
        r->next=u;
        r=u;
        cin>>x;
    }
    r->next=NULL;
}

例5.8设计算法将一个带头结点的单链表Ａ分解为两个链表A和B，使Ａ中含有表中奇数项的结点，Ｂ中含有表中偶数项的结点，且保持结点间原有的相对顺序

void disab(list *A,list *B){
    p=L->next;
    node rb;
    rb=B;
    while(p!=NULL&&p->next!=NULL){
        q=p->next;
        p->next=q->next;
        rb->next=q;
        rb=q;
        p=p->next;
    }
    rb->next=NULL;
}

例5.9设计算法将一个都是整数数据域的单链表Ａ分成一个只包含奇数的A和一个只是偶数的B

void disab_2(list *A,list *B){
    node *p=L->next,*pre=A;
    node *rb=B;
    while(P!=NULL){
        if(p->data%2==0){
            pre->next=p->next;
            rb->next=p;
            rb=p;
            p=pre->next;
        }
        else{
            pre=p;
            p=p->next;
        }
    }
    rb->next=NULL;
}

例5.10 A B是两个递增的单链表，设计算法利用原结点空间将其合并成一个递增有序链表C

void merge(list *A,list *B，list *C){
    pa=A;
    pb=B;
    pc=c;
    rc=c;
    while(pa->next!=NULL&&pb->next!=NULL){
        if(pa->data<pb->data){
            rc->next=pa;
            rc=pa;
            pa=pa->next;
        }
        else if(pa<data<pb->data){
            rc->next=pb;
            rc=pb;
            pb=pb->next;
        }
        else{
            rc->next=pa;
            rc=pa;
            pa=pa->next;
     		rc->next=pb;
            rc=pb;
            pb=pb->next;
        }
    }
    while(pa!=NULL){
        rc->next=pa;
        rc=pa;
        pa=pa->next;
    }
   	while(pb!=NULL){
        rc->next=pb;
        rc=pb;
        pb=pb->next;
    }
    rc->next=NULL;
}

表头插入建表法

void create_list_h(node *L){
    node *u;
    datatype x;
    L=new node;
    L->next=NULL;
    cin>>x;
    while(x!=end_of_num){
        u=new node;
        u->data=x;
        u->next=L->next;
        L=u;
        cin>>x;
    }
}

例5.11设计一个基于表头插入法建表法实现单链表逆置的算法

void reverse(link *L){
    link h,u;
    h=NULL;
    while(L->next!=NULL){
        u=L->next;
        L->next=u->next;
        u->next=h;
        h=u;
    }
    L->next=u;
}

例5.12将两个递增有序的单链表AＢ，设计算法利用原结点空间将其合并成一个递减有序链表

void merge(link *A,link *B,link *C){
    C=NULL;
    while(A!=NULL&&B!=NULL){
        if(A->data<B->data){
            u=A;
            A=u->next;
        }else{
            u=B;
            B=u->next;
        }
        u->next=C;
        C=u;
    }
    while(A!=NULL){
        u=A;
        A=u->next;
        u->next=C;
        C=u;
    }
    while(B!=NULL){
        u=B;
        B=u->next;
        u->next=C;
        C=u;
    }     
}