第4周 项目3-单链表：逆置、连接与递增判断

最新推荐文章于 2023-03-19 16:17:15 发布
最新推荐文章于 2023-03-19 16:17:15 发布
阅读量429 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ap_ple6223/article/details/48914981
本文详细介绍了单链表的基本操作，包括逆置、连接及递增判断等算法，并提供了具体的C语言实现代码。通过实例演示了如何使用这些算法来解决实际问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

/* 
*文件名称：1.pp 
*作者：崔从敏 
*完成日期：2015年10月5日 
*问题描述：单链表：逆置、连接与递增判断 
*/  

（1）逆置
#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode        //定义单链表结点类型
{
    ElemType data;
    struct LNode *next;     //指向后继结点
}LinkList;
void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表
void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表
void InitList(LinkList *&L);  //初始化线性表
void DestroyList(LinkList *&L);  //销毁线性表
bool ListEmpty(LinkList *L);  //判断线性表是否为空
int ListLength(LinkList *L);  //求线性表长度
void DispList(LinkList *L);  //输出线性表
bool GetElem(LinkList *L,int i,ElemType &e);  //求线性表某个数据元素值
int LocateElem(LinkList *L,ElemType e);  //按元素值查找
bool ListInsert(LinkList *&L,int i,ElemType e);  //插入数据元素
bool ListDelete(LinkList *&L,int i,ElemType &e);  //删除数据元素
void CreateListF(LinkList *&L,ElemType a[],int n)//头插法建立单链表
{
    LinkList *s;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
    for (i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
        s->data=a[i];
        s->next=L->next;            //将*s插在原开始结点之前,头结点之后
        L->next=s;
    }
}

void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法建立单链表
{
    LinkList *s,*r;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
    r=L;                    //r始终指向终端结点,开始时指向头结点
    for (i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
        s->data=a[i];
        r->next=s;          //将*s插入*r之后
        r=s;
    }
    r->next=NULL;           //终端结点next域置为NULL
}

void InitList(LinkList *&L)
{
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
}
void DestroyList(LinkList *&L)
{
    LinkList *p=L,*q=p->next;
    while (q!=NULL)
    {
        free(p);
        p=q;
        q=p->next;
    }
    free(p);    //此时q为NULL,p指向尾结点,释放它
}
bool ListEmpty(LinkList *L)
{
    return(L->next==NULL);
}
int ListLength(LinkList *L)
{
    LinkList *p=L;
    int i=0;
    while (p->next!=NULL)
    {
        i++;
        p=p->next;
    }
    return(i);
}
void DispList(LinkList *L)
{
    LinkList *p=L->next;
    while (p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
bool GetElem(LinkList *L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L;
    while (j<i && p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)            //不存在第i个数据结点
        return false;
    else                    //存在第i个数据结点
    {
        e=p->data;
        return true;
    }
}
int LocateElem(LinkList *L,ElemType e)
{
    LinkList *p=L->next;
    int n=1;
    while (p!=NULL && p->data!=e)
    {
        p=p->next;
        n++;
    }
    if (p==NULL)
        return(0);
    else
        return(n);
}
bool ListInsert(LinkList *&L,int i,ElemType e)
{
    int j=0;
    LinkList *p=L,*s;
    while (j<i-1 && p!=NULL) //查找第i-1个结点
    {
        j++;
        p=p->next;
    }
    if (p==NULL)    //未找到位序为i-1的结点
        return false;
    else            //找到位序为i-1的结点*p
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
        s->data=e;
        s->next=p->next;                        //将*s插入到*p之后
        p->next=s;
        return true;
    }
}
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L,*q;
    while (j<i-1 && p!=NULL)    //查找第i-1个结点
    {
        j++;
        p=p->next;
    }
    if (p==NULL)                //未找到位序为i-1的结点
        return false;
    else                        //找到位序为i-1的结点*p
    {
        q=p->next;              //q指向要删除的结点
        if (q==NULL)
            return false;           //若不存在第i个结点,返回false
        e=q->data;
        p->next=q->next;        //从单链表中删除*q结点
        free(q);                //释放*q结点
        return true;
    }
}
void Reverse(LinkList *&L)
{
    LinkList *p=L->next,*q;
    L->next=NULL;
    while (p!=NULL)     //扫描所有的结点
    {
        q=p->next;      //让q指向*p结点的下一个结点
        p->next=L->next;    //总是将*p结点作为第一个数据结点
        L->next=p;
        p=q;            //让p指向下一个结点
    }
}

int main()
{
    LinkList *L;
    ElemType a[]= {1,3,5,7, 2,4,8,10};
    CreateListR(L,a,8);
    printf("L:");
    DispList(L);
    Reverse(L);
    printf("逆置后L： ");
    DispList(L);
    DestroyList(L);
    return 0;
}

运行结果：

（2）连接

#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode        //定义单链表结点类型
{
    ElemType data;
    struct LNode *next;     //指向后继结点
}LinkList;
void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表
void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表
void InitList(LinkList *&L);  //初始化线性表
void DestroyList(LinkList *&L);  //销毁线性表
bool ListEmpty(LinkList *L);  //判断线性表是否为空
int ListLength(LinkList *L);  //求线性表长度
void DispList(LinkList *L);  //输出线性表
bool GetElem(LinkList *L,int i,ElemType &e);  //求线性表某个数据元素值
int LocateElem(LinkList *L,ElemType e);  //按元素值查找
bool ListInsert(LinkList *&L,int i,ElemType e);  //插入数据元素
bool ListDelete(LinkList *&L,int i,ElemType &e);  //删除数据元素
void CreateListF(LinkList *&L,ElemType a[],int n)//头插法建立单链表
{
    LinkList *s;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
    for (i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
        s->data=a[i];
        s->next=L->next;            //将*s插在原开始结点之前,头结点之后
        L->next=s;
    }
}

void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法建立单链表
{
    LinkList *s,*r;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
    r=L;                    //r始终指向终端结点,开始时指向头结点
    for (i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
        s->data=a[i];
        r->next=s;          //将*s插入*r之后
        r=s;
    }
    r->next=NULL;           //终端结点next域置为NULL
}

void InitList(LinkList *&L)
{
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
}
void DestroyList(LinkList *&L)
{
    LinkList *p=L,*q=p->next;
    while (q!=NULL)
    {
        free(p);
        p=q;
        q=p->next;
    }
    free(p);    //此时q为NULL,p指向尾结点,释放它
}
bool ListEmpty(LinkList *L)
{
    return(L->next==NULL);
}
int ListLength(LinkList *L)
{
    LinkList *p=L;
    int i=0;
    while (p->next!=NULL)
    {
        i++;
        p=p->next;
    }
    return(i);
}
void DispList(LinkList *L)
{
    LinkList *p=L->next;
    while (p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
bool GetElem(LinkList *L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L;
    while (j<i && p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)            //不存在第i个数据结点
        return false;
    else                    //存在第i个数据结点
    {
        e=p->data;
        return true;
    }
}
int LocateElem(LinkList *L,ElemType e)
{
    LinkList *p=L->next;
    int n=1;
    while (p!=NULL && p->data!=e)
    {
        p=p->next;
        n++;
    }
    if (p==NULL)
        return(0);
    else
        return(n);
}
bool ListInsert(LinkList *&L,int i,ElemType e)
{
    int j=0;
    LinkList *p=L,*s;
    while (j<i-1 && p!=NULL) //查找第i-1个结点
    {
        j++;
        p=p->next;
    }
    if (p==NULL)    //未找到位序为i-1的结点
        return false;
    else            //找到位序为i-1的结点*p
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
        s->data=e;
        s->next=p->next;                        //将*s插入到*p之后
        p->next=s;
        return true;
    }
}
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L,*q;
    while (j<i-1 && p!=NULL)    //查找第i-1个结点
    {
        j++;
        p=p->next;
    }
    if (p==NULL)                //未找到位序为i-1的结点
        return false;
    else                        //找到位序为i-1的结点*p
    {
        q=p->next;              //q指向要删除的结点
        if (q==NULL)
            return false;           //若不存在第i个结点,返回false
        e=q->data;
        p->next=q->next;        //从单链表中删除*q结点
        free(q);                //释放*q结点
        return true;
    }
}
void Link(LinkList *&L1, LinkList *&L2)
{
    LinkList *p = L1;
    while(p->next != NULL)   //找到L1的尾节点
        p = p->next;
    p->next = L2->next;  //将L2的首个数据节点连接到L1的尾节点后
    free(L2);   //释放掉已经无用的L2的头节点
}

int main()
{
    LinkList *A, *B;
    int i;
    ElemType a[]= {1,3,2,9};
    ElemType b[]= {0,4,7,6,5,8};
    InitList(A);
    for(i=3; i>=0; i--)
        ListInsert(A, 1, a[i]);
    InitList(B);
    for(i=5; i>=0; i--)
        ListInsert(B, 1, b[i]);
    Link(A, B);
    printf("A:");
    DispList(A);
    DestroyList(A);
    return 0;
}


运行结果：

算法复杂度为O(m)，只需要由L1的头节点找到其尾节点即可，与L1的长度相关，与L2的长度n无关

（3）判断递增算法

#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode        //定义单链表结点类型
{
    ElemType data;
    struct LNode *next;     //指向后继结点
}LinkList;
void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表
void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表
void InitList(LinkList *&L);  //初始化线性表
void DestroyList(LinkList *&L);  //销毁线性表
bool ListEmpty(LinkList *L);  //判断线性表是否为空
int ListLength(LinkList *L);  //求线性表长度
void DispList(LinkList *L);  //输出线性表
bool GetElem(LinkList *L,int i,ElemType &e);  //求线性表某个数据元素值
int LocateElem(LinkList *L,ElemType e);  //按元素值查找
bool ListInsert(LinkList *&L,int i,ElemType e);  //插入数据元素
bool ListDelete(LinkList *&L,int i,ElemType &e);  //删除数据元素
void CreateListF(LinkList *&L,ElemType a[],int n)//头插法建立单链表
{
    LinkList *s;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
    for (i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
        s->data=a[i];
        s->next=L->next;            //将*s插在原开始结点之前,头结点之后
        L->next=s;
    }
}

void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法建立单链表
{
    LinkList *s,*r;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
    r=L;                    //r始终指向终端结点,开始时指向头结点
    for (i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
        s->data=a[i];
        r->next=s;          //将*s插入*r之后
        r=s;
    }
    r->next=NULL;           //终端结点next域置为NULL
}

void InitList(LinkList *&L)
{
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
}
void DestroyList(LinkList *&L)
{
    LinkList *p=L,*q=p->next;
    while (q!=NULL)
    {
        free(p);
        p=q;
        q=p->next;
    }
    free(p);    //此时q为NULL,p指向尾结点,释放它
}
bool ListEmpty(LinkList *L)
{
    return(L->next==NULL);
}
int ListLength(LinkList *L)
{
    LinkList *p=L;
    int i=0;
    while (p->next!=NULL)
    {
        i++;
        p=p->next;
    }
    return(i);
}
void DispList(LinkList *L)
{
    LinkList *p=L->next;
    while (p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
bool GetElem(LinkList *L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L;
    while (j<i && p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)            //不存在第i个数据结点
        return false;
    else                    //存在第i个数据结点
    {
        e=p->data;
        return true;
    }
}
int LocateElem(LinkList *L,ElemType e)
{
    LinkList *p=L->next;
    int n=1;
    while (p!=NULL && p->data!=e)
    {
        p=p->next;
        n++;
    }
    if (p==NULL)
        return(0);
    else
        return(n);
}
bool ListInsert(LinkList *&L,int i,ElemType e)
{
    int j=0;
    LinkList *p=L,*s;
    while (j<i-1 && p!=NULL) //查找第i-1个结点
    {
        j++;
        p=p->next;
    }
    if (p==NULL)    //未找到位序为i-1的结点
        return false;
    else            //找到位序为i-1的结点*p
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
        s->data=e;
        s->next=p->next;                        //将*s插入到*p之后
        p->next=s;
        return true;
    }
}
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L,*q;
    while (j<i-1 && p!=NULL)    //查找第i-1个结点
    {
        j++;
        p=p->next;
    }
    if (p==NULL)                //未找到位序为i-1的结点
        return false;
    else                        //找到位序为i-1的结点*p
    {
        q=p->next;              //q指向要删除的结点
        if (q==NULL)
            return false;           //若不存在第i个结点,返回false
        e=q->data;
        p->next=q->next;        //从单链表中删除*q结点
        free(q);                //释放*q结点
        return true;
    }
}
bool increase(LinkList *L)
{
    LinkList *p = L->next, *q;  //p指向第1个数据节点
    if(p != NULL)
    {
        while(p->next != NULL)
        {
            q = p->next;   //q是p的后继
            if (q->data > p->data)   //只要是递增的，就继续考察其后继
                p = q;
            else
                return false;    //只要有一个不是后继大于前驱，便不是递增
        }
    }
    return true;
}

int main()
{
    LinkList *A, *B;
    int i;
    ElemType a[]= {1, 3, 2, 9};
    ElemType b[]= {0, 4, 5 ,6, 7, 8};
    InitList(A);
    for(i=3; i>=0; i--)
        ListInsert(A, 1, a[i]);
    InitList(B);
    for(i=5; i>=0; i--)
        ListInsert(B, 1, b[i]);
    printf("A: %c\n", increase(A)?'Y':'N');
    printf("B: %c\n", increase(B)?'Y':'N');
    DestroyList(A);
    DestroyList(B);
    return 0;
}


运行结果：


得：
a[]= {1, 3, 2, 9}  不是递增

 b[]= {0, 4, 5 ,6, 7, 8}  是递增

ap_ple6223
关注
数据结构-一元多项式操作
Vivinia的博客
10-26 6327
本项目是老师发的框架，自己简单填写了加、减、乘、求导、积分的部分代码。 目标效果： 加法： 减法和乘法与加法类似，就不贴结果图了。 求导： 积分： 下面贴几个主要页面： 1.Mutualplat.h页面： #ifndef MUTUALPLAT_H_INCLUDED #define MUTUALPLAT_H_INCLUDED ////////////////
第四周项目三C/C++单链表应用，逆置、连接与递增判断
JING727708672的博客
11-05 317
/* *Copyright (c) 2017,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：单链表应用逆置、连接与递增判断 *作 者：高晶 *完成日期：2017年9月26日 *版 本 号：v1.0 * 定义单链表存储结构，用头插法和尾插法建立单链表，并显示建立好以后的结果。 */ 1、设计一个算法，将
第四周项目3单链表应用
hwj0406的博客
12-14 234
【项目3 - 单链表应用】 　　完成下面的应用时，除项目中给出的特殊要求，其余工作均可利用项目2完成的算法支持。 　　1、设计一个算法，将一个带头结点的数据域依次为a1，a2，…，an（n≥3）的单链表的所有结点逆置，即第一个结点的数据域变为an，…，最后一个结点的数据域为a1。实现这个算法，并完成测试。 提示：实现算法时，可以设计下面的函数：void Reverse(LinkLis
第二章 线性表 2.5线性表的链式表示和实现
Deam_swan_goose的博客
03-08 439
2.5线性表的链式表示和实现 最近在看《明朝那些事儿》颇有感慨，在文章开始之前容我啰嗦几句。昔明太祖朱元璋从一无所有之人到至高无上的皇帝，这期间的艰难困苦一言难尽……但是历史永远的记住了他，而在权力争夺路上倒下的普通人，历史只留下了四个字——灰飞烟灭。没有人会记住他们的名字，没有人会在乎他们的人生。唯有帝王将相才子佳人才有资格留下印记去证明他们来过这个星球。 倘若百年之后我年少时写的东西还能有幸被...
数据结构 单链表基本操作（C++）
Ruannn的博客
03-19 756
个人笔记
数据结构的判空操作
weiker12的专栏
08-07 4856
1.顺序表的判空： bool ListEmpty(SqList *L) //判线性表是否为空表 { return(L -> length == 0); //长度为0即为空表 } 2.单链表的判空： bool ListEmpty(LinkList *L) //判线性表是否为空表 { return(L->next == NULL); //链表的指针指向下一个为空为空表 } 3.
数据结构【线性表（二)链表】项目之单链表：逆置
Sailor_luo的博客
10-04 1141
/*   *数据结构【线性表（二)链表】项目之单链表：逆置   *Copyright (c) 2015 烟台大学计算机与控制工程学院   *All right reserved.   *文件名称:danlianbiao.cpp   *标题:数据结构【线性表（二)链表】项目之单链表：逆置、连接与递增判断   *分类:单链表：逆置、连接与递增判断   *writer:罗海员   *da
数据结构【线性表（二)链表】项目之单链表：递增判断
Sailor_luo的博客
10-04 899
/*   *数据结构【线性表（二)链表】项目之单链表：递增判断   *Copyright (c) 2015 烟台大学计算机与控制工程学院   *All right reserved.   *文件名称:danlianbiao.cpp   *标题:数据结构【线性表（二)链表】项目之单链表：逆置、连接与递增判断   *分类:单链表：逆置、连接与递增判断   *writer:罗海员   *
JAVA单链表的简单操作（递增单链表插入数据，链表逆置，链表逆序合成）
qq_44095715的博客
03-23 1238
JAVA写一个单链表 1、已知带头结点的动态单链表 L 中的结点是按整数值递增排序的，试写一 算法将值为 x 的结点插入到表 L 中，使 L 仍然有序。要求算法的时间复杂度为 O(n)，空间复杂度为 O(1)。 2、设计一算法，逆置带头结点的动态链表 L。要求利用原表的结点空间， 并要求用尽可能少的时间完成。 3、假设有两个按元素值递增有序的线性表 A 和 B，均以单链表作存...
单链表算法(增删改查、头插法、尾插法、单链表逆置、求倒数第k个节点值、找中间节点、删除单链表中最大值节点、分割单链表）、)
06-25 984
单链表简介： 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 代码： #include <stdio.h> #include "stdlib.h" typedef int ElemType; typedef struct Node { ElemType data; stru
数据结构实验一：（2）（单链表）线性表的各种操作LinkList
wssyaoqifei的博客
10-27 921
                    代码： #include&lt;iostream&gt; #include&lt;malloc.h&gt; #include&lt;cstdio&gt; using namespace std; typedef struct LNode {     char data;     struct LNode*next; }LinkNod...
【数据结构详细学习笔记2】单链表的定义和表示
longbow_nice的博客
07-09 2318
单链表基础知识，单链表代码实现，实现单链表遇到问题
转——链表中LinkList L与LinkList *L的区别
weixin_30457551的博客
12-09 5802
typedef struct Node{ int elem; struct node * next; }node,*LinkList; 　　 对于LinkList L: L是指向定义的node结构体的指针,可以用->运算符来访问结构体成员,即L->elem,而(*L)就是个Node型的结构体了,可以用点运算符访问该结构体成员,即(*L).elem; 对于Link...
数据结构实验.2
比企谷叭帆i的博客
10-30 1364
12.3 实验二 线性表的链式存储结构 3. （必做题）设计并验证以下算法：判定带头结点单向链表L的数据元素是否为非递增有序。如果是非递增有序的，删除值相同的多余元素，并就地逆置删除后的链表L；如果不是非递增有序的，输出相应的提示信息。 (1) 根据键盘输入数据用尾插法建立带头结点单向链表L。 (2) 输出带头结点单向链表L、删除值相同多余元素后的单向链表L、就地逆置后的单向链表L。 #inclu...
第四周项目3—单链表应用
Niki2222的博客
09-25 740
完成下面的应用时，除项目中给出的特殊要求，其余工作均可利用项目2完成的算法支持。 　　1、设计一个算法，将一个带头结点的数据域依次为a1，a2，…，an（n≥3）的单链表的所有结点逆置，即第一个结点的数据域变为an，…，最后一个结点的数据域为a1。实现这个算法，并完成测试。 提示：实现算法时，可以设计下面的函数：void Reverse(LinkList *&L) 　　2、已知L
【数据结构 李春葆】第二章 线性表 上机实验题2【单链表】
memcpy0的博客
10-21 6899
实验题2：实现单链表的各种基本运算 编写一个程序linklist.h和linklist.cpp，实现单链表的各种基本运算和整体建表算法(元素类型ElemType为char)。在此基础上面设计一个exp2-2.cpp完成下面的功能。 初始化单链表h。 依次采用尾插法插入a,b,c,d,e元素。 输出单链表h。 输出单链表的长度。 判断单链表是否为空。 输出单链表的第3个元素。 输出元素a的位置。 ...
大一新生必看，自学必看，里昂详解数据结构之链表
iiLeon的博客
08-23 609
数据结构之链表 核心算法思想 1． 链表建立操作的基本步骤：链表是一个动态的结构，它不需要分配空间，因此建立链表的过程是一个结点“逐个插入” 的过程。先建立一个只含头结点的空单链表，然后依次生成新结点，再不断地将其插入到链表的头部或尾部，分别称其为“头插法”和“尾插法”。 2． 链表查找操作的基本步骤：因链表是一种"顺序存取"的结构，则要在带头结点的链表中查找到第 i个元素，必须从头结点开始沿着后继指针依次"点数"，直到点到第 i 个结点为止,如果查找成功，则用e返回第i个元素值。头结点可看成是第0个结点。
205LinkList
weixin_34006468的博客
05-11 119
2019独角兽企业重金招聘Python工程师标准>>> ...
第4周 项目3-单链表应用
ap_ple6223的博客
10-05 418
/* *文件名称：1.pp *作者：崔从敏 *完成日期：2015年10月5日 *问题描述：单链表的应用 */ （1）#include #include typedef int ElemType; typedef struct LNode //定义单链表结点类型 { ElemType data; struct LNode *
编写程序，建立2个带头结点单链表，输入若干整数将正整数插入第1个单链表，将负整数插入第2个单链表，插入前和插入后单链表保持递增或相等次序，显示2个单链表，最后销毁。程序不可存在内存泄漏。)建立2个单链表基础上，设计和实现就地逆置单链表函数，即利用原单链表结点建立元素次序相反的单链表。编写程序，建立2个单链表，就地逆置这2个单链表，显示逆置前后的各单链表。注意不可存在内存泄漏。
06-07
以下是代码实现： ```c #include <stdio.h> #include <stdlib.h> // 定义链表结构体 typedef struct node { int data; struct node *next; } Node, *List; // 建立链表函数 List buildList() { List head = (List)malloc(sizeof(Node)); head->next = NULL; Node *p = head; int num; printf("请输入整数，以0结束："); scanf("%d", &num); while (num != 0) { Node *q = (Node *)malloc(sizeof(Node)); q->data = num; q->next = NULL; p->next = q; p = q; scanf("%d", &num); } return head; } // 就地逆置单链表函数 void reverseList(List head) { Node *p = head->next, *q = NULL; head->next = NULL; while (p != NULL) { q = p->next; p->next = head->next; head->next = p; p = q; } } // 分离链表函数 void splitList(List head, List posList, List negList) { Node *p = head->next, *q1 = posList, *q2 = negList; while (p != NULL) { if (p->data > 0) { q1->next = p; q1 = p; } else { q2->next = p; q2 = p; } p = p->next; } q1->next = NULL; q2->next = NULL; } // 输出链表函数 void printList(List head) { Node *p = head->next; while (p != NULL) { printf("%d ", p->data); p = p->next; } printf("\n"); } // 销毁链表函数 void destroyList(List head) { Node *p = head, *q = head->next; while (q != NULL) { p = q; q = q->next; free(p); } free(head); } int main() { List head1 = buildList(); List head2 = (List)malloc(sizeof(Node)); head2->next = NULL; List posList = (List)malloc(sizeof(Node)); posList->next = NULL; List negList = (List)malloc(sizeof(Node)); negList->next = NULL; splitList(head1, posList, negList); printf("正数单链表："); printList(posList); printf("负数单链表："); printList(negList); reverseList(posList); reverseList(negList); printf("逆置后的正数单链表："); printList(posList); printf("逆置后的负数单链表："); printList(negList); destroyList(head1); destroyList(head2); destroyList(posList); destroyList(negList); return 0; } ``` 程序运行截图： ``` 请输入整数，以0结束：1 3 -2 -4 5 0 正数单链表：1 3 5 负数单链表：-2 -4 逆置后的正数单链表：5 3 1 逆置后的负数单链表：-4 -2 ``` 程序时间复杂度为O(n)，空间复杂度为O(1)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值