数据结构3.17

最新推荐文章于 2024-06-26 23:14:31 发布
最新推荐文章于 2024-06-26 23:14:31 发布
阅读量55 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45585727/article/details/129628359
版权

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

yxgjbfddgijhhhj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
常见数据结构与算法整理总结 3.17
Amandaa_的博客
06-10 181
常见数据结构与算法整理总结 数据结构是以某种形式将数据组织在一起的集合，它不仅存储数据，还支持访问和处理数据的操作。算法是为求解一个问题需要遵循的、被清楚指定的简单指令的集合。下面是自己整理的常用数据结构与算法相关内容，如有错误，欢迎指出。 为了便于描述，文中涉及到的代码部分都是用Java语言编写的，其实Java本身对常见的几种数据结构，线性表、栈、队列等都提供了较好的实现，就是我们经常用到的Java集合框架，有需要的可以阅读这篇文章。Java - 集合框架完全解析 一、线性表 1.数组实现 2.链表 二
【数据结构】期中测试1
m0_72318954的博客
11-07 1030
期中测验1试题及解答
严蔚敏数据结构习题3.17
blanKey的博客
10-08 2067
3.17 试写一个算法，识别一次读入的一个以@为结束符的字符序列是否为形如‘序列1&序列2’模式的字符序列。其中序列1和序列2中都不含字符‘&’，且序列2是序列1的逆序列。例如，‘a+b&b+a’是属该模式的字符序列，而‘1+3&3-1’则不是。思路很简单，把&前面部分入栈，然后从&后面部分开始一个一个出栈比较，相同即可。 说个题外话，现在开始我会逐渐写些这个数据结构的习题完整的程序，主要发现网上
数据结构答案
热门推荐
@you的博客
12-22 1万+
百度云下载：https://pan.baidu.com/s/1mWuKxN45BuhgHlC8xBjQWw 第1章 绪论 一、基础知识题 1.1 简述下列概念 数据，数据元素，数据类型，数据结构，逻辑结构，存储结构，算法。 【解答】数据是信息的载体，是描述客观事物的数、字符，以及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。 数据元素是数据的基本单位。在不同...
（15）3.17
2302_81921490的博客
03-17 360
printf("二进制中1的个数 = %d的\n", count);printf("交换前a=%d,b=%d\n", a, b);printf("交换后=%d,b=%d\n", a, b);//////////////^的用法。
C语言数据结构
Joyer_cc 的博客
03-08 1581
目录 绪论 线性表 栈和队列 串、数组和广义表 树和二叉树 图 查找 排序 绪论 数值计算：数学模型->算法 数据结构： 逻辑结构：集合结构，线性结构，树结构，图结构或网结构 存储结构：顺序存储结构，链式存储结构 数据类型：基本数据类型，抽象数据类型 抽象数据类型： ADT 抽象数据类型名{ 数据对象: <数据对象的定义> 数据关系: <数据关系的定义> 基本操作: &...
python基础语法5-数据结构
a316495442的博客
11-10 100
今天主要说的是列表作为栈、队列、矩阵的使用，其他几种数据结构之前都有介绍到，朋友们可以翻看之前的文章。列表中的使用方法可以很方便的当做一个栈来使用，栈作为特定的数据结构，它遵循的是先进后出。列表的append()可以在栈顶添加一个元素，pop()方法可以将一个元素从栈顶释放。因为在列表的末尾添加和释放元素速度后很快，但是在列表的头部和中间插入弹出速度却不行，列表的具体方法在之前的文章中已经讲到过，在这里就不赘述了，需要的可以点链接进去查看。列表是可变的，即可对其中的元素进行修改、删除、增加。
队列（从数据结构的三要素出发）
Nie同学的博客
05-21 993
本文介绍了队列的定义、物理结构及其多种实现方式，包括顺序队列、循环队列、链式队列和双端队列，详细阐述了各类队列的基本操作和具体实现，并展示了队列在层次遍历和操作系统中的应用。通过图文并茂的讲解，深入解析了队列的逻辑结构和实际应用场景。
数据结构之查找
weixin_46516647的博客
09-10 1368
（掌握散列查找的特征和性能分析，散列表的构造和冲突处理方法，查找成功和查找失败的平均查长度；折半查找的过程，构造判定树，分析平均查找长度；掌握B树的插入删除和查找，B+树的概念性质）用于在静态的线性表（顺序表or链表）中进行查找：从线性表的某一端开始，将表中的元素与关键字逐个比较。对于顺序表，通过数组下标递增的顺序扫描每个元素；对于链表，可通过指针来一次扫描每个元素把待查关键字key存入表头(哨兵、监视哨)， 从而避免查找过程中每一次比较后都要判断查找位置是否越界，加快查找速度。
数据结构与算法分析--c语言描述(原书第二版)练习自答（第三章）(3.11~3.17)
fuluoyide312的博客
07-01 673
3.11 list.h #ifndef _List_H #define _List_H struct Node; typedef struct Node *PtrToNode; typedef PtrToNode List; typedef PtrToNode Position; typedef int ElementType; List MakeEmpty(List L); //List L is unused int IsEmpty(List L); int IsLast(Position P,L
数据结构勘误表202108111
08-03
这份勘误表主要针对《数据结构：抽象建模、实现与应用》这本书中的一些错误进行了修正，涵盖了线性表、栈、队列、树、二叉树和图等多个数据结构的相关算法和描述。以下是各章节具体修改内容的详细说明： **第二章 ...
数据结构实现（C++版）
11-28
1.基本数据结构 1.1.Array ........... 动态数组 1.2.LinkedList ... 链表 1.3.BST .............. 二分搜索树 1.4.MapBST ..... 二分搜索树（用于实现映射） 1.5.AVLTree ...... AVL树 2.接口 2.1.Queue .............
习题20183.31
08-08
《数据结构》是一门至关重要的计算机科学基础课程，它涵盖了数据的组织、存储和操作的各种方法。本课程的作业设计旨在帮助学生深入理解和掌握数据结构的基本概念、算法及其在实际问题中的应用。以下是对各章节重点...
python-data-structure-cn_python科学计算_python_数据结构_游戏_字典学习_
09-30
为什么要学习数据结构和抽象数据类型1.6.为什么要学习算法1.7.回顾Python基础2.算法分析2.1.目标2.2.什么是算法分析2.3.大O符号2.4.一个乱序字符串检查的例子2.5.Python数据结构的性能2.6.列表2.7.字典2.8.总结3....
数据结构——带头双向循环链表（c语言实现）
qq_58761784的博客
06-26 869
我们在前几期详细地讲解了不带头单向不循环链表（单链表），使用它的底层代码实现了一个简单的通讯录项目，也介绍了链表分为八种，但是其中最常用的只有两种：（1）不带头单向不循环链表，（2）带头双向循环链表，今天我们要讲解的就是第二种带头双向循环链表。
数据结构--栈（图文）
最新发布
SouTY_C的博客
06-26 436
栈是一种基本的抽象数据类型，具有后进先出的特点。在栈这种数据结构中，元素只能在一端进行插入和删除操作，这一端被称为栈顶（Top），而另一端则称为栈底（Bottom）。
数据结构--单链表（图文）
SouTY_C的博客
06-21 597
从前向后遍历整个链表，如果 plist->data == x，就说明找到了，返回 plist 此时的值，如果plist = NULL了，就说明这个链表中没有该数据，则返回空。在单链表中，每个元素（称为节点）包含两部分：一部分是存储数据的数据域，另一部分是存储下一个节点地址的指针域。先将指定位置的的下一个位置保存起来，让指定位置的next指针指向保存位置的下一个位置，然后释放掉保存的位置也就是指定位置之后的数据。：链表的最后一个节点，其指针域通常为空（NULL），表示链表的结束。在指定位置后直接插入即可。
【数据结构】栈
weixin_73483158的博客
06-20 367
【代码】【C语言数据结构】栈。
Python18 数据结构与数据类型转换
Argulo的博客
06-23 385
在Python中，数据结构是用来存储、组织和管理数据的方式，以便有效地执行各种数据操作。栈是一个后进先出（LIFO）的数据结构，只能在一端（通常是顶部）进行添加或移除元素。队列是一个先进先出（FIFO）的数据结构，元素从一端添加，从另一端移除。字典是无序的，但从Python 3.7开始，字典维护元素的插入顺序。Python中没有内置的栈数据结构，但可以使用列表来实现栈的功能。字典是基于键值对的数据结构，可以快速检索存储的数据。列表中的元素可以是不同类型的，可以包含重复值。列表不可以转换成字典。
cmake 3.17
10-15
CMake是一个跨平台的自动化构建系统，它可以用简单的语句来描述构建过程，而不需要编写平台特定的脚本。CMake 3.17是CMake的一个版本，它于2020年3月发布。 相关问题: 1. CMake有哪些常用的命令？ 2. CMake支持哪些编译器？ 3. CMake如何生成Visual Studio

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值