【C语言基础】顺序表、链表

于 2023-01-25 22:25:22 发布
阅读量310 收藏 1
点赞数 1
分类专栏： C语言 文章标签： 链表 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51490933/article/details/128757081
版权

文章目录

一、 线性表

1 线性表定义

请添加图片描述

特点：

  1. 个数有限
  2. 表中数据类型相同
  3. 元素具有逻辑的顺序性，有先后顺序

2 顺序表

用数组实现的

请添加图片描述
请添加图片描述

2.1 插入操作

请添加图片描述

//因为L会改变，所以要引用
bool ListInsert(SqList &L, int i, ElemType element)
{
    //判断不合法情况
    if (i<1 || i>L.length + 1)
    {
        return false;
    }
    //存储空间满了也不能插入
    if (L.length == MaxSize)
    {
        return false;
    }
    //插入元素，插入位置后的元素后移
    for (int j = L.length; j >= i; j--)
    {
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = element;//插入位置的元素
    L.length++;
    return true;
}

2.2 删除操作

请添加图片描述

//删除顺序表  要删除的，有所改变的就加&
//i 是删除元素的位置，del是被删除元素的值
bool ListDelete(SqList& L, int i, ElemType& del) {
    //判断被删除元素的位置是否合法
    if (i < 1 || i>L.length + 1) {
        return false;
    }
    del = L.data[i - 1];
    for (int j = i; j < L.length; j++) {
        L.data[j - 1] = L.data[j];//j赋值为i-1的话，L.data[j] = L.data[j+1],此时需要j<L.length+1,不然多复制了一个
    }
    L.length--;//顺序表长度必须减一
    return true;
}

2.3 查找操作

//查找顺序表
int LocateElem(SqList& L, ElemType element) {
    int i;
    for (i = 0; i < L.length; i++) {
        if (element == L.data[i]) {
            return i + 1;//返回位置，不是下标
        }
      
    }
    return 0;
}

二、单链表

顺序表进行操作移动了大量元素，会造成碎片，因此使用链式结构

一般学习的是具有头结点的链表：
头结点：单链表的第一个结点之前附加了一个结点。头结点的数据域可以不设任何信息，也可以记录表长等信息。头结点的指针域指向线性表的第一个元素结点。

1 头插法创建链表

头插法就是把每个节点插在头结点后面
存储的顺序和输入的顺序是相反的

在这里插入图片描述

请添加图片描述

1.1 代码实现

//1. 头插法
// LNode* 和 LinkList 等价
void list_head_insert(LNode*& L)//这里的LNode* 是结构体指针，&是引用 结构体要改变
{
    L = (LinkList)malloc(sizeof(LNode));//申请头结点空间，头指针指向头结点
    L->next = NULL;
    ElemType x;
    scanf("%d", &x);
    LNode* s;//指向新的节点的指针
    while (x != 9999)
    {
        s = (LinkList)malloc(sizeof(LNode)); // 每次申请一个新的节点
        s->data = x;
        s->next = L->next;//插到头结点后面
        L->next = s;
        scanf("%d", &x);
    }
}

2 尾插法创建链表

尾插法就是把节点插在链表尾部，存储顺序与输入顺序是相同的。

请添加图片描述
把节点连接到链表尾部
在这里插入图片描述

2.1 代码实现

//2. 尾插法
void list_tail_insert(LNode*& L)
{
    L = (LinkList)malloc(sizeof(LNode));//头结点
    L->next = NULL;
    ElemType x;
    scanf("%d", &x);
    //r是一个指针，s也是一个指针变量
    LNode* s, * r = L;//L始终指向头结点，r现在也指向头结点
    while (x != 9999)
    {
        s = (LinkList)malloc(sizeof(LNode));//申请新节点，实际上s指向的就是这块空间的首地址
        s->data = x;
        r->next = s;//r始终指向链表尾部，把新节点连接到尾结点的next
        r = s;//r指向新的尾部![请添加图片描述](https://img-blog.csdnimg.cn/e731289ec1a44a9491652fb13c1b5ba6.png)

        scanf("%d", &x);
    }

3 查找操作

请添加图片描述

3.1 按值查找

从单链表的第一个结点开始，依次比较表中各个结点的数据域的值，若某结点数据域的值等于x，则返回该结点的指针；
若整个单链表中没有这样的结点，则返回空。

//3. 按值查找
LinkList LocateElem(LinkList L, ElemType SearchVal)
{
    while (L)
    {
        if (L->data == SearchVal)
        {
            return L;
        }
        L = L->next;
    }
    return NULL;
}

3.2 按位查找

从单链表的第一个结点开始，顺着指针域逐个往下搜索，直到找到第 i 个结点为止，否则返回最后一个结点的指针域NULL。

//4.按位置查找
LinkList GetElem(LinkList L, int SearchPos)
{
    int j = 0;
    //判断不合法情况
    if (SearchPos < 0)
    {
        return NULL;
    }
    while (L && j < SearchPos)
    {
        L = L->next;
        j++;
    }
    return L;
}

4 插入操作

首先保证第i个位置的合法性。从表头开始遍历，查找第 i-1个结点，即插入位置的前驱结点为p，然后令新结点q的指针域指向p的后继结点，再令结点p的指针域指向新结点q。

4.1 代码实现

//5. 插入一个元素
bool ListFrontInsert(LinkList L, int i, ElemType InsertVal) //第i个位置
{
    LinkList p = GetElem(L, i - 1); // 利用了按位查找的函数，首先保证该位置的合法性
    if (NULL == p)
    {
        return false;
    }
    LinkList q;
    q = (LinkList)malloc(sizeof(LNode));//为新插入的节点申请空间
    q->data = InsertVal;
    q->next = p->next; //p指针就是插入位置前一个位置
    p->next = q;
    return true;
}

5 删除操作

先检查删除位置的合法性，然后从头开始遍历，找到表中的第 i-1 个结点，即被删除结点的前驱结点p，被删除结点为q，修改p的指针域，将其指向q的下一个结点，最后再释放结点q的存储空间。

5.1 代码实现

//5.删除节点
bool ListDelete(LinkList L, int i)
{
    LinkList p = GetElem(L, i - 1);//查找前驱节点是否存在
    if (NULL == p)
    {
        return false;
    }
    LinkList q = p->next;//指向要删除的节点
    p->next = q->next;//断链
    free(q);//释放，删除操作要释放空间
    return true;
}

6 打印链表

// 6. 打印链表
void print_list(LinkList L)
{
    L = L->next;
    while (L != NULL)
    {
        printf("%3d", L->data);
        L = L->next;
    }
    printf("\n");
}

7 完整代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;
typedef struct LNode {
    ElemType data;
    struct LNode* next;
}LNode, * LinkList;//结构体指针
//1. 头插法
// LNode* 和 LinkList 等价
void list_head_insert(LNode*& L)//这里的LNode* 是结构体指针，&是引用 结构体要改变
{
    L = (LinkList)malloc(sizeof(LNode));//申请头结点空间，头指针指向头结点
    L->next = NULL;
    ElemType x;
    scanf("%d", &x);
    LNode* s;//指向新的节点的指针
    while (x != 9999)
    {
        s = (LinkList)malloc(sizeof(LNode)); // 每次申请一个新的节点
        s->data = x;
        s->next = L->next;//插到头结点后面
        L->next = s;
        scanf("%d", &x);
    }
}
//2. 尾插法
void list_tail_insert(LNode*& L)
{
    L = (LinkList)malloc(sizeof(LNode));//头结点
    L->next = NULL;
    ElemType x;
    scanf("%d", &x);
    //r是一个指针，s也是一个指针变量
    LNode* s, * r = L;//L始终指向头结点，r现在也指向头结点
    while (x != 9999)
    {
        s = (LinkList)malloc(sizeof(LNode));//申请新节点，实际上s指向的就是这块空间的首地址
        s->data = x;
        r->next = s;//r始终指向链表尾部，把新节点连接到尾结点的next
        r = s;//s指向新节点
        scanf("%d", &x);
    }
    r->next = NULL;//
}

// 5. 打印链表
void print_list(LinkList L)
{
    L = L->next;
    while (L != NULL)
    {
        printf("%3d", L->data);
        L = L->next;
    }
    printf("\n");
}

//4.按位置查找
LinkList GetElem(LinkList L, int SearchPos)
{
    int j = 0;
    //判断不合法情况
    if (SearchPos < 0)
    {
        return NULL;
    }
    while (L && j < SearchPos)
    {
        L = L->next;
        j++;
    }
    return L;
}
//3. 按值查找
LinkList LocateElem(LinkList L, ElemType SearchVal)
{
    while (L)
    {
        if (L->data == SearchVal)
        {
            return L;
        }
        L = L->next;
    }
    return NULL;
}
//5. 插入一个元素
bool ListFrontInsert(LinkList L, int i, ElemType InsertVal) //第i个位置
{
    LinkList p = GetElem(L, i - 1); // 利用了按位查找的函数，首先保证该位置的合法性
    if (NULL == p)
    {
        return false;
    }
    LinkList q;
    q = (LinkList)malloc(sizeof(LNode));//为新插入的节点申请空间
    q->data = InsertVal;
    q->next = p->next; //p指针就是插入位置前一个位置
    p->next = q;
    return true;
}


int main() {
    LinkList L, search;
//    list_head_insert(L);
    list_tail_insert(L);
    print_list(L);
//    search=GetElem(L,2);
//    if(search!=NULL)
//    {
//        printf("Succeeded in searching by serial number\n");
//        printf("%d\n",search->data);
//    }
//    search=LocateElem(L,6);
//    if(search!=NULL)
//    {
//        printf("Search by value succeeded\n");
//        printf("%d\n",search->data);
//    }
    bool ret;
    ret = ListFrontInsert(L, 4, 99);
    print_list(L);
    return 0;
}
蛋黄液
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】C语言实现顺序链表
东东里个乖乖
12-24 3008
这是在上数据结构课程时候的练习，贴出来做备忘。 #include #include #include #include #include typedef int elemtype; #define TRUE 0 #define FALSE 1 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #if(1) typed
C语言来实现链表创建
热门推荐
xinzhilinger的博客
10-11 3万+
前言 链表是数据结构中很重要的内容，要想学会数据结构，首先要了解链表 链表的基本知识 1，链表的构成 链表是由一个头指针和一个个节点构成的，如图： 而节点则是一个个结构体，包含数据域和指针域两部分，其中，指针域存储的是指向下一个节点的指针 2，对于链表的操作 1，创建链表 2，初始化链表 3，遍历链表 4，对于链表进行增删查等操作 C语言对于链表的代码的实现 1，创建结构体并命名 创建链表前需要先创建结构体作为节点和头指针： typedef struct Node //typedef方法函数可以对于st
（C语言）顺序表和链表
博主qq1077644249
08-09 677
线性表（linear list）是n个具有相同特性的数据元素的有限序列。顺序表、链表、栈、队列、字符串。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。静态顺序表：使用定长数组存储元素。动态顺序表：使用动态开辟的数组存储。......
数据结构之顺序表、链表（C语言实现）
weixin_43552133的博客
05-19 1575
1、顺序表2.1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为：1. 静态顺序表：使用定长数组存储。2. 动态顺序表：使用动态开辟的数组存储。在C语言中,我们将用结构体来实现我们的顺序表。 现在让我们来一一实现吧！ 顺序表的静态存储 #define N 100 为了方便以后修改顺序表的长度,我们将顺序表的长度作为宏定义. typedef int SLDataType; 因为顺序表存储的类型是不确定的,因此
数据结构（C语言版-顺序表和链表）
代码笔记本
11-20 1389
1.顺序表和链表 线性表 顺序表 链表 顺序表和链表的区别和联系 1.静态顺序表 #pragma once #define N 1000 typedef double SLDataType //静态顺序表 typedef struct SeqList{ SLDataType a[N]; int size; //表示数组中存储了多少个函数 }SL; ///接口函数 ---命名风格跟着STL void SeqInit(SL* ps); //静态特点：如果满了就不让插入 缺点
C语言之顺序表&单链表
Ja_king_的博客
06-26 880
一、顺序表的创建、删除和插入 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> struct sqlist { int date[10]; int length; }; void InitList(sqlist& L) { for (int i = 0;i < 10;i++) { L.date[i] = 0; } L.length = 0; } void charu(sqlist& L) { for (i
数据结构-C语言描述（顺序表、链表）
最新发布
04-01
### 数据结构-C语言描述（顺序表、链表） #### 实验背景 本次实验的主要目的是让学生通过C语言实现顺序表和链表的相关操作，加深对这两种基本数据结构的理解，并掌握其在实际编程中的应用技巧。 #### 实验目的 1...
C语言链表和顺序表基本操作的头文件
03-20
链表顺序表的增删改查
链表(c语言),c语言链表(c语言链表详解)
weixin_33034073的博客
05-21 1812
用建构体定义 struct Node { 结构体的成员 struct Node *link; }在C语言中，什么是链表呀？希望可以举例说明一下 谢谢啦链表由一系列结点(链表中每一个元素称为结点)组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地.什么是链表、书上的定义太复杂、能用通俗易懂的话解释下么~顺便用一段代.struct node { ...
C语言自学链表，单向链表，双向链表，适合新手学习。
06-18
由于链表的节点不连续存储，所以访问链表元素时需要从头节点开始按顺序遍历。单向链表的特点是只能向前遍历，不能像数组那样随机访问。常见的单向链表操作包括创建、插入、删除节点以及遍历链表。 - **创建链表**...
C语言链表排序操作
06-29
链表创建、排序操作
C语言 数据结构 顺序表和链表
CR7lmz的博客
07-27 517
一、线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 二、顺序表 顺序表一般可以分为： 1. 静态顺序表：使用定长数组存储。 2. 动态顺...
[数据结构]C语言实现顺序表、链表
weixin_51062241的博客
11-26 1505
实现顺序表、无头单向链表、双向带头循环链表的增删查改的接口功能
链表和顺序表（参考stl源码，使用c语言实现）
编程爱好者的博客
09-29 968
顺序表 优点：可以随机访问，cpu高速缓存利用率高，不涉及（较少）进行插入和删除操作，应该使用顺序表。 顺序表，不论是动态开辟，还是固定大小，一般放置在栈上，不用程序员手动开辟空间   链表：主要运用2种，A单向不带头结点的非循环链表      B双向带头结点的循环链表 特点是，由程序员手动开辟空间，存放在堆上。 频繁的插删时，应该使用链表。   以链表代码为例 结构体： t...
C语言实现顺序表
weixin_34007886的博客
04-07 148
顺序表是C语言中一种基本的结构，可以存储各种基本类型的数据，而且不但可以存储基本类型的数据，也可以存储一种结构。所以顺序表是一种在学C的过程中必须掌握的结构，通过学习整理，下面来实现一下： 首先，先要想好用什么实现，一般实现最基本的顺序表的话直接用数组实现，我们在这用一个结构体来封装这个顺序表（封装这一概念是在C++中最常用的概念）#defineARRAY_EMPTY...
C语言实现顺序链表
大鹰的天空
07-24 922
1 概念：指用一个连续的地址来存储数据元素。结构类似数组2 设计与实现:a 设计要素：1）插入元素算法 判断线性表是否合法 判断插入位置是否合法 把最后一个元素到插入位置的元素后移一个位置 将新元素插入后线性表长度加1 b 实现代码：#include "stdio.h" #include "stdlib.h" #include "string.h"#include "seqlist.h"typede
顺序链表C语言实现
zcg_741454897的博客
11-04 3348
顺序链表没什么说的啦，直接上代码，参考了传智播客出版的数据结构。创建工程的时候不小心弄成c++了，不过没关系，都一样。 Operation中有一处语法上的疑惑，就是插入的那个函数中，node为什么要强制转换成整型，既然等式两边都是指针，为什么不是转化成int* ，有心人帮忙解答一下，谢谢。 SeqList.h头文件 #ifndef _SEQLIST_H_ #define _SEQLIST_...
C语言有序链表
SunNang的博客
11-11 770
/* Note:Your choice is C IDE */ #include "stdio.h" #include "stdlib.h" //结构体 typedef struct n { //数据域 union { char ch; int len; }; //指针域 struct n *next; }list; //创建头结点函数 list *cj() { list *h=malloc(sizeof(list));//申请结点空间 if(h!=NULL) { h-&.
C语言详解：链表基础与操作
3. 插入操作：在给定的两个结点之间插入新的结点，这涉及更新指针，确保链表的顺序和链接关系保持正确。 4. 删除操作：移除指定结点，调整前后结点的指针以保持链表连续。删除头结点时可能需要特殊处理，因为没有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值