循环单链表

循环单链表的结点类型

typedef struct LNode
{
    ElemType   data;       //数据域
    struct LNode  *next;   //指针域
} LNode,*LinkList;

初始化循环单链表

Status InitList_L(LinkList &L) 
{
    L=(LinkList)malloc(sizeof(LNode));
    if(!L)
    {
        exit(OVERFLOW);
    }
    else
        L->next = L;
    return OK;
}

头插法建立单链表

Status List_HeadInsert(LinkList &L,int n)
{
    LinkList s;
    int x;
//    L = (LinkList)malloc(sizeof(LNode));//创建头结点
//    L->next = NULL;
    for(int i = 0; i < n; i++)
    {
        s = (LinkList)malloc(sizeof(LNode));
        cin >> x;
        s->data = x;
        s->next = L->next;
        L->next = s;
    }
    return OK;
}

尾插法建立单链表

LinkList List_TailInsert(LinkList &L, int n)    
{
    LinkList s;
    LinkList r = L;       //r为表尾指针
    int x;

    for(int i = 0; i < n; i++)
    {
        cin >> x;
        s = (LinkList)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
    }
    r->next = L;
    return L;
}

销毁线性表

Status DestroyList_L(LinkList &L)
{
    LinkList p;
    while(L)
    {
        p=L;
        L=L->next;
        free(p);
    }
    return OK;
}

求线性表的长度

int  ListLength_L(LinkList L) 
{
    //返回L中数据元素个数
    LinkList p;
    p=L->next; //p指向第一个结点
    int i=0;
    while(p != L) //遍历单链表,统计结点数
    {
        i++;
        p=p->next;
    }
    return i;
}

判断线性表是否为空

int IsEmpty(LinkList L)  
{
    //若L为空表，则返回1，否则返回0
    if(L->next == L) //空
        return TRUE;
    else
        return FALSE;
}

有两个循环单链表，链表头指针分别为h1和h2，编写一个函数将链表h2链接到链表h1之后，要求链接后的链表仍保持循环链表形式。

先找到两个链表的尾指针，将一个链表的尾指针与第二个链表的头结点链接起来

LinkList MergeList(LinkList &h1, LinkList &h2)
{
    LinkList r1 = h1->next;
    LinkList r2 = h2->next;
    while(r1->next!=h1)
    {
        r1 = r1->next;
    }
    while(r2->next!=h2)
    {
        r2 = r2->next;
    }
    r2->next = h1;
    r1->next = h2->next;
    free(h2);
}

设计一个带头结点的循环单链表，其结点值均为正整数，设计一个算法，反复找出单链表中结点值最小的结点从中删除，直到单链表空为止，再删除表头结点

void Delete_Min(LinkList &L)
{
    int mindata = L->next->data;
    LinkList p = L->next;
    LinkList pre = L;
    LinkList t = p;

    while(L->next != L)
    {
        p = L->next;
        pre = L;
        minpre = pre;
        minp = L->next;
        while(p!=L)
        {
            if(p->datadata)
            {
                minp = p;
                minpre = pre;
            }
            pre = p;
            p = p->next;
        }
        cout << minp->data;
        minpre->next = minp->next;
        free(minp);
    }
    
    free(L);
}