循环单链表

21.头插法、尾插法

//头插法建立循环单链表
void createLinkList(LinkList &L,int arr[],int n){
    L=(LinkNode *)malloc(sizeof(LinkNode));
    L->next=L;
    int i=0;
    while(i<n){
        LinkNode *pNode=(LinkNode *)malloc(sizeof(LinkNode));
        pNode->data=arr[i];
        pNode->next=L->next;
        L->next=pNode;
        i++;
    }
}

//尾插法建立单链表
void createLinkList(LinkList &L,int arr[],int n){
    L=(LinkNode *)malloc(sizeof(LinkNode));
    L->next=L;

    LinkNode *pTail=L;
    int j=0;
    while(j<n){
        LinkNode *pNode=(LinkNode *)malloc(sizeof(LinkNode));
        pNode->data=arr[j];
        pNode->next=pTail->next;
        pTail->next=pNode;
        pTail=pNode;
        j++;
    }
}

22.

//逆置循环单链表
void reverse(LinkList L){
    LinkNode *p=L->next;
    L->next=L;
    while(p!=L){
        LinkNode *temp=p;
        p=p->next;
        temp->next=L->next;
        L->next=temp;
    }
}

23.

//将循环单链表左移k个结点
/*
算法思想：只需将头指针指向第k+1个元素即可
*/
void move(LinkList &L,int k){
    int j=1;
    while(j<k+1){
        L=L->next;
        j++;
    }
}

24.

//设计算法将循环单链表中结点p的直接前驱删掉
LinkNode *getNode(LinkList L,int k){//得到链表L的第k个结点
    int j=0;
    LinkNode *p=L;

    while(j<k){
        p=p->next;
        j++;
    }
    return p;
}
void deletePre(LinkNode *node){//删除node结点的直接前驱
    LinkNode *pre=node;
    LinkNode *p=node->next;

    while(p->next!=node){
        pre=p;
        p=p->next;
    }
    pre->next=p->next;
    free(p);
}

25.

26.

//已知L为一个单链表的头结点，设计算法将表中从i号结点到m号结点构成一个逆置的循环链表
/*
算法思想：先找到链表L的第i个结点，然后从第i个结点开始，依次头插，直到第m个结点插入到新的
链表为止
*/
LinkNode *reverse(LinkList L,int i,int m){
    LinkNode *newList=(LinkNode *)malloc(sizeof(LinkNode));
    newList->next=newList;

    int j=0;
    LinkNode *p=L;
    while(p!=NULL && j<i){//找到第i个结点
        p=p->next;
        j++;
    }

    while(p!=NULL && j<m+1){//从第i个结点开始，依次插入
        LinkNode *temp=p;
        p=p->next;
        j++;

        temp->next=newList->next;
        newList->next=temp;
    }
    return newList;
}

 27.

//已知La和Lb分别为两个循环单链表的头结点指针，m和n分别为La和Lb中数据结点的个数
//设计时间复杂度最低的算法，将两个链表合并成一个带头的循环单链表
/*
算法思想：先挑选出较短的链表，然后将该链表从头到尾，依次头插进较长的链表即可
*/
LinkNode *merge(LinkList La,LinkList Lb,int m,int n){
    LinkNode *pShort;
    LinkNode *pLong;
    if(m<n){
        pShort=La;
        pLong=Lb;
    }
    else{
        pShort=Lb;
        pLong=La;
    }

    LinkNode *p=pShort->next;
    while(p!=pShort){
        LinkNode *temp=p;
        p=p->next;

        temp->next=pLong->next;
        pLong->next=temp;
    }
    free(pShort);
    return pLong;
}

28.

//创建尾指针指向的循环单链表
#include<stdio.h>
#include<malloc.h>
typedef struct LinkNode{
    int data;
    struct LinkNode *next;
}LinkNode,*LinkList;

void createLinkList(LinkList &L,int arr[],int n){
    L=(LinkNode *)malloc(sizeof(LinkNode));
    L->next=L;

    int i=0;
    while(i<n){
        LinkNode *pNode=(LinkNode *)malloc(sizeof(LinkNode));
        pNode->data=arr[i];

        pNode->next=L->next;
        L->next=pNode;
        L=pNode;
        i++;
    }
}

void printLinkList(LinkList L){
    LinkNode *pHead=L->next;
    LinkNode *p=pHead->next;
    while(p!=pHead){
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
int main(){
    LinkList L;
    int arr[5]={1,2,3,4,5};
    createLinkList(L,arr,5);
    printLinkList(L);

    return 0;
}

29.

//设计一种数据结构来存储带头结点的循环单链表La和Lb，使得两表合并时效率尽可能高
/*
算法思想：采用带尾结点指针的循环链表。
将La的尾结点指向Lb的第一个数据结点。Lb的尾结点指向La的头结点
*/
void merge(LinkList &La,LinkList Lb){
    LinkNode *LaHead=La->next;
    LinkNode *LbHead=Lb->next;

    La->next=LbHead->next;
    Lb->next=LaHead;
    free(LbHead);
    La=Lb;
}