数据结构3.17

1.

main.c 

#include "head.h"
 
int main(int argc, const char *argv[])
{    
    //创建头结点
    DoubleLink L = Create_head();
    
    printf("请输入插入的元素个数：");
    int n;//输入的个数
    scanf("%d",&n);
    datatype e;//插入的值
    int pos;
    int flag;
/*
    //双向链表头插
    for(int i=0;i<n;i++)
    {
        printf("请输入插入的值：");
        scanf(" %c",&e);
        Insert_head(L,e);
    }
*/
    //双向链表尾插    
    for(int i=0;i<n;i++)
    {
        printf("请输入插入的值：");
        scanf(" %c",&e);
        Insert_rear(L,e);
    }
/*
    //双向链表遍历
    printf(" 正向输出0   反向输出1\n");
    int x;
    scanf("%d",&x);
*/
    Output(L,0);
/*
    //双向链表头删
    Delete_head(L);
    Delete_head(L);
    Delete_head(L);
    Output(L,0);
 
    //双向链表尾删
    Delete_rear(L);
    Delete_rear(L);
    Delete_rear(L);
    Output(L,0);
 
    //双向链表按位置插入
    printf("请输入插入的位置：");
    scanf("%d",&pos);
    printf("请输入插入的字符串：");
    scanf(" %c",&e);
    Insert_by_pos(L,pos,e);
    Output(L,0);
 
    //双向链表按位置删除
    printf("请输入删除的位置：");
    scanf("%d",&pos);
    Delete_by_pos(L,pos);
    Output(L,0);
 
    //双向链表按位置修改
    printf("请输入修改的位置：");
    scanf("%d",&pos);
    printf("请输入修改后的字符串：");
    scanf(" %c",&e);
    Update_by_pos(L,pos,e);
    Output(L,0);
 
    //双向链表按位置查找
    printf("请输入查找的位置：");
    scanf("%d",&pos);
    Search_by_pos(L,pos);
    Output(L,0);
*/
    //双向链表按元素查找
    printf("请输入查找的值：");
    scanf(" %c",&e);
    flag = Search_by_data(L,e);
    if(flag == -1)
        printf("查找的值不存在\n");
    else
        printf("在%d位置出现\n",flag);
 
    //双向链表按元素删除    
    printf("请输入删除的值：");
    scanf(" %c",&e);
    flag = Delete_by_data(L,e);
    if(flag == -1)
        printf("删除的值不存在\n");
    else
        printf("删除成功\n");
    Output(L,0);
 
    //双向链表按元素修改    
    printf("请输入修改的值：");
    scanf(" %c",&e);
    datatype key;
    printf("请输入修改后的值：");
    scanf(" %c",&key);
    flag = Update_by_data(L,e,key);
    if(flag == -1)
        printf("修改的值不存在\n");
    else
        printf("修改的成功\n");
    Output(L,0);
 
    //双向链表排序
    printf("排序\n");
    DoubleLink_sort(L);
    Output(L,0);
 
    //释放
    L = Free_space(L);
    printf("释放成功\n");
 
    return 0;
}

test.c

#include "head.h"
 
/*
 * function:    在堆区创建头结点
 * @param [ in] 无参数
 * @param [out] 
 * @return      成功返回头结点地址，失败返回NULL
 */
DoubleLink Create_head()
{
    DoubleLink L = (DoubleLink)malloc(sizeof(struct Node));
    if(L == NULL)
        return NULL;
    //L结点的数据域
    L->len = 0;
    //L的后继指针
    L->next = NULL;
    //L的前驱指针
    L->prev = NULL;
    return L;
}
 
/*
 * function:    在堆区创建结点
 * @param [ in] 无参数
 * @param [out] 
 * @return      成功返回结点地址，失败返回NULL
 */
DoubleLink Create_node()
{
    DoubleLink p = (DoubleLink)malloc(sizeof(struct Node));
    if(p == NULL)
        return NULL;
    //L结点的数据域
    p->len = 0;
    //L的后继指针
    p->next = NULL;
    //L的前驱指针
    p->prev = NULL;
    return p;
}
 
 
/*
 * function:    头插  永远在头结点后面
 * @param [ in] 头结点   插入的数据元素
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Insert_head(DoubleLink L,datatype e)
{
    //判断头结点是否存在
    if(L == NULL)
    {
        printf("头插入失败。\n");
        return -1;
    }
    //在堆区申请新结点
    DoubleLink p = Create_node();
    if(p == NULL)
        return -1;
    //p的数据赋值为e
    p->data = e;
    //p的指针域
    p->next = L->next;
    p->prev = L;
    if(L->next != NULL)
        L->next->prev = p;
    L->next = p;
    L->len++;
    return 0;
 
}
 
/*
 * function:    双向链表的遍历
 * @param [ in] 链表   正向输入0   反向输入1
 * @param [out] 
 * @return      无返回值函数
 */
void Output(DoubleLink L,int x)
{
    //1.判断头结点是否存在
    //2.判断链表是否为空
    if(L == NULL || L->len == 0)
        printf("输出失败！\n");
    DoubleLink p = L;
#if 1
    switch(x)
    {
        case 0:
            while(p->next)
            {
                p = p->next;
                printf("%c\t",p->data);
            }
            printf("\n");
            break;
        case 1:
            while(p->next != NULL)
                p = p->next;
            while(p->prev)
            {
                printf("%c\t",p->data);
                p = p->prev;
            }
            printf("\n");
            break;
    }
#endif
#if 0
    switch (x)
    {
        case 0:
            DoubleLink p = L;
            for(int i=0;i<L->len;i++)
            {
                p = p->next;
                printf("%c\t",p->data);
            }
            break;
        case 1:
            DoubleLink p = L;
            while(p->next)
                p = p->next;
            for(int i=0;i<L->len;i++)
            {
                printf("%c\t",p->data);
                p = p->prev;
            }
            break;
    }
    printf("\n");
#endif
}
 
/*
 * function:    尾插   永远在链表表尾部插入
 * @param [ in] 双向链表   插入的值
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Insert_rear(DoubleLink L,datatype e)
{
    //判断头结点是否存在
    if(L == NULL)
    {
        printf("尾插入失败。\n");
        return -1;
    }
    //循环到尾部结点
    DoubleLink p = L;
    while(p->next)
        p = p->next;
    //在堆区申请新结点空间
    DoubleLink s = Create_head();
    if(s == NULL)
        return -1;
    //s的数据赋值为e
    s->data = e;
    //s的指针域
    s->next = p->next;
    s->prev = p;
    p->next = s;
    L->len++;
    return 0;
 
}
 
/*
 * function:    双向链表头删
 * @param [ in] 双向链表
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Delete_head(DoubleLink L)
{
    //判断链表头结点是否存在
    //判断链表是否为空
    if(L == NULL || L->len == 0)
    {
        printf("失败\n");
        return -1;
    }
    //删除
    DoubleLink q = L->next;
    L->next = q->next;
    if(q->next != NULL)
        q->next->prev = L;
    free(q);
    q = NULL;
    L->len--;
    return 0;
}
 
/*
 * function:    尾删
 * @param [ in] 双向链表
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Delete_rear(DoubleLink L)
{
    //判断头结点是否存在
    //判断链表是否为空
    if(L == NULL || L->len == 0)
    {
        printf("失败。\n");
        return -1;
    }
    //循环到尾部结点
    DoubleLink p = L;
    while(p->next)
        p = p->next;
    //删除p结点
    p->prev->next = NULL;//防止p前驱指针的后继指针不为null
    free(p);
    p=NULL;
    L->len--;
 
}
 
/*
 * function:    按位置插入
 * @param [ in] 双向链表   插入的位置   插入的值
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Insert_by_pos(DoubleLink L,int pos,datatype e)
{
    //判断头结点是否存在
    //判断位置是否合法
    if(L == NULL || L->len == 0 || pos<1 || pos>L->len+1)
    {
        printf("失败。\n");
        return -1;
    }
    //找到pos-1的位置，起名字为p
    DoubleLink p = L;
    for(int i=0;i<pos-1;i++)
        p = p->next;
    //创建结点
    DoubleLink s = Create_node();
    if(s == NULL)
        return -1;
    //s的数据域
    s->data = e;
    //s的指针域
    s->next = p->next;
    s->prev = p;
    if(p->next != NULL)
        p->next->prev = s;
    p->next = s;
    L->len++;
 
    return 0;
}
 
/*
 * function:    按位置删除
 * @param [ in] 双向链表   删除的位置
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Delete_by_pos(DoubleLink L,int pos)
{
    //判断头结点是否存在
    //判断位置是否合法
    if(L == NULL || L->len == 0 || pos<1 || pos>L->len)
    {
        printf("失败。\n");
        return -1;
    }
    //找到pos-1的位置，起名字为p
    DoubleLink p = L;
    for(int i=0;i<pos-1;i++)
        p = p->next;
    DoubleLink s = p->next;
    p->next = s->next;
    free(s);
    s = NULL;
    L->len--;
 
    return 0;
 
}
 
/*
 * function:    按位置修改
 * @param [ in] 双向链表   修改的位置   修改后的值
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Update_by_pos(DoubleLink L,int pos,datatype e)
{
    //判断头结点是否存在
    //判断位置是否合法
    if(L == NULL || L->len == 0 || pos<1 || pos>L->len)
    {
        printf("失败。\n");
        return -1;
    }
    //找到pos的位置，起名字为p
    DoubleLink p = L;
    for(int i=0;i<pos;i++)
        p = p->next;
    p->data = e;
 
    return 0;
 
}
 
/*
 * function:    按位置查找
 * @param [ in] 双向链表   查找的位置
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Search_by_pos(DoubleLink L,int pos)
{
    //判断头结点是否存在
    //判断位置是否合法
    if(L == NULL || L->len == 0 || pos<1 || pos>L->len)
    {
        printf("失败。\n");
        return -1;
    }
    //找到pos的位置，起名字为p
    DoubleLink p = L;
    for(int i=0;i<pos;i++)
        p = p->next;
     printf("下标%d对应的值为：%c\n",pos,p->data);
    return 0;
 
}
 
/*
 * function:    按元素查找
 * @param [ in] 双向链表   元素
 * @param [out]
 * @return      成功返回位置，失败返回-1
 */
int Search_by_data(DoubleLink L,datatype e)
{
    //判断头结点是否存在
    //判断链表是否为空
    if(L == NULL || L->len == 0)
    {
        printf("失败。\n");
        return -1;
    }
    DoubleLink p = L;
    for(int i=0;i<L->len;i++)
    {
        p = p->next;
        if(p->data == e)
            return i+1;
    }
    return -1;
 
}
 
/*
 * function:    按元素删除
 * @param [ in] 双向链表   元素
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Delete_by_data(DoubleLink L,datatype e)
{
    //先找e位置
    int pos = Search_by_data(L,e);
    if(pos == -1)
        return -1;
    //再根据位置删除
    int flag = Delete_by_pos(L,pos);
    if(flag == -1)
        return -1;
    return 0;
 
}
 
/*
 * function:    按元素修改
 * @param [ in] 双向链表   要修改的元素  修改后的元素
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Update_by_data(DoubleLink L,datatype e,datatype key)
{
    //先找e位置
    int pos = Search_by_data(L,e);
    if(pos ==-1)
        return -1;
    //再根据位置删除
    int flag = Update_by_pos(L,pos,key);
    if(flag == -1)
        return -1;
    return 0;
 
}
 
/*
 * function:    链表排序
 * @param [ in] 双向链表
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int DoubleLink_sort(DoubleLink L)
{
    //判断头结点是否存在
    //判断链表是否为空
    if(L == NULL || L->len == 0)
    {
        printf("失败。\n");
        return -1;
    }
    //断开头结点
    DoubleLink p = L->next;
    L->next = NULL;
 
    while(p)//循环头结点L后面的所有结点
    {
        DoubleLink t = p;//方便吧p结点插入到L链表的后面
        p = p->next;//p指向下一个结点的地址
 
        DoubleLink q = L;//L不动   q后面没有结点
        //如果L后面存在多个结点，需要t->data实现比较
        while(q->next != NULL && q->next->data < t->data)
        {
            q = q->next;
        }
        //q后面没有结点
        t->next = q->next;
        t->prev = q;
        if(q->next != NULL)
            q->next->prev = t;
        q->next = t;
    }
 
    return 0;
 
}
 
/*
 * function:    链表释放
 * @param [ in] 链表
 * @param [out]
 * @return      成功返回NULL，失败返回-1
 */
DoubleLink Free_space(DoubleLink L)
{
    if(L == NULL)
        return NULL;
 
    for(int i=0;i<L->len;i++)
    {
        Delete_rear(L);
    }
    free(L);
    L = NULL;
 
    return L;
}

head.h

#ifndef __HEAD_H__
#define __HEAD_H__
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef char datatype;
typedef struct Node
{
    //数据域
    union{
        int len;//头结点数据域：链表长度
        datatype data;//其他结点数据域：数据元素
    };
    //指针域：下一个结点地址
    struct Node *next;
    //指针域：上一个结点地址
    struct Node *prev;
}*DoubleLink;
 
 
DoubleLink Create_head();
DoubleLink Create_node();
int Insert_head(DoubleLink L,datatype e);
int Insert_rear(DoubleLink L,datatype e);
void Output(DoubleLink L,int x);
int Delete_head(DoubleLink L);
int Delete_rear(DoubleLink L);
int Insert_by_pos(DoubleLink L,int pos,datatype e);
int Delete_by_pos(DoubleLink L,int pos);
int Update_by_pos(DoubleLink L,int pos,datatype e);
int Search_by_pos(DoubleLink L,int pos);
int Search_by_data(DoubleLink L,datatype e);
int Delete_by_data(DoubleLink L,datatype e);
int Update_by_data(DoubleLink L,datatype e,datatype key);
int DoubleLink_sort(DoubleLink L);
DoubleLink Free_space(DoubleLink L);
 
 
#endif

2.

main.c

#include "head.h"
 
int main(int argc, const char *argv[])
{    
    LoopLink L = Create_head();
    
    int n;
    int pos;
    int flag;
    printf("请输入输入的个数：\n");
    scanf("%d",&n);
    datatype e;
    datatype key;
/*
    //头插
    for(int i=0;i<n;i++)
    {
        printf("请输入插入的元素：");
        scanf("%f",&e);
        Insert_head(L,e);
    }
*/
    //尾插
    for(int i=0;i<n;i++)
    {
        printf("请输入插入的元素：");
        scanf("%f",&e);
        Insert_rear(L,e);
    }
 
    //单向循环链表遍历
    Output(L);
/*
    //单向循环链表头删
    Delete_head(L);
    Delete_head(L);
    Delete_head(L);
    Output(L);
 
    //单向循环链表尾删
    Delete_rear(L);
    Delete_rear(L);
    Delete_rear(L);
    Output(L);
*/
    //单向循环链表任意位置插入
    printf("请输入插入的位置：");
    scanf("%d",&pos);
    printf("请输入插入后的元素：");
    scanf("%f",&e);
    Insert_by_pos(L,pos,e);
    Output(L);
 
    //单向循环链表任意位置删除
    printf("请输入删除的位置：");
    scanf("%d",&pos);
    Delete_by_pos(L,pos);
    Output(L);
 
    //单向循环链表任意位置修改
    printf("请输入修改的位置：");
    scanf("%d",&pos);
    printf("请输入修改后的元素：");
    scanf("%f",&e);
    Update_by_pos(L,pos,e);
    Output(L);
 
    //单向循环链表任意位置查找
    printf("请输入查找的位置：");
    scanf("%d",&pos);
    Search_by_pos(L,pos);
 
    //单向循环链表按元素查找
    printf("请输入查找的元素：");
    scanf("%f",&e);
    flag = Search_by_data(L,e);
    if(flag == -1)
        printf("查找的元素不存在\n");
    else
        printf("在%d位置出现\n",flag);
 
    //单向循环链表按元素删除????????????
    printf("请输入删除的元素：");
    scanf("%f",&e);
    flag = Delete_by_data(L,e);
    if(flag == -1)
        printf("删除的元素不存在\n");
    else
        printf("删除成功\n");
    Output(L);
 
    //单向循环链表按元素修改
    printf("请输入要修改的元素：");
    scanf("%f",&e);
    printf("请输入修改后的元素：");
    scanf("%f",&key);
    flag = Update_by_data(L,e,key);
    if(flag == -1)
        printf("修改的元素不存在\n");
    else
        printf("修改成功\n");
    Output(L);
 
    //逆置
    printf("逆置\n");
    LoopLink_rev(L);
    Output(L);
 
    //排序
    printf("排序\n");
    LoopLink_sort(L);
    Output(L);
 
    //释放
    Free_space(L);
    printf("释放成功！\n");
 
    return 0;
}

test.c

#include "head.h"
 
/*
 * function:    创建头结点
 * @param [ in] 无参数
 * @param [out] 
 * @return      成功返回首地址   失败返回NULL
 */
LoopLink Create_head()
{
    LoopLink L = (LoopLink)malloc(sizeof(struct Node));
    if(L == NULL)
        return NULL;
    L->len = 0;
    L->next = L;
    return L;
}
 
/*
 * function:    创建其他结点
 * @param [ in] 无参数
 * @param [out]
 * @return      成功返回首地址，失败返回NULL
 */
LoopLink Create_node()
{
    LoopLink p = (LoopLink)malloc(sizeof(struct Node));
    if(p == NULL)
        return NULL;
    p->data = 0;
    p->next = p;
    return p;
}
 
/*
 * function:    头插  永远在头结点后面
 * @param [ in] 头结点   插入的数据元素
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Insert_head(LoopLink L,datatype e)
{
    //判断头结点是否存在
    if(L == NULL)
    {
        printf("头插入失败。\n");
        return -1;
    }
    //在堆区申请其他结点空间
    LoopLink p = Create_node();
    //p的数据赋值为e
    p->data = e;
    //p的指针域
    p->next = L->next;
    L->next = p;
    //链表长度自增
    L->len++;
    return 0;
}
 
/*
 * function:    尾插   永远在链表表尾部插入
 * @param [ in] 单向循环链表   插入的值
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Insert_rear(LoopLink L,datatype e)
{
    //判断头结点是否存在
    if(L == NULL)
    {
        printf("尾插入失败。\n");
        return -1;
    }
    //循环到尾部结点
    LoopLink p = L;
    while(p->next != L)
        p = p->next;
    //在堆区申请新结点空间
    LoopLink s = Create_node();
    if(s == NULL)
        return -1;
    //s的数据赋值为e
    s->data = e;
    //s的指针域
    p->next = s;
    s->next = L;
    //链表长度自增
    L->len++;
 
    return 0;
 
}
 
/*
 * function:    单向循环链表的遍历
 * @param [ in] 单向循环链表
 * @param [out]
 * @return      无返回值函数
 */
void Output(LoopLink L)
{
    //1.判断头结点是否存在
    //2.判断链表是否为空
    if(L == NULL || L->len == 0)
        printf("输出失败！\n");
    LoopLink p = L;
#if 0
    while(p->next != L)
    {
        p = p->next;
        printf("%.2f\t",p->data);
    }
    printf("\n");
 
#endif
#if 1
     for(int i=0;i<L->len;i++)
    {
        p = p->next;
        printf("%.2f\t",p->data);
    }
    printf("\n");
#endif
}
 
 
/*
 * function:    头删   删除头结点后面的结点
 * @param [ in] 单向循环链表
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Delete_head(LoopLink L)
{
    //判断链表头结点是否存在
    //判断链表是否为空
    if(L == NULL || L->len == 0)
    {
        printf("失败\n");
        return -1;
    }
    //删除
    LoopLink q = L->next;
    L->next = q->next;
    free(q);
    q = NULL;//防止野指针
    L->len--;
    return 0;
}
 
/*
 * function:    尾删   删除链表尾部结点
 * @param [ in] 单向循环链表
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Delete_rear(LoopLink L)
{
    //判断头结点是否存在
    //判断链表是否为空
    if(L == NULL || L->len == 0)
    {
        printf("失败。\n");
        return -1;
    }
    //循环到尾部结点前一个
    LoopLink p = L;
    for(int i=0;i<L->len-1;i++)
    {
        p = p->next;
    }
    //删除p结点后面的结点
    free(p->next);
    p->next = NULL;//防止野指针
    L->len--;
    return 0;
}
 
/*
 * function:    按位置插入
 * @param [ in] 单向循环链表   插入的位置   插入的值
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Insert_by_pos(LoopLink L,int pos,datatype e)
{
    //判断头结点是否存在
    //判断位置是否合法
    if(L == NULL || L->len == 0 || pos<1 || pos>L->len+1)
    {
        printf("失败。\n");
        return -1;
    }
    //找到pos-1的位置，起名字为p
    LoopLink p = L;
    for(int i=0;i<pos-1;i++)
        p = p->next;
    //创建结点
    LoopLink s = Create_node();
    if(s == NULL)
        return -1;
    //s的数据域
    s->data = e;
    //s的指针域
    s->next = p->next;
    p->next = s;
    L->len++;
    return 0;
 
}
 
/*
 * function:    按位置删除
 * @param [ in] 单向循环链表   删除的位置
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Delete_by_pos(LoopLink L,int pos)
{
    //判断头结点是否存在
    //判断位置是否合法
    if(L == NULL || L->len == 0 || pos<1 || pos>L->len)
    {
        printf("失败。\n");
        return -1;
    }
    //找到pos-1的位置
    LoopLink p = L;
    for(int i=0;i<pos-1;i++)
        p = p->next;
    LoopLink s = p->next;
    p->next = s->next;
    free(s);
    s = NULL;
    L->len--;
    return 0;
 
}
 
/*
 * function:    按位置修改
 * @param [ in] 单向循环链表   修改的位置   修改后的值
 * @param [out] 
 * @return      成功返回0，失败返回-1
 */
int Update_by_pos(LoopLink L,int pos,datatype e)
{
    //判断头结点是否存在
    //判断位置是否合法
    if(L == NULL || L->len == 0 || pos<1 || pos>L->len)
    {
        printf("失败。\n");
        return -1;
    }
    //找到pos的位置，起名为p
    LoopLink p = L;
    for(int i=0;i<pos;i++)
        p = p->next;
    p->data = e;
    return 0;
}
 
/*
 * function:    按位置查找
 * @param [ in] 单项循环链表   查找的位置
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Search_by_pos(LoopLink L,int pos)
{
    //判断头结点是否存在
    //判断位置是否合法
    if(L == NULL || L->len == 0 || pos<1 || pos>L->len)
    {
        printf("失败。\n");
        return -1;
    }    
    //找到pos的位置，起名为p
    LoopLink p = L;
    for(int i=0;i<pos;i++)
        p = p->next;
    printf("下标%d对应的元素为：%f\n",pos,p->data);
    return 0;
}
 
/*
 * function:    按元素查找
 * @param [ in] 单向循环链表   元素
 * @param [out]
 * @return      成功返回位置，失败返回-1
 */
int Search_by_data(LoopLink L,datatype e)
{
    //判断头结点是否存在
    //判断链表是否为空
    if(L == NULL || L->len == 0)
    {
        printf("失败。\n");
        return -1;
    }
    LoopLink p = L;
    for(int i=0;i<L->len;i++)
    {
        p = p->next;
        if(e == p->data)
            return i+1;
    }
    return -1;
 
}
 
/*
 * function:    按元素删除
 * @param [ in] 单向循环链表   元素
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Delete_by_data(LoopLink L,datatype e)
{
    //先找e的位置
    int pos = Search_by_data(L,e);
    if(pos == -1)
        return -1;
    //再根据位置删除
    int flag = Delete_by_pos(L,pos);
    if(flag == -1)
        return -1;
    return 0;
 
}
 
/*
 * function:    按元素修改
 * @param [ in] 单向循环链表   要修改的元素  修改后的元素
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int Update_by_data(LoopLink L,datatype e,datatype key)
{
    int pos = Search_by_data(L,e);
    if(pos == -1)
        return -1;
    int flag = Update_by_pos(L,pos,key);
    if(flag == -1)
        return -1;
    return 0;
}
 
/*
 * function:    链表逆置
 * @param [ in] 单向循环链表
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int LoopLink_rev(LoopLink L)
{
    if(L == NULL || L->len == 0)
    {
        printf("失败。\n");
        return -1;
    }
    //断开头结点
    LoopLink p = L->next;
    L->next = NULL;
    while(p != L)
    {
        LoopLink t = p;
        p = p->next;
        //t头插在L
        t->next = L->next;
        L->next = t;
    }
    return 0;
}
 
/*
 * function:    链表排序
 * @param [ in] 单向链表链表
 * @param [out]
 * @return      成功返回0，失败返回-1
 */
int LoopLink_sort(LoopLink L)
{
    if(L == NULL || L->len == 0)
    {
        printf("失败。\n");
        return -1;
    }
    //断开头结点
    LoopLink p = L->next;
    L->next = L;
    while(p != L)
    {
        LoopLink t = p;
        p = p->next;
 
        LoopLink q = L;
        while(q->next != L && q->next->data < t->data)
            q = q->next;
        t->next = q->next;
        q->next = t;
    }
    return 0;
}
 
/*
 * function:    链表释放
 * @param [ in] 单项循环链表
 * @param [out]
 * @return      成功返回NULL，失败返回-1
 */
LoopLink Free_space(LoopLink L)
{
    if(L == NULL)
        return NULL;
 
    for(int i=0;i<L->len;i++)
    {
        Delete_rear(L);
    }
    free(L);
    L = NULL;
 
    return L;
}

head.h

#ifndef __HEAD_H__
#define __HEAD_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef float datatype;
 
typedef struct Node
{
    //数据域
    union{
        int len;//头结点的数据域
        datatype data;//其他结点的数据域
    };
    //指针域：下一个结点的地址
    struct Node *next;
}*LoopLink;
 
LoopLink Create_head();
LoopLink Create_node();
int Insert_head(LoopLink L,datatype e);
int Insert_rear(LoopLink L,datatype e);
void Output(LoopLink L);
int Delete_head(LoopLink L);
int Delete_rear(LoopLink L);
int Insert_by_pos(LoopLink L,int pos,datatype e);
int Delete_by_pos(LoopLink L,int pos);
int Update_by_pos(LoopLink L,int pos,datatype e);
int Search_by_pos(LoopLink L,int pos);
int Search_by_data(LoopLink L,datatype e);
int Delete_by_data(LoopLink L,datatype e);
int Update_by_data(LoopLink L,datatype e,datatype key);
int LoopLink_rev(LoopLink L);
int LoopLink_sort(LoopLink L);
LoopLink Free_space(LoopLink L);
 
#endif