数据结构 单链表

最新推荐文章于 2022-11-19 23:55:42 发布
最新推荐文章于 2022-11-19 23:55:42 发布
阅读量353 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41998576/article/details/81414796
版权

一、单链表

以下为源代码，主要功能有：初始化、插入（插入随机数）、遍历、求链表长度、判断链表是否为空、获取p位置的元素、查找元素e的位置、删除、反转、清空、销毁。

1. LinkList.h

#ifndef _LINKLIST_H
#define _LINKLIST_H

#define FAILURE  10000
#define SUCCESS  10001
#define TRUE     10002
#define FALSE    10003

typedef int ElemType;

struct node
{
    ElemType data;  /*数据域*/
    struct node *next;  /*指针域*/
};

typedef struct node Node;

int LinkInit(Node **l);
int LinkInsert(Node *l, int n, ElemType e);
int LinkTraverse(Node *l, void (*p)(ElemType));
int LinkLength(Node *l);
int LinkEmpty(Node *l);
int GetElem(Node *l, int p, ElemType *e);
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType));
int LinkDelete(Node *l, int p, ElemType *e);
int LinkReverse(Node *l);
int LinkClear(Node *l);
int LinkDestroy(Node **l);

#endif

2. LinkList.c

#include "LinkList.h"
#include <stdlib.h>

int LinkInit(Node **l)
{
    *l = (Node *)malloc(sizeof(Node) * 1); /*分配头结点，l是头指针*/
    if(NULL == *l)
    {
        return FAILURE;
    }

    (*l)->next = NULL; /*头结点指针域为空*/

    return SUCCESS;
}

int LinkInsert(Node *l, int n, ElemType e) /*n插入位置,k移动次数*/
{
    Node *p = l;
    int k = 1;

    if(NULL == l)
    {
        return FAILURE;
    }

    while(k < n && p != NULL)
    {
        p = p->next;
        k++;
    }

    if(k > n || p == NULL)
    {
        return FAILURE;
    }

    Node *q = (Node *)malloc(sizeof(Node) * 1);
    if(NULL == q)
    {
        return FAILURE;
    }

    q->data = e; /*数据域*/
    q->next = p->next;
    p->next = q;

    return SUCCESS;
}

/*遍历*/
int LinkTraverse(Node *l, void (*p)(ElemType))
{
    if(NULL == l)
    {
        return FAILURE;
    }
    Node *q = l;

    while (q->next)
    {
        q = q->next;
        p(q->data);
    }

    return SUCCESS;
}

/*求长度*/
int LinkLength(Node *l)
{
    if(NULL == l)
    {
        return FAILURE;
    }

    int len = 0;
    Node *p = l->next;

    while(p)
    {
        len++;
        p = p->next;
    }

    return len;
}

/*判断是否为空*/
int LinkEmpty(Node *l)
{
    return (l->next == NULL) ? TRUE : FALSE;
}

/*获取p位置的元素*/
int GetElem(Node *l, int p, ElemType *e)  /*p位置*/
{
    if(NULL == l || p < 1)  /*入参判断 p不能小于0*/
    {
        return FAILURE;
    }

    Node *q = l;
    int i;

    for(i = 0; i < p && q != NULL; i++)  /*循环p次 同时满足p不为空*/
    {
        q = q->next;
    }

    if(!q)  /*如果q为空，说明p(位置)大于长度*/
    {
        return FAILURE;
    }

    *e = q->data;  /*q已经指向第p个结点*/

    return SUCCESS;
}

/*查找元素e的位置*/
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType))
{
    if(NULL == l)
    {
        return FAILURE;
    }

    Node *q = l->next;
    int len = 1;

    while(q)
    {
        if(p(e, q->data) == TRUE)
        {
            return len;
        }
        q = q->next;
        len++;
    }

    return FAILURE;
}

/*删除*/
int LinkDelete(Node *l, int p, ElemType *e)
{
    int k = 1;
    Node *q = l;

    if(NULL == l)
    {
        return FAILURE;
    }

    while(k < p && q != NULL)
    {
        q = q->next;
        k++;
    }

    if(k > p || q == NULL)
    {
        return FAILURE;
    }

    Node *n = q->next;
    *e = n->data;
    q->next = n->next;
    free(n);

    return SUCCESS;
}

/*反转*/
int LinkReverse(Node *l)
{
    if(NULL == l)
    {
        return FAILURE;
    }

    Node *p = l->next;
    l->next = NULL;

    while(p != NULL)
    {
        Node *q = p;
        p = p->next;
        q->next = l->next;
        l->next = q;
    }

    return SUCCESS;
}
/*清空*/
int LinkClear(Node *l)
{
    if(NULL == l)
    {
        return FAILURE;
    }

    Node *p = l->next;

    while(p)
    {
        l->next = p->next;
        free(p);
        p = l->next;
    }

    return SUCCESS;
}

/*销毁*/
int LinkDestroy(Node **l)
{
    if(NULL == l)
    {
        return FAILURE;
    }
    free(*l);
    (*l) = NULL;

    return SUCCESS;
}

3. TestLinkList.c 

#include "LinkList.h"
#include <stdio.h>
/*带头结点的链表*/
void print(ElemType e)
{
    printf("%d ", e);
}

int equal(ElemType e1, ElemType e2)
{
    return (e1 == e2) ? TRUE : FALSE;
}

int main()
{
    int ret, i;
    Node *first = NULL; /*头指针*/

    srand(time(NULL));

    /*初始化*/
    ret = LinkInit(&first);
    if(ret == FAILURE)
    {
        printf("Init Failure!\n");
    }
    else
    {
        printf("Init Success!\n");
    }

    /*插入*/
    for(i = 0; i < 10; i++)
    {
        ret = LinkInsert(first, i + 1, rand() % 20);
        if(ret == FAILURE)
        {
            printf("Insert Failure!\n");
        }
        else
        {
            printf("Insert Success!\n");
        }
    }

    /*遍历*/
    ret = LinkTraverse(first, print);
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    /*求长度*/
    ret = LinkLength(first);
    if(ret == FAILURE)
    {
        printf("Get Length Failure!\n");
    }
    else
    {
        printf("Length is %d\n", ret);
    }

    /*判断是否为空*/
    ret = LinkEmpty(first);
    if(ret == TRUE)
    {
        printf("List is empty!\n");
    }
    else if(ret == FALSE)
    {
        printf("List is not empty!\n");
    }

    /*获取第p个元素*/
    int p = 3;
    ElemType e;
    ret = GetElem(first, p, &e);
    if(ret == FAILURE)
    {
        printf("Get element failure!\n");
    }
    else
    {
        printf("The %dth element is %d\n", p, e);
    }

    /*判断元素10的位置*/
    e = 10;
    ret = LocateElem(first, e, equal);
    if(FAILURE == ret)
    {
        printf("%d not exist!\n");
    }
    else
    {
        printf("%d is %dth element!\n", e, ret);
    }

    /*删除*/
    p = 3;
    ret = LinkDelete(first, p, &e);
    if(ret == FAILURE)
    {
        printf("Delete Failure!\n");
    }
    else
    {
        printf("Delete %d Success!\n", e);
    }

    /*删除后再次遍历*/
    ret = LinkTraverse(first, print);
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    /*反转*/
    ret = LinkReverse(first);
    if(ret == SUCCESS)
    {
        printf("Reverse Success!\n");
    }
    else
    {
        printf("Reverse Failure!\n");
    }

    /*反转后再次遍历*/
    ret = LinkTraverse(first, print);
    if(ret == FAILURE)
    {
        printf("\nTraverse Failure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

    /*清空*/
    ret = LinkClear(first);
    if(ret == SUCCESS)
    {
        printf("Clear Success!\n");
    }
    else
    {
        printf("Clear Failure!\n");
    }

    /*销毁*/
    ret = LinkDestroy(&first);
    if(ret == SUCCESS)
    {
        printf("Destroy Success!\n");
    }
    else
    {
        printf("Destroy Failure!\n");
    }
    return 0;
}

二、单链表结构与顺序存储结构的优缺点

存储分配方式

时间性能

空间性能

1.  顺序存储结构用一段连续的存储单元依次存储线性表的数据元素。

 

2.  单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素。

1.  查找

顺序存储结构 O( 1 )

单链表 O( n )

 

2.  插入和删除

顺序存储结构需要平均移动表长一半的元素。时间为 O( n ) ;

单链表在线出某位置的指针后，插入和删除时间仅为 O(1);

1．顺序存储结构需要预分配存储结构，分大了，浪费，分小了易发生上溢。

 

2．单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制。

  • 若线性表需要频繁查找，很少进行插入和删除操作时，采用顺序存储结构。若需要频繁的插入和删除时，则采用单链表结构。
  • 当线性表中的元素个数变化较大，或者根本不知道有多大时，最好用单链表结构，这样可以不需要考虑存储空间的大小问题。如果事先知道了线性表的大致长度，用顺序存储结构效率会高很多。

 

 

 

海吹
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构】数组
C、Java知识分享
04-30 988
【数据结构】数组
数据结构单链表
yqg27032108的专栏
05-23 789
<br />计算机科学与技术系<br />实验报告<br />实验名称              个人通讯录               <br />专业班级  计算机科学与技术专1001  姓名                    <br />指导教师            成绩                日期   2011-3-26 <br />                                                                      <br />一
数据结构——单链表
Tang_ming_yue的博客
04-29 815
dan链表是一种链式存取的数据结构，，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。 ...
数据结构-单链表
xiuxin121的博客
05-17 226
引入：线性表适用于频繁的查找数据，很少进行插入和删除操作。入需要频繁的插入和删除，宜采用链表。链式结构：使用结构体来存储数据和前/后继相关联的地址（下一个结构体的指针）。 #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #include&lt;stdbool.h&gt; /** **链表节点的定义 ...
数据结构 单链表的实现
qq_40270751的博客
11-16 255
建立新文件 LinkList.cpp #include using namespace std; #include"LinkList.h" template LinkList::LinkList() { first=new Node; first->next=NULL; } template LinkList::LinkList(DataType a[],int n) { Node*
数据结构学习，单链表
好好学习的博客
01-30 1218
​​​​​​​预先要引用的头文件以及宏定义 所使用单链表的结构 其基本操作接口 构造一个空的单链表（带头结点） 销毁单链表 将单链表L置为空链表 单链表L为空表时返回TRUE，否则返回FALSE 求单链表的表长 查找。返回单链表L中第一个数据域值为e的结点地址，若不存在则返回NULL 返回p结点的直接后继的指针，若p结点是尾结点则返回NULL 构造元素e的结点，返回指向该结点的指针 在p结点后插入结点q 删除p结点的直接后继结点，用e返回结点值，若p空或指向尾元结点则操作失败 遍历单链表
数据结构单链表制作QQ名片最终稿
04-27
绝对干货直接就是源代码 采用顺序表，设计一个QQ群名片，主要包含：QQ号码、昵称、性别、年龄、生日等属性。完成基本功能如下： （1）初始化群名片； （2）添加某一个QQ群中10名成员的名片信息；...
数据结构单链表的详细介绍
09-03
单链表是计算机科学中数据结构的基础之一，它在存储和操作数据方面具有灵活的特点。在本资源中，我们将深入探讨单链表的概念、实现、操作以及其在C语言中的应用。 首先，单链表是一种线性数据结构，其中每个元素...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
王道考研数据结构单链表代码（带头节点）
05-28
自己写的王道考研数据结构单链表（带头结点）例题和习题代码，所有函数运行都没问题。
数据结构（03）——单链表
08-20 529
单链表概念 链表的节点均单向指向下一个节点，形成一条单向访问的数据链。 单链表的初始化 typedef struct _LinkNode { int data; //结点的数据域 struct _LinkNode *next; //结点的指针域 }LinkNode, LinkList; //链表节点、链表 bool InitList(LinkList* &L)//...
数据结构书上算法
爵主 的博客
01-05 596
数据结构书上关键算法 顺序表的存储结构 #define MAXSIZE 100 //顺序表可能达到的最大长度 typedef struct { ElemType *elem; //存储空间的基地址 int length; //当前长度 }SqList; //顺序表的结构类型为SQList 顺序表的操作 顺序表的初始化 Status InitList(SqList &L){ //构造一个空的顺序表L L.elem = new ElemType[MAXSIZE]
数据结构学习笔记--单链表
qq_45640206的博客
02-15 573
中国大学MOOC数据结构的单链表学习笔记 单链表 单链表中节点的定义 单链表的特点是：当访问过一个节点，只能接着访问它的后继节点，而无法访问它的前驱节点。 插入节点操作 插入操作语句描述 s->next=p->next; p->next=s; 用图描述或许更直观一点 删除节点操作 操作语句描述 p->next=p->next->next 建立单链表 像顺序...
线性表操作集锦（顺序表，链表，栈，队列）
悠然青年帅的博客
11-19 1397
顺序表（创建，插入，删除）；链表（创建，插入，删除）； 顺序栈，链栈（创建， 进栈，出栈）；顺序队列，链队（创建，入队，出队）
求单链表长度（C语言）
像鱼的博客
05-03 8566
#include <stdio.h> #include <stdlib.h> // 求链表长度 // 定义链表类型 typedef struct Node { int data; struct Node *next; }Node,*LinkList; // 初始化 LinkList initList () { LinkList L = (Node *) malloc (sizeof(Node)); L->next = NULL; .
数据结构:求单链表(有头节点)长度
热门推荐
匿名攻城狮
03-13 2万+
- 单链表的长度求法与顺序表不同(顺序表有现成的函数length()),下面是求单链表长度的两种方法。 方法一: Status Length_L(LinkList L,int &amp;e) { LinkList p=L-&gt;next;//定义头指针 int j=1;//定义j来计数 while(p)//while(p!=NULL) { p=p-&gt;next;//指针向.........
简历-求职简历-word-文件-简历模版免费分享-应届生-高颜值简历模版-个人简历模版-简约大气-大学生在校生-求职-实习
最新发布
08-25
简历-求职简历-word-文件-简历模版免费分享-应届生-高颜值简历模版-个人简历模版-简约大气-大学生在校生-求职-实习 简历是展示个人经历、技能和能力的重要文档，以下是一个常见的简历格式和内容模板，供您参考： 简历格式： 头部信息：包括姓名、联系方式（电话号码、电子邮件等）、地址等个人基本信息。 求职目标（可选）：简短描述您的求职意向和目标。 教育背景：列出您的教育经历，包括学校名称、所学专业、就读时间等。 工作经验：按时间顺序列出您的工作经历，包括公司名称、职位、工作时间、工作职责和成就等。 技能和能力：列出您的专业技能、语言能力、计算机技能等与职位相关的能力。 实习经验/项目经验（可选）：如果您有相关实习或项目经验，可以列出相关信息。 获奖和荣誉（可选）：列出您在学术、工作或其他领域获得的奖项和荣誉。 自我评价（可选）：简要描述您的个人特点、能力和职业目标。 兴趣爱好（可选）：列出您的兴趣爱好，展示您的多样性和个人素质。 参考人（可选）：如果您有可提供推荐的人员，可以在简历中提供其联系信息。 简历内容模板： 姓名: 联系方式: 地址: 求职目标: （简短描述您的求职意
c语言数据结构单链表长度
03-27
C语言数据结构单链表长度可以通过遍历单链表来计算。具体实现方法如下： 1. 定义一个变量count，用于记录单链表长度，初始值为0。 2. 从单链表的头节点开始，依次遍历单链表的每个节点，每遍历一个节点，count的值加1。 3. 遍历结束后，count的值即为单链表长度。 以下是C语言代码实现： ``` typedef struct Node { int data; struct Node* next; } Node; int getLinkedListLength(Node* head) { int count = 0; Node* p = head; while (p != NULL) { count++; p = p->next; } return count; } ``` 其中，Node是单链表节点的结构体，包含数据域data和指向下一个节点的指针next。getLinkedListLength函数的参数是单链表的头节点指针，返回值是单链表的长度。函数通过遍历单链表，计算节点数量来实现求单链表长度的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值