实现循环单链表各种基本运算的算法

/**
*   实现循环单链表各种基本运算的算法
*
*/

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>

typedef int ElemType;
typedef struct LNode
{
    ElemType data;//数据域
    struct LNode *next;//指针域

}LinkNode;// 声明循环单链表结点类型

/*---------------------头插法建立循环单链表------------------------*/
static void create_list_front(LinkNode *&L, ElemType a[], int n)
{
    int i;
    LinkNode *s;

    // 创建头结点
    L = (LinkNode *)malloc(sizeof(LinkNode));
    L->next = NULL;
    for(i = 0; i < n; i++)
    {
        // 创建新结点
        s = (LinkNode *)malloc(sizeof(LinkNode)); // 分配内存
        s->data = a[i];
        // 将结点s插入到原开始结点之前,头结点之后
        s->next = L->next;
        L->next = s;
    }
    s = L->next;
    while(s->next != NULL)//查找尾结点,由s指向它
        s = s->next;
    //尾结点next域指向头结点
    s->next = L;
}

/*---------------------尾插法建立循环单链表------------------------*/
static void create_list_rear(LinkNode *&L, ElemType a[], int n)
{
    int i;
    LinkNode *s, *r;

    // 创建头结点
    L = (LinkNode *)malloc(sizeof(LinkNode));// 分配内存
    L->next = NULL;
    // r始终指向终端结点,开始时指向头结点
    r = L;
    for(i = 0; i < n; i++)
    {
        // 创建新结点
        s = (LinkNode *)malloc(sizeof(LinkNode));
        s->data = a[i];
        // 将结点s插入到结点r之后
        r->next = s;
        r = s;
    }
    // 尾结点next域指向头结点
    r->next = L;
}

/*---------------------初始化线性表------------------------*/
static void init_list(LinkNode *&L)//指针的引用
{
    L = (LinkNode *)malloc(sizeof(LinkNode));// 创建头结点
    L->next = L;
}

/*---------------------销毁线性表------------------------*/
static void destroy_list(LinkNode *&L)
{
    LinkNode *pre = L;
    LinkNode *p = pre->next;

    while(p != L)
    {
        free(pre);
        // pre,p同步后移一个结点
        pre = p;
        p = pre->next;
    }
    // 此时p = L,pre指向尾结点,释放它
    free(pre);
}

/*---------------------判断线性表是否为空表------------------------*/
static bool list_empty(LinkNode *L)
{
    return (L->next == L);
}

/*---------------------求线性表的长度------------------------*/
static int list_length(LinkNode *L)
{
    //p指向头结点,i置为0(头结点的序号为0)
    int i = 0;
    LinkNode *p = L;

    while(p->next != L)
    {
        i++;
        p = p->next;
    }

    return i;
}

/*---------------------输出线性表------------------------*/
static void display_list(LinkNode *L)
{
    LinkNode *p = L->next;

    // p不为L,输出p结点的data域
    while(p != L)
    {
        printf("%c ", p->data);
        p = p->next;
    }
    printf("\n");
}

/*---------------------求线性表中第i个元素值------------------------*/
static bool get_elem(LinkNode *L, int i, ElemType &e)
{
    int j = 1;
    LinkNode *p = L->next;

    // i错误或者空表返回假
    if(i <=0 || L->next == L)
        return false;
    // 求第1个结点值,作为特殊情况处理
    if(i == 1)
    {
        e = L->next->data;// 提取数据域
        return true;
    }
    else // i不为1时
    {
        // 找到第i个结点p
        while(j <= i - 1 && p != L)
        {
            j++;
            p = p->next;
        }
        // 没有找到返回假
        if(p == L)
        {
            return false;
        }
        else
        {
            //找到提取它的值并返回true
            e = p->data;
            return true;
        }
    }
}

/*---------------------查找第一个值域为e的元素序号------------------------*/
static int locate_elem(LinkNode *L, ElemType e)
{
    int i = 1;
    LinkNode *p = L->next;

    // 查找第1个值域为e的结点p
    while(p != L && p->data != e)
    {
        p = p->next;
        i++;
    }
    if(p == L)
        return 0; // 没有找到返回0
    else
        return i; // 找到返回其序号
}

/*---------------------插入第i个元素------------------------*/
static bool list_insert(LinkNode *&L, int i, ElemType e)
{
    int j = 1;
    LinkNode *p = L, *s;

    // i错误返回假
    if(i <= 0)
        return false;
    // 原单链表为空表或i = 1作为特殊情况处理
    if(p->next == L || i == 1)
    {
        // 创建新结点
        s = (LinkNode *)malloc(sizeof(LinkNode));
        s->data = e;
        // 将结点s插入到结点p之后
        s->next = p->next;
        p->next = s;
        return true;
    }
    else
    {
        p = L->next;
        // 找到第i - 1个结点p
        while(j <= i - 2 && p != L)
        {
            j++;
            p = p->next;
        }
        // 未找到第i - 1个结点
        if(p == L)
            return false;
        else // 找到第i - 1个结点p
        {
            // 创建新结点s
            s = (LinkNode *)malloc(sizeof(LinkNode));
            s->data = e;
            // 将结点s插入到结点p之后
            s->next = p->next;
            p->next = s;
            return true;
        }
    }
}

/*---------------------删除第i个元素------------------------*/
static bool list_delete(LinkNode *&L, int i, ElemType &e)
{
    int j = 1;
    LinkNode *p = L, *q;

    // i错误或者空表返回假
    if(i <= 0 || L->next == L)
        return false;
    // i = 1作为特殊情况处理
    if(i == 1)
    {
        // 删除第1个结点
        q = L->next;
        e = q->data;
        L->next = q->next;
        free(q);
        return true;
    }
    else
    {
        // i不为1时
        p = L->next;
        // 找到第i - 1个结点p
        while(j <= i - 2 && p != L)
        {
            j++;
            p = p->next;
        }
        // 未找到第i - 1个结点
        if(p == L)
            return false;
        // 找到第i - 1个结点p
        else
        {
            // q指向要删除的结点
            q = p->next;
            e = q->data;
            // 从单链表中删除q结点
            p->next = q->next;
            // 释放q结点
            free(q);
            return true;
        }
    }
}

int main(void)
{
    LinkNode *h;
    ElemType e;

    printf("循环单链表的基本运算如下:\n");
    printf("(1)初始化循环单链表h\n");
    init_list(h);
    printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
    list_insert(h, 1, 'a');
    list_insert(h, 2, 'b');
    list_insert(h, 3, 'c');
    list_insert(h, 4, 'd');
    list_insert(h, 5, 'e');
    printf("(3)输出循环单链表h:");
    display_list(h);
    printf("(4)循环单链表h长度:%d\n", list_length(h));
    printf("(5)循环单链表h为%s\n",(list_empty(h) ? "空" : "非空"));
    get_elem(h, 3, e);
    printf("(6)循环单链表h的第3个元素:%c\n", e);
    printf("(7)元素a的位置:%d\n", locate_elem(h, 'a'));
    printf("(8)在第4个元素位置上插入f元素\n");
    list_insert(h, 4, 'f');
    printf("(9)输出循环单链表h:");
    display_list(h);
    printf("(10)删除h的第3个元素\n");
    list_delete(h, 3, e);
    printf("(11)输出循环单链表h:");
    display_list(h);
    printf("(12)释放循环单链表\h");
    destroy_list(h);

    return 0;
}

测试结果:

循环单链表的基本运算如下:
(1)初始化循环单链表h
(2)依次采用尾插法插入a,b,c,d,e元素
(3)输出循环单链表h:a b c d e
(4)循环单链表h长度:5
(5)循环单链表h为非空
(6)循环单链表h的第3个元素:c
(7)元素a的位置:1
(8)在第4个元素位置上插入f元素
(9)输出循环单链表h:a b c f d e
(10)删除h的第3个元素
(11)输出循环单链表h:a b f d e
(12)释放循环单链表h