初识数据结构——链表和顺序表（C语言）

于 2024-05-15 19:36:03 发布
阅读量821 收藏 15
点赞数 39
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shi_ki2/article/details/138822090
版权

        早在我们用C语言写出“hello world！”这一程序之前，就听到老师说，程序=数据结构+算法，那么什么是数据结构呢？下面我们便来了解一下：

        数据结构顾名思义就是数据在计算机中的存储结构，当然数据结构有很多种（线性结构，树状结构，网状结构），今天我们只介绍最基础的两种线性结构——顺序表和链表

        1.顺序表

        1.1顺序表和数组的关系

  • 顺序表的底层结构其实就是数组，我们对数组进行封装，实现常用的增删查改等接口便是顺序表

        1.2顺序表分类        

                1.2.1 静态顺序表：使用定长数组存储元素，如下

       静态顺序表的缺点显而易见：空间给少了不能用，给大了浪费，用的不多，我们就先不实现

                1.2.2动态顺序表

动态顺序表是我们以后比较常用的，所以我们接下来便来实现一下

1.3动态顺序表的实现

下面是我们要实现的几个常用接口：


typedef int SLDataType;

typedef struct SeqList {

	int* arr; 

	int size;//有效数据个数
	int capacity;//空间容量
}SL;
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
//打印
void SLPrint(SL* ps);
//扩容
void SLCheckCapacity(SL* ps);

//头部插入删除 / 尾部插入删除
void SLPushBack(SL* ps, SLDataType x);
void SLPopBack(SL* ps);
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);

//指定位置之前插入/删除数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
int SLFind(SL* ps, SLDataType x);
1.3.1动态顺序表的初始化、销毁和打印

        这部分内容比较简单直接附上代码

//初始化
void SLInit(SL* ps){
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}
//销毁
void SLDestroy(SL* ps){
    assert(ps);
    if(ps->arr){
        free(ps->arr);
    }
    ps->arr = NULL;
    ps->size = ps->capacity = 0;
}
//打印
void SLPrint(SL* ps){
    assert(ps);
    for (int i = 0; i < ps->size; ++i) {
        printf("%d ",ps->arr[i]);
    }
    printf("\n");
}

动态顺序表初始化的时候可以申请空间，也可以不申请空间，我在这里没有申请

1.3.2检查内存是否够用，不够用就扩容
void SLCheckcapCity(SL * ps)

{
	if (ps->capacity == ps->size){
		SLDotaType* ptr;
        //在这里用三目操作符来防止传过来的顺序表的内存空间为零
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		ptr = (SLDotaType*)realloc(ps->arr, newcapacity * sizeof(SLDotaType));
		if (ptr == NULL){
			perror(realloc);
			exit(1);
		}
        ps->arr = ptr;
		ps->capacity = newcapacity;
	}
}
1.3.4尾部和头部的 插入\删除

         尾插和尾删较为简单，尾插就直接在顺序表后面插入数据再令顺序表的size++就好，尾删直接令size--就好了，我们直接看代码

void SLPushback(SL* ps, SLDotaType x){
    //先断言
    assert(ps);
	SLCheckcapCity(ps);
    ps->arr[ps->size++]=x;
}
void SLPopback(SL* ps){	
    assert(ps);
	assert(ps->size);
	--ps->size;
}

而头插和头删则需要我们将顺序表中的数据向后或者向前移，如图我们想在1的前面插入一个6，我们则需要将1~5这五个元素向后移一个单位

类比一下我们想要删除1则需要2~5这四个元素向右移一个单位 代码如下：

void SLPushFront(SL*ps,SLDotaType x){
	assert(ps);
    SLCheckcapCity(ps);
	for (int i=ps->size;i>0;i--){
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}
void SLPopFront(SL* ps){
	assert(ps);
	assert(ps->size);
	for (int i = 0; i < ps->size-1; i++)	{
		ps->arr[i] = ps->arr[i + 1];
	}
	--ps->size;
}
1.3.5指定位置之前的插入和删除

        我们把前面介绍的头插头删理解了这部分其实就没什么问题了，其实就相当于我们把指定位置当作顺序表的“头”，对它进行头插头删就行了

void SLInsert(SL* ps, int pos, SLDataType x){
    assert(ps);
    assert(pos <= ps->size && pos >= 0);
    SLCheckCapacity(ps);
    for (int i = ps->size; i > pos; --i) {
        ps->arr[i] = ps->arr[i-1];
    }
    ps->arr[pos] = x;
    ++ps->size;
}
void SLErase(SL* ps, int pos){
    assert(ps);
    assert(pos < ps->size && pos >= 0);
    for (int i = pos; i < ps->size-1; ++i) {
        ps->arr[i] = ps->arr[i+1];
    }
    --ps->size;
}
int SLFind(SL* ps, SLDataType x){
    assert(ps);
    for (int i = 0; i < ps->size; ++i) {
        if(ps->arr[i] == x ){
            return i;
        }
    }
    return -1;
}

2.链表

        2.1什么是链表？

        链表就像是一列火车，车厢里存数据，车厢和车厢之间用链子相连。这里的车厢就是链表的结点，那么链子是什么呢？当然是指针啦！那么我们链表节点的就可以这样声明：

 那么链表的物理结构应该是这个样子的（尾节点的next要指向NULL否则就会成为野指针）

当然这只是单向不循环链表下面我们便来看看链表的分类

        2.2链表的分类

链表有三种结构可选分别是：带头和不带头、单向还是双向、循环还是不循环，两两组合可以形成八种链表如下图

我们在网上刷题遇到的链表为往往是单向不带头不循环链表，简称单链表，那么我们今天就来实现一下单链表的基础功能

        2.3链表的实现

常用接口和顺序表差不多,不过值得注意的是，和顺序表不同，我们的链表的常用功能大都是通过修改指针的指向来完成的，所以我们传参时的实参要是指针的地址，用来接收实参的形参便要设计成二级指针，由于链表是一个一个节点串起来的，所以我们不必初始化，也不必担心内存问题

具体如下：

typedef int SLTDataType;
typedef struct SListNode{
    SLTDataType val;
    struct SListNode* next;
}SLTNode;


void SLTPrint(SLTNode* phead);

//头部插入删除/尾部插入删除
void SLTPushBack(SLTNode** pphead, SLTDataType x);
void SLTPushFront(SLTNode** pphead, SLTDataType x);
void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//销毁链表
void SListDesTroy(SLTNode** pphead);
         2.3.1尾部和头部的 插入\删除

        开始之前我们先来实现一个开辟新节点的函数：

//节点创建

SLTNode* BuyNode(SLTDataType x){
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode==NULL){
		perror(malloc);
		exit(1);
	}
	newnode->Data = x;
	newnode->next = NULL;
	return newnode;
}

    头插和头删较为简单，我们只需要创建一个新节点让新节点的next指针指向头节点，再让*pphead指向新节点就好了，类推一下头删的方法就是新建一个指针prve来记录头节点的next的位置，随后释放掉头节点，再让指向头节点的指针指向prve，如下：

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x){
	assert(pphead);
	SLTNode* newnode = (SLTNode*)BuyNode(x);
	if (*pphead == NULL){
		*pphead = newnode;
	}
	else{
		newnode->next = *pphead;
		*pphead = newnode;
	}
}
//头删

void SLTPopFront(SLTNode** pphead){
	assert(pphead && *pphead);
	SLTNode* prve = (*pphead)->next;
	free(*pphead);
	*pphead = prve;
}

       尾部的插入和删除则需要先找到链表的尾巴在哪里，然后尾插直接让尾节点的next指向新节点就好了，尾删则需要用一个指针来记录尾节点的前一个节点也就是新的尾节点，释放掉尾节点后要将新的尾节点的next置空，否则会出现野指针，代码如下：

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x){
	assert(pphead);
	SLTNode* newnode = BuyNode(x);
	if (*pphead == NULL){
		*pphead = newnode;
	}
	else{
		//找尾
		SLTNode* pcur = *pphead;
		while (pcur->next){
			pcur = pcur->next;
		}
		pcur->next = newnode;
	}
}
//尾删
void SLTPopBack(SLTNode** pphead){
	assert(pphead&&*pphead);
	if ((*pphead)->next == NULL){
		free(*pphead);
		*pphead = NULL;
	}
	else {
		SLTNode* prve = *pphead, * ptail = *pphead;
		while (ptail->next){
			prve = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		prve->next = NULL;
	}
}
        2.3.2查找元素和指定位置之前和之后的插入

查找元素：

//查找

SLTNode* SLTFind(SLTNode* phead, SLTDataType x){
	SLTNode* pcur = phead;
	while (pcur){
		if (pcur->Data == x){
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}
  • 指定位置之前的插入

要实现在指定位置之前插入数据，我们便需要找到指定位置的前一个节点，新建一个指针prve记录该节点的next指向的位置，让后让该节点的next指向新节点，再让新节点的next赋值为prve。如下：

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)

{
	assert(pphead && *pphead);
	assert(pos);
	if (*pphead == pos)	{
		SLTPushFront(pphead, x);
	}
	else{
		SLTNode* newnode = (SLTNode*)BuyNode(x);
		SLTNode* prve = *pphead;
		while (prve->next != pos){
			prve = prve->next;
		}
		newnode->next = pos;
		prve->next = newnode;
	}	
}
  • 指定位置之后的插入

指定位置之后插入数据就简单了，我们秩序让新节点的next和该节点的next相等，再让该节点的next指向新节点就好了，如下

void SLTInsertAfter(SLTNode* pos, SLTDataType x){
	assert(pos);
	SLTNode* newnode = (SLTNode*)BuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
        2.3.3删除指定位置的节点&删除指定位置之后的节点

和插入差不多，指定位置节点的删除也要找到指定位置之前一个节点，让之前的节点指向之后的节点，将该节点的next指针置空后将该节点free掉就完成了，删除指定位置之后的节点就没那么麻烦，我们只需要新建一个指针prve指向该节点往后两个节点，随后将该节点下一个节点的next置空，随后将该节点的next free掉，然后将prve赋给该节点的next完成了

//删除pos节点

void SLTErase(SLTNode** pphead, SLTNode* pos)

{
	assert(pphead && *pphead);
	SLTNode* plist = *pphead;
	if (plist == pos){
		plist = (*pphead)->next;
		*pphead = plist;
	}
	else{
		while (plist->next != pos){
			plist = plist->next;
	}
		plist->next = pos->next;
	}
	free(pos);
	pos = NULL;
}

//删除pos之后的节点

void SLTEraseAfter(SLTNode* pos)

{
	assert(pos);
	if (pos->next == NULL){
		return;
	}
	else{
		SLTNode* prve = pos->next->next;
		free(pos->next);
		pos->next = prve;
	}
}
        2.3.4链表的销毁

这个没啥好说的，while循环遍历删除每一个节点就好了

void SListDesTroy(SLTNode** pphead)
{
	assert(pphead&&*pphead);
	SLTNode* prve = *pphead;
	SLTNode* pcur = *pphead;
	while (prve->next!=NULL){
		prve = prve->next;
		free(pcur);
		pcur = prve;
	}
	*pphead = NULL;
}

好的！今天的学习就到此为止吧！

蒲公英派
关注
  • 39
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
（C语言）顺序表和链表
博主qq1077644249
08-09 655
线性表（linear list）是n个具有相同特性的数据元素的有限序列。顺序表、链表、栈、队列、字符串。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。静态顺序表：使用定长数组存储元素。动态顺序表：使用动态开辟的数组存储。......
【C语言基础】顺序表、链表
m0_51490933的博客
01-25 305
单链表
数据结构（C语言版-顺序表和链表）
代码笔记本
11-20 1378
1.顺序表和链表 线性表 顺序表 链表 顺序表和链表的区别和联系 1.静态顺序表 #pragma once #define N 1000 typedef double SLDataType //静态顺序表 typedef struct SeqList{ SLDataType a[N]; int size; //表示数组中存储了多少个函数 }SL; ///接口函数 ---命名风格跟着STL void SeqInit(SL* ps); //静态特点：如果满了就不让插入 缺点
链表和顺序表（参考stl源码，使用c语言实现）
编程爱好者的博客
09-29 964
顺序表 优点：可以随机访问，cpu高速缓存利用率高，不涉及（较少）进行插入和删除操作，应该使用顺序表。 顺序表，不论是动态开辟，还是固定大小，一般放置在栈上，不用程序员手动开辟空间   链表：主要运用2种，A单向不带头结点的非循环链表      B双向带头结点的循环链表 特点是，由程序员手动开辟空间，存放在堆上。 频繁的插删时，应该使用链表。   以链表代码为例 结构体： t...
C语言——顺序表和单链表的逆置
qq_40596811的博客
09-09 6531
顺序表的逆置 #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #define MAX 100 typedef struct node { int num[MAX]; int length; } *Link, Node; void reverse(int * num, int length) { int i = 0; ...
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
C语言——链表的归并_c语言链表详解
12-21
用c语言写链表归并
数据结构——用现有链表转换为顺序表
06-26
用链表创建顺序表，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
数据结构-C语言描述（顺序表、链表）
最新发布
04-01
水一下学校的实验报告，注释没有认真写，勿喷。
算法和数据结构——链表.pdf
08-07
#资源达人分享计划#
数据结构——C语言实现 顺序表和链表代码
ZhangJiawen的博客
10-25 2741
今天敲了一下数据结构中顺序表的代码，发现C语言好久不用真的忘得差不多了。代码都是可以直接运行的（我的运行环境是Dev）。如果有写错的地方，欢迎大家留言一起讨论。 对这一部分概念的介绍可以参考这篇博客：数据结构中的顺序表 下来就直接看代码吧 #include<stdio.h> #define MAXSIZE 100 typedef struct{ int elem[MAXSIZE]; int length; }SeqList; //初始化 void Init_SeqList(SeqLis
C语言顺序表和链表内容
薛定谔猫猫
04-09 408
1顺序表: 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储 顺序表中的问题: 1. 中间/头部的插入删除，时间复杂度为O(N) 2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。 3. 增容一般是呈2倍的增长，...
数据结构 | 1.顺序表与链表
明朗晨光的专栏
09-07 926
1、顺序表 顺序表是一种更为高级的数组。 数组的特点：一片连续的存储空间，存储相同类型的元素。 顺序表可以存储任意类型的元素，但是一个顺序表只能存储同一种类型的元素。 1.1 初版代码实现 #include <stdio.h> #include <time.h> #include <stdlib.h> //顺序表结构定义 typedef struct Vector { int *data; //连续的存储空间 int size; //顺序表可容纳的总元
C语言单链表和顺序表的基本操作
BO688的博客
09-28 2183
笔者当初学的时候不熟悉结构，很容易出错 因为本人不是专学C，所以有些知识不是很懂 顺序表 typedef struct{ ElemType *elem; //存储空间的基地址 int length; //当前长度 }SqList; 顺序表结构比较简单，只需要在一个结构体中，加入一个数组，和一个表示数组长度的数 *elem 的意思是指向一个地址==指针 所有的操作都基于结构体中的数组和长...
C语言：顺序表以及单链表
weixin_55797565的博客
10-28 1115
实验题目：线性表的基本操作 实验环境：Visual Studio 实验目的： 1、掌握线性表的定义； 2、掌握线性表的基本操作，如建立、查找、插入和删除等。 实验内容： 定义一个包含学生信息（学号，姓名，成绩）的顺序表和链表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回...
顺序表、单链表——C语言实现及其比较
chunzhi5303的博客
02-09 653
（一）顺序表的实现 顺序表的存储结构定义 #define MaxSize 100 typedef int DataType; typedef struct { DataType data[MaxSize]; //存储数组 int length; //顺序表的长度 } seqList; ...
顺序表与链表
lipengfei0427的博客
07-10 6797
一、顺序表和链表的比较 1.存取方式 顺序表可以顺序存取，也可以随机存取，链表只能从表头顺序存取元素。 2.逻辑结构与物理结构 顺序存储时，逻辑上相邻的元素，对应的物理存储位置也相邻； 链式存储时，逻辑上相邻的元素，物理存储位置不一定相邻，其逻辑关系是通过指针链接来表示的。 3.查找、插入和删除操作 对于按值查找，顺...
【数据结构】顺序表和单链表(C语言版)
weixin_62007227的博客
02-24 1368
一篇文章让你搞懂单链表的基本操作[通过图画轻松掌握] 前言 提示：本篇记录自学《大话数据结构》的链表章节 主要是代码的理解，不会出现很多概念定义 一、顺序存储之顺序表 定义 顺序表也叫(顺序存储结构) ，是一种用一段地址连续的存储单元依次存储线性表的数据元素。 顺序表的示意图 二、线性表的顺序存储结构 #define Max_sz 20 /代表数组最大容量 ty.
线性表的概念及实现方式——顺序表和链表
线性表的实现方式主要有顺序存储结构和链式存储结构两种，分别称为顺序表和链表。 在本章中，我们首先学习了线性表的逻辑结构特性，即数据元素之间的线性逻辑关系。然后，我们详细讨论了顺序表和链表两种实现方式在...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值