单链表的创建及其基本操作

最新推荐文章于 2024-11-09 20:38:27 发布
最新推荐文章于 2024-11-09 20:38:27 发布
阅读量36 收藏
点赞数 1
文章标签： 算法 数据结构 链表 visual studio c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59193477/article/details/133278684
版权

  1. 不带头节点的单链表的创建 
    #include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct {
    int data;
    struct LinkList* next;
}LinkList;

bool InitList(LinkList* L) {
    L = NULL;                //空表，暂时还没有任何节点
    return true;
}

//判断单链表是否为空
bool Empty(LinkList* L) {
    return (L == NULL);
}

int main()
{
    LinkList* L;            //声明一个指针指向单链表
    //初始化一个空表
    InitList(&L);

    return 0;
}

  2. 带头结点的单链表的创建 
    #include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct {
    int data;
    struct LinkList* next;
}LinkList;

bool InitList(LinkList* L) {
    L = (LinkList*)malloc(sizeof(LinkList));        //分配一个头节点
    if (L == NULL)
        return false;
    L->next == NULL;        //头结点之后暂时还没有节点
    return true;
}

//判断单链表是否为空(带头结点)
bool Empty(LinkList* L) {
    if (L->next == NULL)
        return true;
    else
        return false;
}

int main()
{
    LinkList* L;            //声明一个指针指向单链表
    //初始化一个空表
    InitList(&L);

    return 0;
}

  3. 单链表的基本操作-----按位序插入（带头结点） 
    //在第i个位置插入元素e(带头结点)
bool ListInsert(LinkList* L, int i, int e) {
    if (i < 1)
        return false;
    LinkList* p;            //指针p指向当前扫描的结点
    int j = 0;                //指针p指向的是第几个结点
    p = L;                    //L是指向头结点，头结点是第0个结点（不存数据）

    while (p != NULL && j < i - 1) {            //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;        //i的值不合法
    LinkList* cur = (LinkList*)malloc(sizeof(LinkList));        //创建一个新的结点
    cur->data = e;
    cur->next = p->next;    //先将cur连到p的下一个结点
    p->next = cur;            //再将p连到cur，这样就把cur插入进去了
    return true;
                        
}

  4. 单链表的基本操作-----按位序插入（不头结点） 
    //在第i个位置插入元素e(不头结点)
bool ListInsert(LinkList* L, int i, int e) {
    if (i < 1)
        return false;
    if (i == 1) {        //就是第一个结点的操作与其他的不同
        LinkList* cur = (LinkList*)malloc(sizeof(LinkList));
        cur->data = e;
        cur->next = L;
        L = cur;            //头结点指向新结点
        return true;
    }
        LinkList* p;            //指针p指向当前扫描的结点
        int j = 1;                //此处与带头结点有区别
        p = L;                    //L是指向头结点，头结点是第0个结点（不存数据）

    while (p != NULL && j < i - 1) {            //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;        //i的值不合法
    LinkList* cur = (LinkList*)malloc(sizeof(LinkList));        //创建一个新的结点
    cur->data = e;
    cur->next = p->next;    //先将cur连到p的下一个结点
    p->next = cur;            //再将p连到cur，这样就把cur插入进去了
    return true;

}

  5. 单链表的基本操作-----指定结点的后插操作 
    //后插操作：在p结点后插入元素e
bool InsertNextNode(LinkList* p, int e) {            //时间复杂度O（1）
    if (p == NULL)
        return false;
    LinkList* cur = (LinkList*)malloc(sizeof(LinkList));
    if (cur == NULL)
        return false;        //内存分配失败
    cur->data = e;
    cur->next = p->next;
    p->next = cur;
    return true;
}

  6. 单链表的基本操作-----指定结点的前插操作 
    //前插操作：在p结点之前插入元素e
bool InsertPriorNode(LinkList* p, int e) {
    if (p == NULL)
        return false;
    LinkList* cur = (LinkList*)malloc(sizeof(LinkList));
    if (cur == NULL)
        return false;        //内存分配失败
    //前插操作转换为后插，然后给cur和p的元素交换
    cur->data = e;
    cur->next = p->next;
    p->next = cur;
    int temp = cur->data;
    cur->data = p->data;
    p->data = temp;
    return true;
}

  7. 单链表的基本操作-----按位序删除（带头结点） 
    //按位序删除（带头结点）
bool ListDelete(LinkList* L, int i, int* e) {
    if (i < 1)
        return false;
    LinkList* p;            //指针p指向当前扫描的结点
    int j = 0;                //指针p指向的是第几个结点
    p = L;                    //L是指向头结点，头结点是第0个结点（不存数据）

    while (p != NULL && j < i - 1) {            //循环找到第i-1个结点
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;        //i的值不合法
    if (p->next == NULL)
        return false;        //第i-1个结点后已无其他结点
    LinkList* cur = p->next;        //令cur指向p的next 结点
    *e = cur->data;            //获取到被删除元素的值
    p->next = cur->next;            //p再指向next的next,此时就相当于跳过了p->next这个结点，实现删除
    free(cur);                        //释放cur
    return true;

}

  8. 单链表的基本操作-----指定结点的删除 
    //指定结点的删除
bool DeleteNode(LinkList* p) {
     if (p == NULL)
        return false;
    LinkList* cur = p->next;        //此处删除p结点，和前插类似，将p->next的值放到p上，再删除p->next，相当于删除了p。
    p->data = cur->data;
    p->next = cur->next;        //    此代码有个bug，就是如果p结点是最后一个结点，会报空指针异常
    free(cur);
    return true;
}

  9. 单链表的基本操作-----按位查找（带头结点） 
    //按位查找，返回第i个元素（带头结点）
LinkList* GetElem(LinkList* L, int i) {
    if (i < 0)
        return NULL;
    LinkList* p;
    int j = 0;
    p = L;        //L指向头结点，头结点是第0个结点（不存数据）
    while (p != NULL && j < i) {
        p = p->next;
        j++;
    }
    return p;
}

  10. 单链表的基本操作-----按值查找（带头结点） 
    //按值查找，找到数据域==e的结点（带头结点）
LinkList* LocateElem(LinkList* L, int e) {
    LinkList* p = L->next;            //从第一个结点开始查找
    while (p != NULL && p->data != e) {
        p = p->next;
    }
    return p;            //找到后返回该结点的指针，否则返回NULL
}

  11. 单链表的基本操作-----尾插法建立单链表 
    //尾插法建立单链表
LinkList* ListTailInsert(LinkList* L) {
    int x;        //插入的类型为整型
    L = (LinkList*)malloc(sizeof(LinkList));    //建立头结点
    L->next = NULL;
    LinkList* s, * r = L;        //r为表尾指针
    scanf("%d", &x);
    while (x != 9999) {
        s = (LinkList*)malloc(sizeof(LinkList));
        s->data = x;
        r->next = s;
        r = s;            //r指向新的表尾结点
        scanf("%d", &x);
    }
    r->next = NULL;
    return L;
}

  12. 单链表的基本操作-----头插法建立单链表（单链表的逆置） 
    //头插法建立单链表
LinkList* HeadInsert(LinkList* L) {
    LinkList* s;
    int x;
    L = (LinkList*)malloc(sizeof(LinkList));    //建立头结点
    L->next = NULL;        //初始化为空链表,得置空，有可能指向一个未知区域
    scanf("%d", &x);
    while (x != 9999) {
        s = (LinkList*)malloc(sizeof(LinkList));
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf("%d", &x);
    }
    return L;
}

Redeem丶
关注
单链表的实现及其基本操作
weixin_46506068的博客
01-30 216
关于数据结构中的链表 最近在复习数据结构，之前基本一点都没有看，算是重新开始学习 对于链表的代码实现自己又敲了一遍 。。 记录一下，欢迎大神批评指正 直接上代码 #include<bits/stdc++.h> #define OK 1 #define ERROR 0 using namespace std; typedef int Status; typedef int ElemType; //链表的定义结构 typedef struct Lnode { ElemType data;
单链表的创建和基本操作
weixin_61856940的博客
09-27 707
/1、创建结构体int data;//数据域//指针域//创建表头struct Node* creatList(){ //定义结构体函数，返回结构体指针表示链表//headNode变成了结构体变量//变量初始化//创建结点//定义一个newNode指针，指向结点。
单链表的创建及基本操作
大芝士球的博客
02-17 471
链表作为数据结构中最容易理解的结构，我们需要对它的基本操作非常熟悉结点结构：typedef struct Node { int data; struct Node *next; }Node,*snode; 基本操作：初始化：//初始化 snode init() { snode head=(snode)malloc(sizeof(Node)); if(!head) return NUL...
（C语言）单向链表的创建和链表的一些基本操作
m0_59141303的博客
05-23 339
链表是数据结构里非常重要的一个东西，也是平常用的比较多的一个东西。下面简单的展示一下单向链表的创建和单向链表的一些基本操作。 #include <stdio.h> #include <stdlib.h> typedef int datatype; typedef struct data { datatype num; //数据域 struct data *next; //指针域 }Data; Data *request_head_node(...
【数据结构】单链表的基本操作 （C语言版）
weixin_56814370的博客
01-21 3678
【数据结构】单链表的基本操作 （C语言版）
单链表基本操作
Sti1lWater的博客
12-24 1万+
单链表的基本操作
单链表操作基本运算_单链表的基本操作_
10-03
这个压缩包文件“单链表操作基本运算”包含了关于如何在编程中实现单链表基本操作的详细内容，特别是插入和删除操作。 单链表的插入操作通常分为头插法和尾插法。头插法是在链表的开头添加新节点，这需要更新头节点...
Java实现单链表排序及其基本操作详解
资源摘要信息:"基于Java实现的单链表基本操作之链表排序" 知识点说明: 1. Java编程语言基础 Java是一种广泛使用的面向对象的编程语言，它具有跨平台、面向对象、安全性高等特点。在本资源中，Java被用于实现单链表...
验证单链表及其上的基本操作
08-25
1）创建单链表； 2）插入操作：分别在当前结点后、表头、表尾插入值为x的结点； 3）删除操作：分别删除表头结点、表尾结点和当前结点的后继结点； 4）存取操作：分别存取当前结点的值和单链表中第k个结点的值； 5）...
java单链表的基本操作.zip
01-09
本资料主要涵盖了Java单链表的基本操作，包括链表的定义、创建、插入、删除、遍历等核心概念。 单链表由一系列节点组成，每个节点包含两部分：数据元素（data）和指向下一个节点的引用（next）。链表的头部是第一个...
创建程序文件exp1-2.cpp，实现单链表存储及其基本操作后，完成线性表链表的逆置操作。
10-04
2. 实现单链表的基本操作，如插入节点、删除节点和打印链表： ```cpp ListNode* insertNode(ListNode* head, int val) { // 插入节点函数 } void deleteNode(ListNode*& head, int val) { // 删除节点函数 } ...
一、单链表创建以及操作
qq_61858706的博客
04-28 1713
链表操作全内容： 1，链表创建 2，创建头结点（赋值） 3，输出当前链表 4，连接节点形成链表 5，插入节点函数 6，删除节点函数 7，伪尾插法 8，测试并运行上述代码 9，打印地址了解计算机运行代码的规则 1，链表创建 typedef struct List//创建链表 { char data; struct List*next; }LNode,*NodePtr; 2，创建头结点（赋值） NodePtr startList()//创建链表头结点 { Node..
单链表的创建与基本操作
zhaol_90的博客
12-17 2786
链表通过“指针”将一组零散的内存块串联在一起。其中，我们把内存块称为链表的“结点”。为了将所有的结点串起来，每个链表的结点除了存储数据之外，还需要记录链上的下一个结点的地址。如图所示，我们把这个记录下个结点地址的指针叫作后继指针 next。 把第一个结点叫作头结点，把最后一个结点叫作尾结点。其中，头结点用来记录链表的基地址。而尾结点特殊的地方是：指针不是指向下一个结点，而是指向一个空地址 N...
单链表——单链表的定义及基本操作（初始化、头插法尾插法建表、查找、插入、删除、判空等）
热门推荐
薛定谔的猫的博客
04-17 10万+
文章目录单链表的定义单链表上的操作初始化建立单链表头插法建立单链表尾插法建立单链表遍历单链表求单链表的长度查找操作按值查找按位查找插入操作删除操作完整代码及实例 单链表的定义   由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。   单链表的特点： 单链表不要求逻辑上相邻的两个元素在物理位置上也相邻，因此不需要连续的存储
数据结构单链表的创建以及简单操作
Makeitok_的博客
07-29 9123
数据结构初学-单链表的创建以及简单操作
单链表的基本操作（创建、销毁、增删查改等）
qq_44631587的博客
01-05 2003
链表分类 链表主要有下面三种分类方法： 单向或者双向 带头或者不带头 循环或者非循环 综合来看链表有八种类型，本文主要针对的是不带头节点的非循环单链表。 单链表的介绍 typedef struct SListNode { DataType data;//数据域 struct SListNode *next;//结构体指针，指向下一个节点 }SListNode;//类型别名 如图 链表的每一个节点由数据域和指针域构成，数据域存放数据，指针域中的指针指向下一个节点。plist表示链表的指针，指向链表
单向链表
zheng_lan_fang的博客
09-08 953
单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 表元素域elem用来存放具体的数据。链接域next用来存放下一个节点的位置（python中的标识）变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。 节点实现 class
单链表的基本操作
meng_lemon的博客
08-25 2万+
链表：一种链式存储的线性表，用一组地址任意的存储单元存放线性表的数据元素，称为存储单元为一个节点。 单链表的存储结构 typedef int DataType; typedef struct ListNode { DataType _data; //当前节点中所保存的元素 struct ListNode* _pNext; //指向...
STL set
最新发布
hls0611的博客
11-09 209
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值