[数据结构] 1.顺序表与链表

最新推荐文章于 2024-10-12 20:00:42 发布
最新推荐文章于 2024-10-12 20:00:42 发布
阅读量281 收藏
点赞数
分类专栏： 初级数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44506866/article/details/109956816
版权

目录

0.数据结构

  1. 程序设计=算法+数据结构+编程范式

  2. 程序=算法+数据结构
    算法合理利用CPU的计算资源，数据结构合理利用存储资源

  3. 数据结构=结构定义+结构操作

  4. 如何学习一种新的数据结构？
    数据结构是定义一种性质并维护这种性质

⭐线性表：具有相同数据类型的N（N>=0）个数据元素的有序序列

1.顺序表

1.1定义

  1. 通过命令 ulimit -s 查看linux的默认栈空间大小，默认情况下为 8192 即8M

  2. 函数中定义的数组位于栈段

  3. 栈段存管理节点地址，管理节点、数据都在堆段

  4. 结构操作：增删改查
    ☞删除指当前内存可以被占用，不是真正意义上的删除，如果被覆写就找不回来了

1.2 代码演示

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

typedef struct Vector {
    int *data, size, length;
} Vec;

//堆区
Vec *initVec(int n) {
    Vec *v = (Vec *)malloc(sizeof(Vec));
    v->data = (int *)malloc(sizeof(int) * n);
    v->size = n;
    v->length = 0;
    return v;
}

void freeVec(Vec *v) {
    if (v == NULL) return ;
    free(v->data);
    free(v);
    return ;
}

int expand(Vec *v) {
    int expsize = v->size;
    int *temp;
    while (expsize) {
        temp = (int *)realloc(v->data, sizeof(int) * (v->size + expsize));
        if (temp) break;
        expsize >>= 1;
    }
    if (!temp) return 0;
    v->data = temp;
    v->size += expsize;
    printf("expand %d bytes successfully~\n", expsize);
    return 1;
}

int insert(Vec *v, int idx, int val) {
    if (!v) return 0;
    if (idx < 0 || idx > v->length) return 0;
    if (v->length == v->size) {
        if (!expand(v)) return 0;
    }
    //memcpy(dst, src, n); 一次拷贝不会覆盖丢失数据
    //重点：下标从0开始
    memmove(v->data + idx + 1, v->data + idx, sizeof(int) * (v->length - idx));
    v->data[idx] = val;
    v->length++;
    return 1;
}

int erase(Vec *v, int idx) {
    if (!v) return 0;
    if (idx < 0 || idx >= v->length) return 0;
    memmove(v->data + idx, v->data + idx + 1, sizeof(int) * (v->length - idx - 1));
    v->length--;
    return 1;
}

void showVec(Vec *v) {
    printf("Vec:[");
    if (v) {
        for (int i = 0; i < v->length; i++) {
            i && printf(",");
            printf("%d", v->data[i]);
        }
    }
    printf("]\n");
    return ;
}

int find(Vec *v, int val) {
    if (!v) return -1;
    for (int i = 0; i < v->length; i++) {
        if (v->data[i] == val) return i;
    }
    return -1;
}

int main() {
    Vec *v = initVec(2); //栈区
    srand(time(0));
    int cnt = 10;
    while (cnt--) {
        int opt = rand() % 4;
        int val = rand() % 100;
        int idx = rand() % (v->length + 3) - 1; // [-1, v->length + 1]
        switch (opt) {
            case 0:
            case 1:
            case 2:
                printf("insert %d at %d, res = %d\n", val, idx, insert(v, idx, val));
                break;
            case 3:
                printf("erase at %d, res = %d\n", idx, erase(v, idx));
                break;
        }
        showVec(v);
    }
    insert(v, 1, 68);
    printf("find 68 at %d\n", find(v, 68));
    freeVec(v);
    return 0;
}

  1. 动态申请内存使用 alloc 一族，配对使用 free 释放内存，避免内存泄露

  2. void *malloc(size_t size)开辟空间不清空
    void *calloc(size_t nitems, size_t size)开辟空间并清空
    void *realloc(void *ptr, size_t size)智能地开辟一段空间

  3. realloc(src,size)

    1. 在原空间src后扩建，成功后返回src；
    2. 原地址扩建失败后申请新空间，成功后顺序拷贝原空间，自动 free(src) 并返回新地址
    3. 申请新空间失败，返回NULL

  4. 开辟空间时严谨的做法，是动态减小开辟空间的大小
    🌙原空间大小为n，新开辟新空间大小为n+n（2倍）
    🌙失败时改为n+n/2（1.5倍）
    🌙再失败时改为n+n/4（1.25倍）…

2.链表

2.1定义

  1. 【数据搬移】顺序表在插入和删除时移动大量元素，造成浪费，解决方法：链式存储

  2. 虚拟头节点：位于管理节点，相当于第-1个节点，目的是统一第0个节点的插入、删除操作

  3. ⭐插入/删除的关键
    <1> 找到待插入/删除节点的前一个节点
    <2> 有序修改指针，否则会内存泄漏

  4. 单向循环链表：头指针指向尾结点，方便头插和尾插（尾节点是头节点和尾插位置的前一个节点）

2.2代码演示

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

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

typedef struct List {
    Node head; //虚拟头节点，当作第-1个节点
    int len;
} List;

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

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

List *initList() {
    List *l = (List *)malloc(sizeof(List));
    l->head.next = NULL; // val/prev无需初始化
    l->len = 0;
    return l;
}

void freeList(List *l) {
    if (!l) return ;
    Node *p = l->head.next, *k; // killer，记录待free的地址
    while (p) {
        k = p;
        p = p->next;
        freeNode(k);
    }
    free(l);
    return ;
}

// 插入节点到链表 「 reverse() 」
int insertNode(List *l, int idx, Node *n) {
    if (!l) return 0;
    if (idx < 0 || idx > l->len) return 0;
    Node *p = &(l->head);
    while (idx--) p = p->next; //p指向节点idx[0, idx - 1]
    n->next = p->next;
    p->next = n;
    //双向链表
    n->prev = p;
    if (n->next) //NULL
        n->next->prev = n;
    l->len++;
    return 1;
}

// 插入数值到链表
int insertVal(List *l, int idx, int val) {
    Node *n = initNode(val);
    if (!insertNode(l, idx, n)) {
        freeNode(n); //插入失败释放节点n
        return 0;
    }
    return 1;
}

// 删除节点
int erase(List *l, int idx) {
    if (!l) return 0;
    if (idx < 0 || idx >= l->len) return 0;
    Node *p = &(l->head);
    while (idx--) p = p->next;
    Node *k = p->next;
    p->next = k->next; //p->next=p->next->next;
    //双向链表
    if (k->next) //NULL
        k->next->prev = p;
    freeNode(k);
    l->len--;
    return 1;
}

void showList(List *l) {
    if (!l) return ;
    Node *p = l->head.next;
    Node *k = &(l->head); // k初始化虚拟节点地址
    printf("List+ :[");
    while (p) {
        k = p; // 取到NULL前一个节点的地址
        printf("%d->", p->val);
        p = p->next;
    }
    printf("NULL]\n");
  
    printf("List- :[");
    while (k != &(l->head)) { // 非虚拟节点，val有效
        printf("%d->", k->val);
        k = k->prev;
    }
    printf("HEAD]\n");
    return ;
}

// 头插法翻转链表
int reverse(List *l) {
    if (!l) return 0;
    Node *p = l->head.next;
    Node *k;
    // 修改管理节点
    l->head.next = NULL; // 尾节点指向NULL
    l->len = 0;
    while (p) {
        k = p;
        p = p->next;
        insertNode(l, 0, k);
    }
    return 1;
}

int main() {
    srand(time(0));
    List *l = initList();
    int cnt = 10;
    while (cnt--) {
        int val = rand() % 100;
        int opt = rand() % 5;
        int idx = rand() % (l->len + 3) - 1;
        switch (opt) {
            case 0:
            case 1:
            case 2:
                printf("insert %d at %d, res = %s\n", val, idx, insertVal(l, idx, val) ? "SUC" : "ERR");
                break;
            case 3:
                printf("erase at %d, res = %s\n", idx, erase(l, idx) ? "SUC" : "ERR");
                break;
            case 4:
                printf("reverse, res = %s\n", reverse(l) ? "SUC" : "ERR");
                break;
        }
        showList(l);
    }
    freeList(l);
    return 0;
}
savior_xzh
关注
专栏目录
2.2_顺序表
狂草
11-08 286
一. 顺序表概念 一言蔽之: 顺序结构的线性表 1. 特点 顺序结构线性表, 元素集中存储 首元素地址, 即顺序表首地址, 亦即底层数组地址 基于数组实现 二. 顺序表实现 基于数组实现 ~ (顺序表集中存储的物理结构和数组数据类型完全一致) 存储结构 底层动态数组 len + cap 实时记录长度 + 容量 struct Table { int *head; i...
数据结构和算法-2.顺序表与链表
08-10
这份笔记深入解析了计算机科学中两种最基本的数据结构——顺序表与链表的原理、实现以及实际应用。通过对比顺序表和链表的不同特点，你将了解到它们各自的优势与适用场景。例如，笔记详细阐述了顺序表的扩展机制、...
顺序表 - 地址计算
weixin_55085468的博客
01-28 8522
1、假设顺序表第 1 个元素的内存地址是 100，每个元素占用 2 字节内存空间，则第 5 个元素的内存地址是——。 解题：
数据结构----顺序表的基本操作
weixin_49324123的博客
12-09 410
顺序表三个重要组成部分： 1.顺序表的首地址,即存储的首地址 2.顺序表的长度 3.顺序表的大小 顺序表的基本操作： 1.建立和初始化 2.末尾添加元素 3.插入元素 4.删除指定位置的元素 5.删除指定数据的元素 6.销毁顺序表 自己的理解： 顺序表作为一种最简单的数据结构，类似于数组的升级版。也就是一个动态数组.也随时可以知道他现在有几个元素。 1.建立和初始化： 这个部分，根据顺序表的基本组成部分可知，应该建立一个结构体，定义一个指定类型的数据的指针，一个长度，一个大小 初始化的时候再根据指定的大小，
顺序表的基本操作
慢慢冲鸭子的博客
09-23 1298
  #include&lt;iostream&gt; using namespace std; //#define MaxSize 10; 使用define的时候后面没有 ; //#define ElemType ElemType ; //数据类型修改别名的时候用typedef 并且是定义数组类型成新的别名 ElemType -&gt;newType #define MaxSize 1...
数据结构笔记 四：顺序表
OnlyLove_的博客
10-12 599
一、定义 顺序表：用顺序存储的方式实现线性表。 顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间关系由存储单元的邻近关系来体现。 二、顺序表实现 1、静态分配 使用数组方式实现。 #define MAXSIZE 10 // 定义最大长度 typedef int ElemType; // 根据实际情况定义 typedef struct{ ElemType data[MAXSIZE]; // 用数组存放数据元素（ElemType -
数据结构-顺序表与链表详解
m0_62918577的博客
11-05 1996
顺序表概念及分类，以及动态顺序表的接口实现 链表的概念及结构以及无头单向非循环链表的接口实现 在不同方面解析顺序表和链表的区别
数据结构---顺序表，链表
includeevey的博客
08-03 2588
2w字带你走进链表
【数据结构】顺序表和链表的优缺点
Eraser的博客
04-21 2404
经过这么多对比，可以发现顺序表和链表就是互补的存在，两个都有存在的意义和自己擅长的领域。
《数据结构》顺序表与链表
1
10-08 4779
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。}
【数据结构】链表与顺序表的比较
SWsunlight的博客
06-01 1301
顺序表和链表比较
8.顺序表和链表1
08-03
总的来说，顺序表和链表各有优缺点，选择哪种数据结构取决于具体的应用场景和需求。例如，如果需要快速访问任意位置的元素，顺序表可能是更好的选择；而如果频繁进行插入和删除操作，特别是当这些操作发生在表的中间...
8.顺序表和链表新1
08-03
总结来说，顺序表和链表各有优缺点，顺序表适合快速访问和固定大小的存储，链表则在插入删除操作上有优势。选择哪种结构取决于具体应用场景的需求。在编程实践中，理解并熟练掌握这两种数据结构及其操作是至关重要的...
数据结构实验 顺序表和链表
10-08
数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍： 顺序表是一种线性表，...
数据结构实验1顺序表_链表.rar
03-08
本实验将探讨两种基本的数据结构：顺序表和链表。这两种数据结构是理解和掌握数据结构的基础，对于后续的学习和编程实践至关重要。 一、顺序表 顺序表是一种线性数据结构，它在内存中连续存储元素，每个元素都有一...
数据结构-5.2.树的性质
最新发布
ADCvbV的博客
10-12 239
一个分支中，如父结点B，两个子结点为E和F，结点B的度的值为2，等于子结点数量，加上这一个父结点(父结点只能有一个)，就是结点B，E，F组成的树的总结点数即结点数 = 总度数 + 1高度为h的m叉树至少有h个结点(每层至少一个结点，共h层，所以至少共h个结点)；高度为h，度为m的树至少有h+m-1个结点(首先度为m，表明至少要有m个分支，最少时一个分支上只有一个结点，此时有m个结点，这些分支占一层，此外有h-1层，每层最少1个结点，因此这h-1层至少h-1个结点，所以整个树至少h-1+m个结点)为了达到最小
数据结构之顺序表——静态顺序表(C语言版)
努力码字中······
10-09 1193
首先我们来介绍一下顺序表的概念：线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。
（JAVA）浅入数据结构 “堆” - 实现和理论
拔高、提升、创新！
10-09 585
在树结构上做出一部分改变的堆结构，是如何实现的呢？强烈建议初学者来看一看噢~！
栈的操作算法实现（数据结构）
m0_61903191的博客
10-09 385
验证性实验内容：编写一个程序sqstack.cpp,实现顺序栈(假设栈中元素类型ElemType为char的各种基本运算，并在此基础上设计一个程序exp3-1.cpp。验证性实验：实现顺序栈各种基本运算的算法掌握栈的存储结构的表示和实现方法。目的：领会顺序栈存储结构和掌握顺序栈中各种基本运算算法设计。(3)依次进栈元素a、b、c、d、e。(2)判断栈s是否非空。(4)判断栈s是否非空。(6)判断栈s是否非空。(5)输出出栈序列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值