线性表详解（代码演示）

已于 2022-05-08 18:49:31 修改
阅读量468 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 c算法 c语言 链表
于 2022-04-26 21:27:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Guqing_f/article/details/124437636
版权

1.顺序表

顺序表是指用一段连续的地址，依次存放数据元素的线性数据结构，这种存储方式使得顺序表的物理结构与逻辑结构都是连续的。

q1：这和平时再函数中定义的数组有什么区别？

ans1：函数中的数组被存放在栈段中，而栈段有系统限制的大小【ulimit -s】。因此顺序表往往使用再堆段中操作管理动态数组的方式实现。

（1）管理结点

如果把数据结构比作仓库，数据元素比作货物，除了货物之外，还应该有货物的数量，货架的数量等信息。要体现这些信息，就需要“管理结点”。

eg：

​ 顺序表中，管理结点内部一般存放：数据域地址(*data)、总容量(size)、当前数据量(len)

顺序表的基本实现代码：

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

typedef struct Vector{
    int *data; //数据域指针
    int total; //总容量
    int len; //当前容量
} Vector;

Vector *initVector(int total){
    //初始化管理结点
    Vector *v = (Vector *)malloc(sizeof(Vector));
    //初始化数据域
    v->data = (int *)malloc(sizeof(int) * total);
    v->len = 0; //当前容量为0
    v->total = total; //设置总容量
    return v;
}

//在data[idx] 处插入x
void insert(Vector *v, int idx, int val){
    if(!v) return ;
    if(idx > v->len || idx < 0) return ;
    if(v->len == v->total) return ; //满了
    //元素移动
    for(int i = v->len; i > idx; i--){
        v->data[i] = v->data[i - 1];
    }
    v->data[idx] = val; //真正的插入
    ++ v->len; //更新管理结点
}

void delete(Vector *v, int idx){
    if(!v) return ;
    if(idx >= v->len || idx < 0) return ;
    for(int i = idx; i < v->len; i++){
        v->data[i] = v->data[i + 1];
    }
    -- v->len;
}

int isEmpty(Vector *v){
    return !v || (v->len == 0);
}

void printVector(Vector *v){
    for(int i = 0; i < v->len; i++){
        printf("%d ", v->data[i]);
    }
    printf("\n----------------------\n");
}

int main(){
    Vector *v = initVector(100);

    for(int i = 0; i < 10; i++){
        insert(v, i, i);
    }
    printVector(v);
    insert(v, 3, 100);
    printVector(v);
    insert(v, 5, 200);
    printVector(v);
    delete(v, 10);
    printVector(v);


    return 0;
}

（2）顺序表的扩容

当进行插入时，顺序表满，就进行扩容。一般扩容规则：倍增（2*size）

int expend(Vector *v){
    int exTotal = v->total;
    int *temp;
    while(exTotal){
        //尝试重新申请空间
        temp = (int *) realloc (v->data, sizeof(int*) * (v->total + exTotal));
        if(temp) break; //申请成功
        exTotal >> 1; //不行就减半
    }
    if(!temp) return 0; //申请失败
    //维护管理结点
    v->data = temp;
    v->total += exTotal;
    return 1;
}

void insertWithExtend(Vector *v, int idx, int val){
    if(!v) return ;
    if(idx > v->len || idx < 0) return ;
    if(v->len == v->total) {
        if(!expend(v)) return ;//尝试扩容

    }
    //元素移动
    for(int i = v->len; i > idx; i--){
        v->data[i] = v->data[i - 1];
    }
    v->data[idx] = val; //真正的插入
    ++ v->len; //更新管理结点
}

2.链表

链表是一种物理结构不连续，但是可以依靠结点中的指针实现逻辑结构连续的先行数据结构。

构成链表的数据元素被称为“结点”，结点内部存放数据和指向下一个结点的指针，只有单一结点的指针的链表是单链表。

链表的管理结点一般仅需要存放头结点指针(*head)

如果需要频繁获取链表长度，管理节点中可以额外存放链表长度(len)

（1）头插法和尾插法：

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

typedef struct Node{
    int val;
    struct Node *next;
} Node;

Node *initNode(int val){
    Node *node = (Node *) malloc (sizeof(Node));
    node->val = val;
    node->next = NULL;
    return node;
}

typedef struct List{
    Node *head;
    int len;
} List;

List *initList(){
    List *l = (List *) malloc (sizeof(List));
    l->head = NULL;
    l->len = 0;
    return l;
}

void insertToHead(List *list, int val){
    if(!list) return ;
    Node *node = initNode(val);
    node->next = list->head;
    list->head = node;
    ++ list->len;
}

void insertToTail(List *list, int val){
    if(!list) return ;
    Node *node = initNode(val);
    if(!list->head){ //如果链表为空
        list->head = node;
        ++list->len;
        return ;
    }
    Node *p = list->head;
    while(p->next){
        p = p->next;
    }
    p->next = node;
    ++ list->len;
}

void printList(List *list){
    Node *p = list->head;
    while(p){
        printf("%d ", p->val);
        p = p->next;
    }
    printf("\n----------------------\n");
}

int main(){
    List *l = initList();
    for(int i = 0; i < 3; i++){
        insertToHead(l, i);
    }
    for(int i = 3; i < 8; i++){
        insertToTail(l, i);
    }
    printList(l);
    for(int i = 8; i < 10; i++){
        insertToHead(l, i);
    }
    printList(l);
    
    return 0;
}

（2）在任意位置插入和删除：

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

typedef struct Node{
    int val;
    struct Node *next;
} Node;

Node *initNode(int val){
    Node *node = (Node *) malloc (sizeof(Node));
    node->val = val;
    node->next = NULL;
    return node;
}

typedef struct List{
    Node *head;
    int len;
} List;

List *initList(){
    List *l = (List *) malloc (sizeof(List));
    l->head = NULL;
    l->len = 0;
    return l;
}

void insertToHead(List *list, int val){
    if(!list) return ;
    Node *node = initNode(val);
    node->next = list->head;
    list->head = node;
    ++ list->len;
}

void insertToTail(List *list, int val){
    if(!list) return ;
    Node *node = initNode(val);
    if(!list->head){ //如果链表为空
        list->head = node;
        ++list->len;
        return ;
    }
    Node *p = list->head;
    while(p->next){
        p = p->next;
    }
    p->next = node;
    ++ list->len;
}

void printList(List *list){
    Node *p = list->head;
    while(p){
        printf("%d ", p->val);
        p = p->next;
    }
    printf("\n----------------------\n");
}

//在编号为idx的位置插入值为val的点
void insert(List *list, int idx, int val){
    if(!list) return ;
    if(idx > list->len || idx < 0) return ;
    if(idx == 0) {
        insertToHead(list, val);
        return ;
    }
    Node *node = initNode(val);
    Node *p = list->head;
    for(int i = 0; i < idx - 1; i++){
        p = p->next;
    }
    node->next = p->next;
    p->next = node;
    ++ list->len;
}

void freeNode(Node *node){
    if(!node) return ;
    free(node);
    return ;
}

//删除编号为idx的结点
void delete(List *list, int idx){
    if(!list) return ;
    if(idx >= list->len || idx < 0) return ;
    if(idx == 0){
        list->head = list->head->next;
        -- list->len;
        return ;
    }
    Node *p = list->head;
    for(int i = 0; i < idx - 1; i++){
        p = p->next;
    }
    Node *node = p->next;
    p->next = p->next->next;
    freeNode(node);
    -- list->len;
    return ;
}

int main(){
    List *l = initList();
    for(int i = 0; i < 5; i++){
        insertToTail(l, i);
    }
    printList(l); //0 1 2 3 4

    insert(l, 3, 100);
    printList(l); // 0 1 2 100 3 4
    insert(l, 0, 200);
    printList(l); // 200 0 1 2 100 3 4

    delete(l, 0);
    printList(l); //0 1 2 100 3 4
    delete(l, 5);
    printList(l); //0 1 2 100 3
    
    return 0;
}

（3）虚头结点

在需要特殊处理头结点的时候，可以实现一个带有虚头结点的链表，在链表初始化或在某些操作执行时，将一个额外的结点放在头指针执行的地方。

虚头结点可以使得整个链表永远不空，永远有头，所以拥有虚头结点的链表在处理各类头结点操作时会更加便捷。

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

typedef struct Node{
    int val;
    struct Node *next;
} Node;

Node *initNode(int val){
    Node *node = (Node *) malloc (sizeof(Node));
    node->val = val;
    node->next = NULL;
    return node;
}

typedef struct List{
    Node *head;
    int len;
} List;

List *initList(){
    List *l = (List *) malloc (sizeof(List));
    l->head = initNode(0);
    l->len = 0;
    return l;
}

void insertToHead(List *list, int val){
    if(!list) return ;
    Node *node = initNode(val);
    node->next = list->head->next;
    list->head->next = node;
    ++ list->len;
}

void insertToTail(List *list, int val){
    if(!list) return ;
    Node *node = initNode(val);
    Node *p = list->head;
    while(p->next){
        p = p->next;
    }
    p->next = node;
    ++ list->len;
}

void printList(List *list){
    Node *p = list->head->next;
    while(p){
        printf("%d ", p->val);
        p = p->next;
    }
    printf("\n----------------------\n");
}

//在编号为idx的位置插入值为val的点
void insert(List *list, int idx, int val){
    if(!list) return ;
    if(idx > list->len || idx < 0) return ;
    Node *node = initNode(val);
    Node *p = list->head->next;
    for(int i = 0; i < idx - 1; i++){
        p = p->next;
    }
    node->next = p->next;
    p->next = node;
    ++ list->len;
}

void freeNode(Node *node){
    if(!node) return ;
    free(node);
    return ;
}

//删除编号为idx的结点
void delete(List *list, int idx){
    if(!list) return ;
    if(idx >= list->len || idx < 0) return ;
    Node *p = list->head; //加上next循环就idx-1
    for(int i = 0; i < idx; i++){
        p = p->next;
    }
    Node *node = p->next;
    p->next = p->next->next;
    freeNode(node);
    -- list->len;
    return ;
}

int main(){
    List *l = initList();
    for(int i = 0; i < 5; i++){
        insertToTail(l, i);
    }
    printList(l); //0 1 2 3 4

    insert(l, 3, 100);
    printList(l); // 0 1 2 100 3 4
    insert(l, 0, 200);
    printList(l); // 200 0 1 2 100 3 4

    delete(l, 0);
    printList(l); //0 1 2 100 3 4
    delete(l, 5);
    printList(l); //0 1 2 100 3
    
    return 0;
}

要是对您有帮助，点个赞再走吧~ 欢迎评论区讨论~

Guqing_f
关注
专栏目录
数据结构 单向链表详解和代码演示
菜鸟心声：学的不仅是技术，更是梦想！
12-04 829
链表详解和代码演示链表1.链表的介绍1.1单链表的内存结构图：1.2单链表（带头节点）逻辑结构示意图2.单链表的应用实例2.1题目要求2.2思路分析2.2.1head节点：2.2.2添加：next指向heroNode (添加到最后)2.2.3按照编号的顺序添加：2.2.4单链表的修改2.3相关代码2.4结果展示2.5小结 链表 1.链表的介绍 链表是一种物理存储单元上非连续、非顺序的存储结构 数据元素的逻辑顺序是通过链表中的指针链接次序实现的 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行
操作系统：FIFO算法详解及代码演示
Zeker62的博客
05-16 1万+
FIFO算法 FIFO算法是最简单的页面置换算法。FIFO算法为每个页面记录了调到内存的时间。当必须置换页面的时候，选择最旧的页面。 通俗来说，每次进入主存的时候 如果主存中不存在这个页面，那么最先进入的页面出队。 如果主存存在这个页面，那么内存不动。 下面是C++面向对象写法代码。 这个说明一下为什么不用容器Queue。是因为queue并没有迭代器，所以无法去寻找里面是否含有某块页面。 直接使用线性表即可，方便简单且快速。 // 在分页式虚拟存储管理中，要求通过键盘输入分配给一个作业的物理块数和作业
线性表的实现全部代码
07-14
线性表的实现：建表、插入、删除、排序、查找等 可运行的代码
【数据结构】之 线性表详解
weixin_30664539的博客
02-10 638
线性表（Linear List） 基本概念 线性表是由n（n>=0）个类型相同数据元素组成的有限序列。数据元素可由若干个数据对象组成，且一个线性表中的数据元素必须属于同一数据对象。 线性表示n个类型相同数据元素的有限序列，对n>0,除第一个元素无直接前驱，最后一个元素无直接后继外，其余的每个数据元素只有一个直接前驱和直接后继。 线性表的逻辑结构如图： 线性表具有如下...
线性表的实现（C语言完整代码+详细注释版）【数据结构】
小賀のBlog
08-01 2万+
完整且健壮的两种线性表的表示代码 线性表的顺序表示： // // main.c // SQList // // Created by Eason on 2020/7/28. // Copyright © 2020 Eason. All rights reserved. // #include<stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define maxsize 100 typedef i
线性表c代码实现
10-22
该代码实现了线性表的顺序存储，包括创建线性表、删除线性表、清空线性表、插入元素、删除元素等API函数
线性表的经典实现代码
‎‎‎‎‎不想吃泡面
04-20 636
1.线性表的顺序存储结构   顺序存储结构即用一段连续的存储单元依次存储线性表示的数据元素。优缺点大家应该都知道，下面是实现主要功能的数据结构经典代码。 /** * 顺序存储结构的线性表 * anuthor:star sea * */ #include <cstdio> #define MAX_SIZE 20 #define OK 1 #define ERRO...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
文档中还提供了一些运行结果的例子，包括基本操作的验证和两个有序线性表合并成一个有序表的操作演示。这有助于读者更好地理解代码的实际运行效果，并可以用来验证自己的实现是否正确。 #### 五、注意事项 1. **...
线性表的顺序存储结构具体实现 代码实战 赛博图书馆搭建指南（使用C\C++语言）
m0_56661338的博客
04-05 642
完整地实现了用顺序表存储元素，并且通过将数据类型改为字符串结构体来搭建一个“赛博图书馆”，实现了顺序表的打印、插入元素、删除元素、查询元素，配以图文详解
二叉树详解
热门推荐
weixin_59371851的博客
07-09 5万+
目录前言一、树的概念和结构1、树的概念2、树的表示 3、树在实际中的应用（表示文件系统的目录树结构）二、二叉树概念及结构1.概念 2、特殊的二叉树3、二叉树的性质4、二叉树的存储4.1顺序存储4.2链状存储 三、二叉树的顺序结构和实现1、二叉树的顺序结构2、堆的概念及结构3、堆的实现3.1堆的代码框架3.2堆的插入3.3堆的删除3.4堆的建立 3.5建堆的时间复杂度 4、堆的应用4.1堆排序 4.2TOP-K问题四、二叉树链式结构的实现 1、建二叉树2、二叉树的遍历2.1前序、中序以及后序遍历2.2层序遍历
数据结构-线性表代码实现
03-20
线性表顺序存储代码实现
【数据结构】线性表 顺序存储结构
嗨Sirius
12-09 503
本文收录自【C语言数据结构】思想＋代码集】 文章目录【数据结构】线性表思想代码头文件及函数定义 SqList.h函数源码SqList.cppmain函数 【数据结构】线性表 思想 代码 头文件及函数定义 SqList.h /*============================= * 线性表的顺序存储结构（顺序表） * * 包含算法: 2.3、2.4、2.5、2.6 =======...
线性表的实现
振宇的博客
05-07 659
线性表
线性表的详解
gongjunbox的博客
12-04 9392
线性表是算法题命题的重点。这类算法题实现起来比较容易且代码量较少，但是要求具有最优的性能（时间复杂度、空间复杂度)，才能获得满分。因此，应牢固掌握线性表的各种基本操作（基于两种存储结构)，在平时的学习中多注重培养动手能力。另外，需要提醒的是，算法最重要的是思想!考场上的时间紧迫，在试卷上不一定要求代码具有实际的可执行性，因此应尽力表达出算法的思想和步骤，而不必过于拘泥每个细节。注意算法题只能用C/C++语言实现。
线性表详解
最新发布
qq_59293418的博客
04-19 1612
一篇博文带你了解线性表，
数据结构—线性表实现代码
进阶中的程序员吃吃的博客
05-18 778
顺序表：typedef int Position; typedef struct LNode *List; struct LNode {     ElementType Data[MAXSIZE];     Position Last; };   /* 初始化 */ List MakeEmpty() {     List L;     L = (List)malloc(sizeof(struct ...
线性表的源码分析
Jack11998的博客
07-14 279
线性表 在我们刚开始学习数据结构的过程中，往往是从数据结构的历史开始学起，然后是什么是算法，算法的特性等，接下来便是复杂度的分析。 因为写这个博客我的初衷是对每章的源码进行剖析，以便于自己能够更好的学习这门课，掌握其思想。在这里笔者只希望大家不要去死学数据结构。数据结构是一切算法的思想，它本身就非常有趣，当然也可以学的很开心。 顺序表 我来先讲一下顺序表的思想。 咱们举个例子来阐述，中学的时候大家应该都会做广播体操的吧，在做广播体操之前，我们往往会先排队，你的前面是谁，后面是谁，一般都是会固定好。
线性表代码的实现（最详细）
qq_53965368的博客
10-30 320
顺序表的存储结构 typedef struct List { int *date; int size; int length; }L; 构造线性表 void ListInit(L* ps) { ps->date = (int*)malloc(sizeof(L) * 4); if (ps == NULL) { cout << "创建失败" << endl; } else { cout << "创建成功"
线性表详解（c语言版）
坚持是一种品质
02-17 1833
放假回家第三天，接着复习。啦啦啦： 1. 线性表：线性表是最常用且最简单的一种数据结构，一个线性表就是若干个数据元素的有限序列。 2. 线性表的操作： - InitList（&L）构造一个空的线性表 - DestroyList（&L）销毁线性表 - ClearList（&L）清空线性表 - ListEmpty（L） 判断线性表是否为空 -
严蔚敏版数据结构算法代码详解：线性表与链表实现
这些代码提供了对严蔚敏版数据结构中线性数据结构理论的实践操作演示，有助于读者理解和掌握数据结构的基本操作，对于学习者来说，是编写和理解相关算法不可或缺的参考资料。在实际编程中，这些函数可以作为基础模块...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值