线性表的链式存储-单链表，从认识到实践

最新推荐文章于 2024-11-02 22:50:17 发布
最新推荐文章于 2024-11-02 22:50:17 发布
阅读量201 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 单链表 指针 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjhqukq/article/details/111402881
版权

单链表和顺序表都是线性表，其外在操作完全一致。唯一的差异就在存储结构上，就是这点差异导致了迥然不同的代码实现。话不多说，赶紧上车吧！
运行效果图：
1.单链表初始化过程
在这里插入图片描述

2.遍历单链表
在这里插入图片描述

3.为单链表追加元素
在这里插入图片描述

4.为单链表删除元素
在这里插入图片描述

5.为单链表插入元素
在这里插入图片描述

6.为单链表定位元素
在这里插入图片描述
。
。
。
。因单链表与顺序表的外在操作完全相同，故省去部分运行效果图
。
。
。

7.清空单链表
在这里插入图片描述
至此，运行效果图展示完毕！

附代码

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>

#define OK 1
#define ERROR -1
#define SPAN 35;//菜单的水平跨度
#define VerticalGap 1//菜单的垂直间距，1就是一个换行，2就是两个换行
typedef struct node {
    int data;//数据域
    struct node *next;//指针域
} *NodePointer, Node;

NodePointer initialize();//初始化链表
void manifest(NodePointer originNodePointer);//遍历链表
int sort(NodePointer originNodePointer);//给链表排序
int inverse(NodePointer originNodePointer);//逆转链表中的所有结点的有效数据
void append(NodePointer originNodePointer, int value);//为链表追加结点，也就是在链表末尾添加一个结点
int insert(NodePointer originNodePointer, int position, int value);//在链表指定的位置上插入新结点
int delete(NodePointer originNodePointer, int position);//删除链表中某一结点的值
int modify(NodePointer originNodePointer, int position, int value);//修改表中的某一结点值
int getNode(NodePointer originNodePointer, int position, int *value);//通过结点下标获取结点值，如果成功获取返回1,否则返回-1
int locateNode(NodePointer originNodePointer, int value);//通过结点的值获取结点下标。若结点不存在或链表为空,则返回-1;若结点存在，则返回下标。
void clear(NodePointer originNodePointer);//清空链表
int isEmpty(NodePointer originNodePointer);//判断链表是否为空
void prompt(char *prompt);//运用了字符串和指针的知识，对printf的简单封装
void inputData(int *data, char *dataExplanation);//运用了字符串和指针的知识,对scanf和printf的简单封装
void menu(char **menu, int length);//动态地输出菜单
void duplicate(int size, char token);//给出一个整数size和一个字符型符号token，输出size个token,不换行
int main() {
    char *operatingMenu[] = {"LinkedList",
                             "1.reinitialize list", "2.present list", "3.append element",
                             "4.delete element", "5.insert element", "6.modify element",
                             "7.get element", "8.locate element", "9.sort", "10.inverse",
                             "11.clear list", "12.exit"};
    int length = sizeof(operatingMenu) / sizeof(char *);
    int indicator, position, value, status;
    NodePointer originNodePointer = initialize();
    while (1) {
        system("cls");
        menu(operatingMenu, length);
        if (originNodePointer == NULL || isEmpty(originNodePointer)) {
            prompt("The List Is Empty.Data are required!");
        } else {
            printf("CURRENT TOTAL:\t%d\n", originNodePointer->data);
            manifest(originNodePointer);
        }
        inputData(&indicator, "type in number:\t");
        switch (indicator) {
            case 1:
                if (isEmpty(originNodePointer)) {
                    free(originNodePointer);//若链表有效数据节点已经释放，则释放起源结点即可
                } else//否则，先释放链表有效数据节点，再释放起源结点
                {
                    clear(originNodePointer);
                    free(originNodePointer);//起源结点单独释放
                }
                originNodePointer = initialize();//给起源结点指针重新赋值
                system("pause");
                break;
            case 2:
                manifest(originNodePointer);
                system("pause");
                break;
            case 3:
                inputData(&value, "VALUE:");
                append(originNodePointer, value);
                manifest(originNodePointer);
                system("pause");
                break;
            case 4:
                inputData(&position, "POSITION:");
                status = delete(originNodePointer, position);
                (status == OK) ? manifest(originNodePointer) : prompt("check out and try again!");
                system("pause");
                break;
            case 5:
                inputData(&position, "POSITION:");
                inputData(&value, "VALUE:");
                status = insert(originNodePointer, position, value);
                (status == OK) ? manifest(originNodePointer) : prompt("check out and try again!");
                system("pause");
                break;
            case 6:
                inputData(&position, "POSITION:");
                inputData(&value, "VALUE:");
                status = modify(originNodePointer, position, value);
                (status == OK) ? manifest(originNodePointer) : prompt("check out and try again!");
                system("pause");
                break;
            case 7:
                inputData(&position, "POSITION:");
                status = getNode(originNodePointer, position, &value);
                (status == OK) ? printf("VALUE: %d\n", value) : prompt("check out and try again!");
                system("pause");
                break;
            case 8:
                inputData(&value, "VALUE:");
                position = locateNode(originNodePointer, value);
                (position == ERROR) ? prompt("check out and try again!") : printf("POSITION:%d\n", position);
                system("pause");
                break;
            case 9:
                status = sort(originNodePointer);
                (status == OK) ? manifest(originNodePointer) : prompt("check out and try again!");
                system("pause");
                break;
            case 10:
                status = inverse(originNodePointer);
                (status == OK) ? manifest(originNodePointer) : prompt("check out and try again!");
                system("pause");
                break;
            case 11:
                clear(originNodePointer);
                system("pause");
                break;
            case 12:
                if (isEmpty(originNodePointer))//若有效结点均已释放完毕
                {
                    free(originNodePointer);//释放起源结点
                } else//否则，先释放链表所有有效节点，再释放起源结点
                {
                    clear(originNodePointer);
                    free(originNodePointer);
                }
                exit(-1);
        }
    }
}

NodePointer initialize() {
    int length;
    inputData(&length, "The length of List:");
    if (length <= 0)
        exit(-1);
    NodePointer originNodePointer = (NodePointer) malloc(sizeof(Node));
    if (originNodePointer == NULL) {
        prompt("Failed To Allocate Memory!");
        exit(-1);
    }
    originNodePointer->data = 0;//起源结点的数据域存放有效结点的个数
    NodePointer newborn = originNodePointer;
    NodePointer temp;
    for (int i = 0; i < length; ++i) {
        temp = (NodePointer) malloc(sizeof(Node));
        printf("element %d:", i + 1);
        scanf("%d", &(temp->data));
        temp->next = NULL;
        newborn->next = temp;
        newborn = temp;
        originNodePointer->data++;//链表中有效结点的个数加1
    }
    return originNodePointer;
}

void manifest(NodePointer originNodePointer) {
    if (isEmpty(originNodePointer)) {
        prompt("The List Is Empty");
        return;
    }
    NodePointer newborn = originNodePointer->next;
    printf("{");
    for (; newborn != NULL; newborn = newborn->next) {
        if (newborn->next != NULL)
            printf("%d\t", newborn->data);
        else
            printf("%d", newborn->data);
    }
    printf("}\n");
}

void append(NodePointer originNodePointer, int value) {
    NodePointer newborn = originNodePointer;
    NodePointer renascence = (NodePointer) malloc(sizeof(Node));
    if (renascence == NULL) {
        prompt("Failed To Allocate Memory!");
        exit(-1);
    }
    renascence->data = value;
    renascence->next = NULL;
    while (newborn->next != NULL) {
        newborn = newborn->next;
    }
    newborn->next = renascence;
    originNodePointer->data++;//起源结点存放链表有效结点的个数，在插入结点后加1
}

int insert(NodePointer originNodePointer, int position, int value) {
    //要想在链表中插入结点Amanda，先要定位到该结点Amanda上一个结点Natasha的位置
    //并且判断结点Natasha有没有后继结点，
    // 若没有，则表明Natasha就是链表表尾，插入的位置无效;
    //若有，则表明插入的位置合法，可以插入该结点
    if (isEmpty(originNodePointer)) {
        prompt("The List Is Empty");
        return ERROR;
    }
    NodePointer newborn = originNodePointer;
    int i;
    for (i = 1; i < position && newborn->next != NULL; ++i)//我们从逻辑上将链表当作数组从前往后遍历
    {
        newborn = newborn->next;
    }
    if (i > position || newborn->next == NULL)//若输入的position小于0,则i>position,那么就判定position非法。再一个判断是否已经到达链表表尾
    {
        prompt("INVALID POSITION");
        return ERROR;
    }
    NodePointer renascence = (NodePointer) malloc(sizeof(Node));
    renascence->next = newborn->next;
    renascence->data = value;
    newborn->next = renascence;
    originNodePointer->data++;//结点数量加1
    prompt("The element is inserted completely!");
    return OK;
}

int delete(NodePointer originNodePointer, int position) {
    //删除结点与插入结点相同，同样要定位到要删除结点Amanda的上一个结点Natasha的位置,后面不再赘述
    if (isEmpty(originNodePointer)) {
        prompt("The List Is Empty");
        return ERROR;
    }
    NodePointer newborn = originNodePointer;
    int i;
    for (i = 1; i < position && newborn->next != NULL; ++i) {
        newborn = newborn->next;
    }
    if (i > position || newborn->next == NULL) {
        prompt("INVALID POSITION");
        return ERROR;
    }
    NodePointer destroyedNode = newborn->next;
    newborn->next = destroyedNode->next;
    free(destroyedNode);
    originNodePointer->data--;
    prompt("The element is deleted successfully!");
    return OK;
}

int modify(NodePointer originNodePointer, int position, int value) {
    if (isEmpty(originNodePointer)) {
        prompt("The List Is Empty");
        return ERROR;
    }
    if (position <= 0 || position > originNodePointer->data) {
        prompt("INVALID POSITION");
        return ERROR;
    }
    NodePointer newborn = originNodePointer;
    for (int i = 1; i <= position; ++i)
        newborn = newborn->next;
    newborn->data = value;
    prompt("The modification is completed!");
    return OK;
}

int getNode(NodePointer originNodePointer, int position, int *value) {
    if (isEmpty(originNodePointer)) {
        prompt("The List Is Empty");
        return ERROR;
    }
    if (position <= 0 || position > originNodePointer->data) {
        prompt("INVALID POSITION");
        return ERROR;
    }
    NodePointer newborn = originNodePointer;
    for (int i = 1; i <= position; ++i) {
        newborn = newborn->next;
    }
    *value = newborn->data;
    return OK;
}

int locateNode(NodePointer originNodePointer, int value) {
    if (isEmpty(originNodePointer)) {
        prompt("The List Is Empty");
        return ERROR;
    }
    NodePointer newborn = originNodePointer;
    int i = 1;
    int position;
    for (; i <= originNodePointer->data; ++i) {
        newborn = newborn->next;
        if (newborn->data == value) {
            position = i;
            break;
        }
    }
    if (i > originNodePointer->data) {
        prompt("The element you are looking for doesn't exist!");
        return ERROR;
    } else
        return position;
}

void clear(NodePointer originNodePointer)//清空链表时，保留起源起点
{
    if (originNodePointer->next == NULL) {
        prompt("There is no need to clear!");
        return;
    }
    NodePointer newborn = originNodePointer;
    NodePointer temporaryNode;
    int temp;
    for (int i = 1; i <= originNodePointer->data; ++i) {
        temporaryNode = newborn->next;
        temp = temporaryNode->data;
        newborn->next = temporaryNode->next;
        free(temporaryNode);
        printf("The element {\t%d\t} is released completely!\n", temp);
    }
    originNodePointer->data = 0;//起源结点的数据域存放链表有效结点的个数，在链表清空后归零
}

int sort(NodePointer originNodePointer)//这里用一个简单的选择排序
{
    if (isEmpty(originNodePointer)) {
        prompt("The List Is Empty");
        return ERROR;
    }
    NodePointer competitor = originNodePointer->next;
    NodePointer opponent = NULL;
    NodePointer exchange = NULL;
    int temp;
    for (; competitor->next != NULL; competitor = competitor->next) {
        //最外层循环competitor只运算前n-1个元素，第n个元素已经是链表表尾,不参后续运算，循环结束
        exchange = competitor;
        for (opponent = competitor->next; opponent != NULL; opponent = opponent->next)
            //内层循环opponent运算到最后一个元素，最后一个元素指针域的指针为空，退出循环
            if (exchange->data > opponent->data)
                exchange = opponent;
        if (exchange != competitor) {
            temp = exchange->data;
            exchange->data = competitor->data;
            competitor->data = temp;
        }
    }
    prompt("Sorting is completed!");
    return OK;
}

int inverse(NodePointer originNodePointer) {
    if (isEmpty(originNodePointer)) {
        prompt("The List Is Empty");
        return ERROR;
    }
    NodePointer begin = originNodePointer->next;
    NodePointer end = originNodePointer->next;
    int counter = originNodePointer->data / 2;
    int temp;
    int j = 0;
    for (int i = 0; i < counter; i++, begin = begin->next) //从逻辑将链表有效节点当成数组来操作
    {
        while (j < originNodePointer->data - 1 - i)//定位到对应的交换节点位置
        {
            ++j;
            end = end->next;
        }
        //第一个有效结点和倒数第一个有效结点交互数据域，第二个有效结点和倒数第二个结点交换数据域，依此类推
        temp = end->data;
        end->data = begin->data;
        begin->data = temp;
        j = 0;
        end = originNodePointer->next;
    }
    prompt("Inverse is completed!");
    return OK;
}

int isEmpty(NodePointer originNodePointer) {
    if (originNodePointer->next == NULL)
        return 1;
    else
        return 0;
}

void inputData(int *data, char *dataExplanation) {
    printf("%s", dataExplanation);
    scanf("%d", data);
}

void prompt(char *prompt) {
    printf("%s\n", prompt);
}

void menu(char **origin, int length) {
    int span = SPAN;
    int gapLength;
    duplicate(span, '*');
    duplicate(1, '\n');
    for (int i = 0; i < length; ++i) {
        duplicate(1, '*');
        gapLength = span - (strlen(*(origin + i))) - 2;
        duplicate(gapLength / 2, ' ');
        printf("%s", origin[i]);
        if (gapLength % 2 == 0) {
            duplicate(gapLength / 2, ' ');
        } else {
            duplicate(gapLength / 2 + 1, ' ');
        }
        duplicate(1, '*');
        duplicate(VerticalGap, '\n');
    }
    duplicate(span, '*');
    duplicate(1, '\n');
}

void duplicate(int size, char token) {
    for (int i = 0; i < size; ++i) {
        printf("%c", token);
    }
}
yjhqukq
关注
专栏目录
[CareerCup] 13.7 Node Pointer 节点指针
weixin_33851177的博客
11-02 113
  13.7 Write a method that takes a pointer to a Node structure as a parameter and returns a complete copy of the passed in data structure. The Node data structure contains two pointers to other Nodes...
(Leetcode)Double pointer to implement delete Linklist node
Tigers Den
09-11 467
Problem: Given a linked list, remove the nth node from the end of list and return its head. It’s great to use double pointer to delete node, the double pointer always store the next node’s address. L
10 个技巧，让你在2017 年成为更好的 Node 开发者
u012362458的博客
02-26 1214
本文是由我们的客座作者Azat Mardan写的。SitePoint引入客座帖子的目的是希望能给你带来web社区里著名作者和演讲者的有趣内容。在2012年，我加入了Storify并开始使用Node作为我的主要语言。从那以后，我从未回首过去并觉得我错过了Python，Ruby，Java以及PHP，这些在过去10年里，我在web开发过程中使用的语言。i
线性表的链式存储之单链表(完整)
北野的博客
08-18 692
文章目录1. 声明结构2. 初始化3. 创建表4. 插入操作4. 删除操作5. 按位查找6. 按值查找7. 打印表8. 结语        开始讲述单链表的基本操作。从开始的存储结构定义到实现一个具体的单链表，各种基本操作都通过具体的程序实现。欢迎指正！ 1. 声明结构        在单链表的存储结构中，我们需要指定两个区域：数据域 data =和指针域 next
线性表的链式存储-单向循环链表，认识的前进上升
yjhqukq的博客
01-17 286
一、链表的再认识(带起源结点) 1.起源结点 首结点的前驱结点即为起源结点，起源结点出现的目的是为了更方便地操作链表，其数据域可用来存放有效结点长度。 从我个人的角度出发，起源结点是链表的发源地，是链表生命的开始，孕育了链表后续的一切，是链表有效结点之母、之父，见证了链表全面的、联系的、运动的、有矛盾的、从无到有的变化过程。万分悲痛的是，它是无性繁殖，且每个后代只能生育一个后代。 什么鬼东西？胡说八道！ 通俗来讲，链表的一切操作都要从起源结点出发，通过起源结点方可追踪到链表后续所有的有效结点。 2.起源指针
线性表的链式存储-双向链表，认识的反复性，实践认识再实践再认识
yjhqukq的博客
01-08 271
“单链表能够独立实现，那么双链表的实现也就干脆利落了”，这是我实现完单链表之后的想法。于是受惯性思维的驱使，大部分都是照搬单链表，甚至可以说是直接复制过来。 后来我仔细一想：单链表一个数据域，一个指针域(指向后继结点)；双链表一个数据域，两个指针域，一个指向前驱结点，一个指向后继结点。双链表的功能是实现了，可其前指针域貌似没怎么使用。 于是我把双链表代码推倒重来，在实现双链表的过程中，尽可能多的使用前指针域。不这样做的话，那双链表跟单链表有什么区别？双链表的存在意义何在？ 一、谈谈链表的定义及个人认识 前指
数据结构 --- 线性表 顺序储存 链式储存
bestallen的博客
11-16 4212
线性表是平时一直会用到的数据结构，像python里面的list这种高级数据结构，其实也是对这种底层结构的封装。 线性表的储存结构主要分两大类，一类一类来看。 在这之前，先用伪代码来形容一下线性表拥有的基本功能 1 ：顺序储存结构 听名字就知道，这是按照顺序来排的，简单来说，就是在用顺序储存结构来建立线性表的时候，他是在内存里面先申请一块空地 然后，所有的相
数据结构与算法——线性表的链式储存结构
xzt12138的博客
07-23 2338
链式储存结构：n个结点链组成一个链表，即为线性表的链式存储结构。因为此链表的每个结点中只包含一个指针域，所以叫做单链表。我们把链表中第一个结点的存储位置叫做头指针。在单链表中第一个结点前附设一个结点，称为头结点。（头结点的数据域可以不储存任何信息）...
线性表--堆栈
看，好自为之的博客！！！
01-17 1413
堆栈的介绍
数据结构----单链表的创建及相关操作
2201_75619538的博客
07-01 1125
链表的介绍，创建，遍历，查找，插入和删除详细操作和具体代码实现
数据结构实验线性表实验报告（代码是java编写的）
05-10
4. **实验总结**：实验者通过这次实践加深了对顺序存储和链式存储的理解，掌握了如何创建和操作这两种结构的线性表。同时，也认识到在设计算法时需要兼顾效率和正确性，以及在解决问题过程中自主学习和解决问题能力...
链式存储结构实验：线性表操作源代码
"这篇资源主要涉及的是数据结构中的线性表链式存储结构，通过实验的方式教授如何操作链表，包括头插法和尾插法建立...通过2学时的实践，学生应该能够独立完成链表的建立、操作及输出，并对链式存储结构有深入的认识。
链式存储结构实验：从创建到操作详解
本实验指导书主要针对《数据结构》课程中的链式存储结构部分进行深入实践，目的是让学生通过实际操作掌握线性表的相关理论知识和技能。实验内容主要包括以下几个方面： 1. 实验目的： - 掌握线性表的链式存储结构...
通用型函数——冒泡排序
2401_84654619的博客
10-29 315
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
【数据结构篇】探索堆的算法的巧妙
braveact的博客
11-02 507
⽤剩余的N-K个元素依次与堆顶元素来⽐较，不满⾜则替换堆顶元素 ，然后再将交换进去后的元素向下调整（保证这k个元素始终是堆），最后将剩余N-k个元素依次与堆顶元素⽐完之后，堆中剩余的K个元素就是所求的前k个最⼩或者最⼤的元素。对于Top-K问题，能想到的最简单直接的⽅式就是排序，但是：如果数据量⾮常⼤，排序就不太可取了 (可能数据都不能⼀下⼦全部加载到内存中)。依次将堆顶最大的数据与最后一个（不断发生变化）元素交换，每次都是将最大的数据放最后，可以想象一下，就是升序了。前k个最⼩的元素，则建⼤堆。
数据结构，问题 F: 括弧匹配检验
nick_912912的博客
11-02 103
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3822
BSP驱动开发工程师-OS、4 道编程题
C语言_数据结构_顺序表
最新发布
m0_74445256的博客
11-02 175
本章重点在于对顺序表的增删查改操作~
python数据类型-8-数据结构-Queue (队列)
Lookontime的博客
10-30 249
在python数据类型系列文章中已经介绍了 python的各种数据类型，队列（Queue）是一种非常重要的数据结构，但并不是python的数据类型，队列遵循先进先出（FIFO）的原则，即先插入的元素先被移除，主要的用途是为了支持线程安全和高效的队列操作而设计的！
线性表搜索算法-单链表实现
这个函数接收一个类型为 `T` 的数据 `x`，并从链表的头节点 `first->link` 开始遍历，直到找到数据为 `x` 的节点或者遍历到链表末尾（返回 `NULL` 表示未找到）。此函数体现了链表搜索的时间复杂度通常为 O(n)，因为...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值