第四周项目3—单链表应用

最新推荐文章于 2022-04-15 19:39:32 发布
最新推荐文章于 2022-04-15 19:39:32 发布
阅读量671 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Niki2222/article/details/48629703
版权
　　完成下面的应用时，除项目中给出的特殊要求，其余工作均可利用项目2完成的算法支持。
　　1、设计一个算法，将一个带头结点的数据域依次为a1，a2，…，an（n≥3）的单链表的所有结点逆置，即第一个结点的数据域变为an，…，最后一个结点的数据域为a1。实现这个算法，并完成测试。

提示：实现算法时，可以设计下面的函数：void Reverse(LinkList *&L)

　　2、已知L1和L2分别指向两个单链表的头结点，且已知其长度分别为m、n，请设计算法将L2连接到L1的后面。实现这个算法，完成测试，并分析这个算法的复杂度。

提示：实现算法时，可以设计下面的函数：void Link(LinkList&L1, LinkList&L2)

　　3、设计一个算法，判断单链表L是否是递增的。实现这个算法，并完成测试。

 

问题一

 

linklist.h

#ifndef LINKLIST_H_INCLUDED
#define LINKLIST_H_INCLUDED

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 Reverse(LinkList *&L);
#endif // LINKLIST_H_INCLUDED


linklist.cpp

#include <stdio.h>
#include <malloc.h>
#include "linklist.h"


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指向下一个结点
    }
}


main.cpp

#include "linklist.h"
#include <stdio.h>
#include <malloc.h>
#include "linklist.h"


int main()
{
    LinkList *L1, *L2;
    ElemType a[8]= {7, 9, 8, 2, 0, 4, 6, 3};
    CreateListF(L1, a, 8);
    printf("头插法建表结果：");
    DispList(L1);
    CreateListR(L2, a, 6);
    printf("尾插法建表结果：");
    DispList(L2);
    DestroyList(L1);
    DestroyList(L2);
    return 0;
}

运行结果

 

 

问题二

linklist.cpp

#ifndef LINKLIST_H_INCLUDED
#define LINKLIST_H_INCLUDED

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 Link(LinkList *&L1, LinkList *&L2);
#endif // LINKLIST_H_INCLUDED


linklist.cpp

#include <stdio.h>
#include <malloc.h>
#include "linklist.h"


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的头节点
}


main.cpp

#include "linklist.h"
#include <stdio.h>
#include <malloc.h>
#include "linklist.h"

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;
}


 

 

问题三

linklist.h

#ifndef LINKLIST_H_INCLUDED
#define LINKLIST_H_INCLUDED

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);  //删除数据元素
bool increase(LinkList *L);
#endif // LINKLIST_H_INCLUDED


linkist.cpp

#include <stdio.h>
#include <malloc.h>
#include "linklist.h"


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;
}

main.cpp

#include "linklist.h"
#include <stdio.h>
#include <malloc.h>


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;
}


 

心得体会：把程序分装在多个文件里面不能忘了写头文件，在linklist.h里写函数名字的时候不能忘了写分号（；）。


 

Niki2222
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单链表应用
11-01
该资源能实现在每三次就把链表的一个元素消除，知道剩最后一个
C语言—链表的逆置
wintershii的博客
05-27 5055
C语言—链表的逆置 组里考核题有这么一道题：创建一个链表，链表里的数据取随机数，现在要求把链表逆置，写出实现代码。 刚看到这道题的时候我第一想到的是交换指针实现，但是画了半天想不出来，为了过审核就用了最笨的值交换。就是把头和尾的值交换，头向后移，尾向前移，直到相遇。 后来组长除了这个值交换还说了两种方法：迭代逆置链表和递归逆置链表。 迭代逆置链表：从第一个节点开始依次改变节点指针，把原来...
PTA链表函数和编程题
琉璃轻纱的博客
03-27 5144
6-1 求单链表的表长 (10分) 本题要求实现一个函数，求带头结点的单链表的表长。 函数接口定义： int Length ( LinkList L ); 其中LinkList结构定义如下： typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; L是带头结点的单链表的头指针，函数Len...
写一个函数reverseList，该函数能够接受一个List，然后把该List 倒序排列。(用list)
WFlySky的博客
07-04 2773
写一个函数reverseList，该函数能够接受一个List，然后把该List 倒序排列。(用list) import java.util.ArrayList; import java.util.List; /** * @author wangtengfei * @date 2019/7/4 14:33 */ public class Demo4 { public static v...
数据结构:关于逆转链表的问题(C语言实现)
weixin_57425841的博客
04-15 1588
设计一个函数 void LinkReverse(List *pla) 其功能将带头结点的单向链表反转。la是一个带头结点的链表，函数的目的是逆转这个链表， 也就是第一个结点变成最后一个结点，第二个结点变为倒数第二个结点，以此类推。该函数的空间复杂度为O(1），也就是该函数不能定义数组变量和使用动态分配函数。其中List是如下结构体： typedef struct T_Node{ int d; struct T_Node *next; } Node, *List; 如下的main函数执行后 /...
线性表（二）——单链表（4）——单链表的递增判断
Henry's Blog
11-11 755
/* *Copyright (c) 2015 , 烟台大学计算机学院 *All right resvered . *文件名称: 单链表的递增判断.cpp *作 者: 郑兆涵 *线性表（二）——单链表 （4） */ 问题：设计一个算法，判断单链表L是否是递增的。实现这个算法，并完成测试。 编程代码： //头文件：l
Python3实现的反转单链表算法示例
09-19
主要介绍了Python3实现的反转单链表算法,结合实例形式总结分析了Python基于迭代算法与递归算法实现的翻转单链表相关操作技巧,需要的朋友可以参考下
C#(数据结构与教程）单链表的实例应用程序
01-19
单链表的算法及调。单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素...
应用单链表统计单词出现次数
07-14
从一篇txt文档中读取出英文单词，统计不同英文单词出现的次数（大小写统一被视为小写），按照次数从多到少输出到另一txt文件中.
单链表及其应用
01-07
利用单链表实现电话本的模拟程序：定义单链表的数据类型，将头插法和尾插法、插入、删除、查找、修改、计数、逆置、输出等操作都定义成子函数的形式，最后在主函数中调用它，并将每一种操作前后的结果输出，以查看每...
线性表初始化int InitList(LinkList *L)和int InitList（LinkList L）问题
热门推荐
zachaxy的专栏
10-25 2万+
在数据结构线性表一章，看到
第四周上机实践项目3（2）——单链表应用
yxxhilda的博客
09-25 330
问题及代码： 测试函数：main.cpp，完成相关的测试工作 /* *Copyright(c)2015,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：test.cpp *作者：颜肖璇 *完成日期：2015年9月25日 *版本号：v1.0 /* *问题描述：已知L1和L2分别指向两个单链表的
数据结构实践——单链表：逆置、连接与递增判断
weixin_34061482的博客
09-11 165
本文针对数据结构基础系列网络课程(2)：线性表的实践项目。 【项目 - 单链表算法】（程序中利用了已经实现的单链表算法，头文件LinkList.h及其中函数的实现见单链表算法库） 　　1、设计一个算法，将一个带头结点的数据域依次为a1，a2，…，an（n≥3）的单链表的所有结点逆置，即第一个结点的数据域变为an，…，最后一个结点的数...
第四周项目三（3）-判断单链表是否递增
xiaoguaishou2333的博客
09-22 1696
问题及代码： /* copyright （t） 2016，烟台大学计算机学院 *All rights reserved. *文件名称：1.cpp *作者：肖博文 *完成日期：2016年9月22日 *版本号：v1.0 *问题描述：判断单链表L是否递增（注：不考虑输入元素有重复的情况，如输入5个节点，1 2 3 3 5） *输入描述：单链表L长度n 单
第4周 项目3-单链表：逆置、连接与递增判断
ap_ple6223的博客
10-05 373
/* *文件名称：1.pp *作者：崔从敏 *完成日期：2015年10月5日 *问题描述：单链表：逆置、连接与递增判断 */ （1）逆置#include #include typedef int ElemType; typedef struct LNode //定义单链表结点类型 { ElemType data; struct
第4周 项目3-单链表应用
ap_ple6223的博客
10-05 380
/* *文件名称：1.pp *作者：崔从敏 *完成日期：2015年10月5日 *问题描述：单链表的应用 */ （1）#include #include typedef int ElemType; typedef struct LNode //定义单链表结点类型 { ElemType data; struct LNode *
数据结构第四周项目-单链表算法
zx735211469的博客
11-30 396
/* *Copyright (c) 2017,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：多文件组织 *作 者：张昕 *完成日期：2017年11月30日 *版 本 号：v1.0 */ 头文件LinkList.h及其中函数的实现见　单链表
线性表的基本操作（单链表）
DoyleWang的博客
06-04 1054
要求同顺序表：   #include using namespace std; #include #include #define MaxSize 50 typedef char ElemType; typedef struct LNode //定义单链表结点类型 {  ElemType data;     struct LNode *next; } LinkList;
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6038
单链表的操作与实现
单链表应用实例代码C语言
最新发布
03-25
以下是一个简单的单链表的应用实例代码，使用C语言实现： ```c #include <stdio.h> #include <stdlib.h> // 定义链表结构体 typedef struct Node { int data; struct Node* next; } node; // 创建新节点 node* create_node(int data) { node* new = (node*)malloc(sizeof(node)); new->data = data; new->next = NULL; return new; } // 在链表末尾插入节点 void insert_node(node** head, int data) { node* new = create_node(data); if (*head == NULL) { *head = new; return; } node* current = *head; while (current->next != NULL) { current = current->next; } current->next = new; } // 删除指定值的节点 void delete_node(node** head, int data) { if (*head == NULL) { return; } if ((*head)->data == data) { node* temp = *head; *head = (*head)->next; free(temp); return; } node* current = *head; while (current->next != NULL && current->next->data != data) { current = current->next; } if (current->next != NULL) { node* temp = current->next; current->next = current->next->next; free(temp); } } // 打印链表 void print_list(node* head) { printf("Linked List: "); while (head != NULL) { printf("%d ", head->data); head = head->next; } printf("\n"); } int main() { node* head = NULL; insert_node(&head, 1); insert_node(&head, 2); insert_node(&head, 3); insert_node(&head, 4); insert_node(&head, 5); print_list(head); delete_node(&head, 3); print_list(head); delete_node(&head, 1); print_list(head); return 0; } ``` 该代码实现了一个单链表的基本操作，包括创建节点、在末尾插入节点、删除指定值的节点和打印链表。可以通过在 `main` 函数中调用这些函数来使用这个单链表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值