数据结构自学笔记

最新推荐文章于 2024-10-08 19:59:42 发布
最新推荐文章于 2024-10-08 19:59:42 发布
阅读量26 收藏
点赞数
文章标签： 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ajsjsjn/article/details/128738204
版权

线性表

定义：线性表是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。线性表中数据元素的>关系是一对一的。
分类：顺序表、链表、栈和队列。

顺序表

定义： 是一种数据结构，结构是将数据依次放在地址连续的存储单元中。
特点：
存储元素的地址连续;。
可以通过对首地址的偏移访问所有元素

数组实现顺序表

  1. 全局变量及宏定义设置

#include <stdio.h>
int arr[100] = {0};
int len = 0;

  1. 末尾增加元素

void add(int val)
{
    arr[len] = val;
    len++;
}

  1. 删除指定元素

void del(int data)
{
    for(int j = 0; j < len; j++) {
        if(arr[j] == data) {
            for(int k = j+1; k <= len-1; k++)
                arr[k - 1] = arr[k];
            len--;
            j--;//防止连续多个相同的data在一起导致漏删；还可以通过倒序遍历的方法避免
        }
    }
}

  1. 输出顺序表

void print(void)
{
	for(int j = 0; j < len; j ++)
        printf("%d\t", arr[j]);
    printf("\n");
}

  1. 修改指定元素为另外的值

void change(int val, int data)//val为指定要修改的元素，data为修改后的元素
{
    for(int j = 0; j < len; j++)
        if(arr[j] == val)
            arr[j] = data;
}

  1. 查找指定元素，并返回下标（只能找到第一个位置）

int find(int data)
{
    for(int j = 0; j < len; j++)
        if(arr[j] == data)
            return j;
    return -1;//当没有找到指定元素时返回-1，表示该元素不存在
}

  1. 主函数

int main()
{
    add(1); add(2); add(3); add(4); add(5);
    print();
    return 0;
}

指针实现顺序表

  1. 头文件及宏定义

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int Type;

  1. 创建一个顺序表

  • 返回首地址创建顺序表

Type* initArr(int* max)
{
    *max = 10;//设置顺序表的最大容量
    Type* temp = (Type*)malloc((*max) * sizeof(Type));
    memset(temp, 0, (*max) * sizeof(Type));//将申请的内存按字节初始化为0
    return temp;
}

对应的main函数

int main()
{
    Type* arr = NULL;
    int maxSize = 0;
    int len = 0;
    arr = initArr(&maxSize);
    return 0;
}

  • 通过二级指针修改首地址的指向

void initArr(Type** buf, int* max)
{//buf为指向顺序表首地址的二级指针，*max为顺序表的最大容量
    *max = 10;
    *buf = (Type*)malloc((*max) * sizeof(Type));
    memset(*buf, 0, (*max) * sizeof(Type));
}

对应的main函数

int main()
{
    Type* arr = NULL;
    int len = 0;
    int maxSize = 0;
    initArr(&arr, &maxSize);
    return 0;
}

  1. 顺序表末尾增加元素

void add(Type** buf, int* len, int* max, Type val)
{//buf为指向顺序表首地址的二级指针，*len为顺序表的长度，*max为顺序表的最大长度，val为要增加的元素
    if(*len < *max) {
        (*buf)[*len] = val;
        (*len)++;
    } else {
        *max = *max + *max / 2;//扩容为1.5倍
        Type* temp = (Type*)malloc((*max) * sizeof(Type));//申请内存
        for(int j = 0; j < *len; j++)
            temp[j] = (*buf)[j];//将原来的数据复制到temp中
        free(*buf);//释放原来的内存
        *buf = temp;//重新指向空间足够的动态数组
        (*buf)[*len] = val;
        (*len)++;
    }
}

  1. 输出顺序表

void print(Type* buf, int len)
{//tmp为顺序表首地址，len为顺序表长度
    for(int j = 0; j < len; j++)
        printf("%d\t", buf[j]);
    printf("\n");
}

  1. 删除指定元素

void del(Type* buf, int* len, Type val)
{//buf为顺序表的首地址，*len为顺序表的长度，val为指定要删除的元素
    for(int j = 0; j < *len; j++) {
        if(buf[j] == val)
            for(int k = j + 1； k < *len; k++)
                buf[k - 1] = buf[k];
        *len--;
        j--;
    }
}

  1. 修改指定元素

void change(Type* buf, int len, Type val, Type data)
{//buf为顺序表首地址，len为顺序表长度，val为要被修改的顺序表元素，data为修改之后的顺序表元素
    for(int j = 0; j < len; j++)
        if(buf[j] == val)
            buf[j] = data;
}

  1. 查找指定元素

int find(Type* buf, int len, Type val)
{
    for(int j = 0; j < len; j++)
        if(buf[j] == val)
            return j;
    return -1;//当顺序表中找不到该指定元素时返回-1，表示该元素不存在
}

  1. 主函数

int main()
{
    Type* arr = NULL;
    int len = 0;
    int maxSize = 0;
    //arr = initArr(&maxSize)
    initArr(&arr, &maxSize);
    add(&arr, &len, &maxSize, 1);
    add(&arr, &len, &maxSize, 4);
    add(&arr, &len, &maxSize, 3);
    add(&arr, &len, &maxSize, 3);
    add(&arr, &len, &maxSize, 2);
    add(&arr, &len, &maxSize, 2);
    add(&arr, &len, &maxSize, 3);
    print(arr, len);
    return 0;
}

结构体实现顺序表

  1. 头文件及宏定义

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXSIZE 100
typedef int Type;
typedef struct sequence {
    Type* buf;//buf为顺序表首地址
    int maxSize;//maxSize为顺序表当前最大容量
    int len;//len为顺序表当前实际长度
} seq;//seq是一个顺序表对象

  1. 创建一个顺序表

  • 通过二级指针初始化顺序表的结构体

void initArr(seq** seq1)
{//seq1指向一个顺序表对象
    *seq1 = (seq*)malloc(sizeof(seq));
    (*seq1)->len = 0;
    (*seq1)->maxSize = MAXSIZE;
    (*seq1)->buf = (Type*)malloc((*seq1)->maxSize * sizeof(Type));
    memset((*seq1)->buf, 0, (*seq1)->maxSize * sizeof(Type));
}

对应的main函数

int main()
{
    seq* arr1 = NULL;
    initArr(&arr1);
    printf("%d\n", arr1->maxSize);
    return 0;
}

  • 在main函数里初始化结构体再传入结构体地址创建

void initArr(seq* seq1)
{//seq1指向一个顺序表对象
    seq1 = (seq*)malloc(sizeof(seq));
    seq1->len = 0;
    seq1->maxSize = 100;
    seq1->buf = (Type*)malloc(seq1->maxSize * sizeof(Type));
    memset(seq1->buf, 0, seq1->maxSize * sizeof(Type));
}

对应的main函数

int main()
{
     seq arr1 = {
         .buf = NULL,
         .len = 0,
         .maxSize = 0
     };
    initArr(&arr1);
    printf("%d\n", arr1.buf[0]);
    return 0;
}

  1. 增加一个指定元素

void add(seq* seq1, Type val)
{//seq1指向一个顺序表对象
    if(seq1->len >= seq1->maxSize) {
        seq1->maxSize = seq1->maxSize + seq1->maxSize / 2;//扩容为原先的1.5倍
        Type* temp = (Type*)malloc(seq1->maxSize * sizeof(Type));//临时指针作为扩容后顺序表首地址
        for(int j = 0; j < seq1->len; j++)
            temp[j] = seq1->buf[j];
        free(seq1->buf);//复制完成后释放原来的内存
        seq1->buf = temp;//指向新的内存
        seq1->buf[seq1->len] = val;
        seq1->len++;
    } else {
        seq1->buf[seq1->len] = val;
        seq1->len++;
    }
}

  1. 输出顺序表

void print(seq* seq1)
{//seq1指向一个顺序表对象
    for(int j = 0; j < seq1->len; j++)
        printf("%d\t", seq1->buf[j]);
    printf("\n");
}

  1. 删除指定元素

void del(seq* seq1, Type val)
{//seq1指向一个顺序表对象
    for(int j = 0; j < seq1->len; j++) {
        if(seq1->buf[j] == val) {
            for(int k = j + 1; k < seq1->len; k++)
                seq1->buf[k - 1] = seq1->buf[k];
            seq1->len--;
            j--;
        }
    }
}

  1. 修改元素

void change(seq* seq1, Type val, Type data)
{//seq1指向一个顺序表对象,val为要被修改的顺序表元素，data为修改之后的顺序表元素
    for(int j = 0; j < seq1->len; j++) {
        if(seq1->buf[j] == val) {
            seq1->buf[j] = data;
        }
    }
}

  1. 查找指定元素

int* find(seq* seq1, Type val)
{//seq1指向一个顺序表对象
    int* flag = (int*)malloc(seq1->len * sizeof(int));//flag为指定元素下标构成的动态数组
    int i = 0;
    for(int j = 0; j < seq1->len; j++) {
        if(seq1->buf[j] == val) {
            flag[i] = j;
            i++;
        }
    }
    if(i == 0)
        return NULL;//如果没有指定元素返回NULL，表示顺序表内没有该元素
    else
        return flag;//返回值是动态数组的首地址
}
jammy_zy
关注
大话数据结构学习笔记
Chen_learn的博客
01-06 597
大话数据结构学习笔记 笔记内容： 第三章线性表 1、 概念 2、 顺序存储结构 3、 链式存储结构 4、 总结 1、概念 零个或者多个数据元素的有序序列叫做线性表。按照存储结构分为顺序存储结构和链式存储结构。 2、顺序存储结构 线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。 可以类比数组，**有三要素**，**起始位置**，**当前线性表长度**，**线性表的总容量**。 数据结构表示如下： #define MAX_SIZE 20 //总容量 typedef int
数据结构学习笔记（王道）
qq_55593227的博客
03-19 4万+
数据结构学习笔记（王道） PS：本文章部分内容参考自王道考研数据结构笔记 文章目录数据结构学习笔记（王道）一、绪论1.1. 数据结构1.2. 算法1.2.1. 算法的基本概念1.2.2. 算法的时间复杂度1.2.3. 算法的空间复杂度二、线性表2.1. 线性表的定义和操作2.1.1. 线性表的基本概念2.1.2. 线性表的基本操作2.2. 顺序表2.2.1. 顺序表的基本概念2.2.2. 顺序表的实现2.2.3. 顺序表的基本操作2.3. 链表2.3.1. 单链表的基本概念2.3.2. 单链表的实现2.3.
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 43万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构学习笔记
2301_79569991的博客
03-03 1206
数据结构强调的是数据元素之间一定要有数据对象强调的是数据元素之间只要有。
数据结构与算法学习笔记
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
计算机考研——数据结构笔记
ccccddeee的博客
03-10 2487
​ 线性表是一种逻辑结构，是具有相同数据类型的n个数据元素的有限序列。其中每个非表头元素仅有一个直接前驱元素，非表尾元素仅有一个直接后继元素。表中元素有限表中元素具有逻辑上的顺序性，表中元素有其先后次序表中元素都是数据元素，每个元素都是单个元素表中每个元素的数据类型相同，这使得每个元素占有的存储空间相等表中元素具有抽象性，仅讨论元素之间的逻辑关系，不考虑元素本身​ 顺序表是使用一组连续的存储单元依次存储数据元素的存储结构。​ 顺序表的空间分配方式分为两种，即静态分配和动态分配。
408考研数据结构学习笔记
CherriesOvO的博客
05-17 697
408考研数据结构学习笔记
408数据结构笔记整理
clh0980507的博客
06-28 2381
个人复习笔记
数据结构—笔记整理—初识数据结构
好好读书
10-22 4万+
数据结构笔记及相关知识整理，冲冲冲！！！
黑马Java版数据结构学习笔记（一）
qq_46373615的博客
09-09 777
一、为什么要学习数据结构？ 1.数据结构包括数据对象集以及它们在计算机中的组织方式，即它们的逻辑和物理存储结构，一般我们可以认为数据结构指的是一组数据的存储结构。 2.算法就是操作数据的方法，即如何操作数据的效率更高，更节省资源。 3.所谓线性表，就是将数据排成一条长线一样的结构，数组，链，栈，队列都是线性表结构，线性表上的每个数据最多只能前后两个方向。 二、数组 2.1 定义 数组是一种线性表的数据...
Java数据结构学习笔记
12-18
### Java数据结构学习笔记知识点详解 #### 一、数据结构与算法基础 1. **数据结构定义** - 数据结构是一门研究组织数据方式的学科，它与编程语言紧密相关，是实现高效程序设计的基础。 - 在软件开发中，合理选择...
数据结构学习笔记基数排序 详细讲解
09-18
数据结构学习笔记基数排序 详细讲解数据结构学习笔记基数排序 详细讲解数据结构学习笔记基数排序 详细讲解数据结构学习笔记基数排序 详细讲解数据结构学习笔记基数排序 详细讲解数据结构学习笔记基数排序 详细讲解...
数据结构学习笔记排序算法：基数排序
09-17
数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数...
数据结构学习笔记.zip
06-17
本压缩包"数据结构学习笔记.zip"包含了丰富的资源，对于大学生来说，是深入理解数据结构的重要参考资料。 在数据结构的学习中，我们首先会接触到线性数据结构，如数组、链表、栈和队列。数组是最基础的数据结构，它...
考研数据结构学习笔记.doc
10-20
"数据结构学习笔记" 本文档是一个关于数据结构学习笔记，涵盖了数据结构的基本概念、逻辑结构、物理结构、算法设计规范、算法时间复杂度分析、空间复杂度分析等方面的内容。下面是对每个知识点的详细解释： 一、...
《数据结构》--队列【各种实现，算法推荐】
Stark的博客
10-06 789
队列是一种常见的数据结构，按照先进先出（FIFO，First In First Out）的原则排列数据。也就是说，最早进入队列的元素最先被移除。：将元素添加到队列的尾部。：从队列的头部移除并返回元素。：初始化一个空队列。：返回但不移除队列的头部元素（通常称为“peek”或“front”）。：检查队列中是否还有元素。：返回队列中元素的数量。
数据结构之图（6）
2301_76246515的博客
10-05 1000
图G有顶点集V和边集E组成，记为G=(V,E),其中V（G）表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系（边）集合。若V={v1,v2,…，vn}，则用|V|表示图G中顶点的个数。也称为图G的阶E={（u,v)|u ∈​​​V},用|E|表示图G中边的条数图不可以是空，V一定是非空集E是无向边（简称边）的有限集合E是有向边（弧）的有限集合弧是顶点的有序对，记为<v,w>,v为弧尾，w为弧头不存在重复边不存在顶点到自身的边。
C语言 动态数据结构的C语言实现内存映像
hangweijie的博客
10-04 468
在程序运行期间，用动态内存分配函数来申请的内 存都是从堆上分配的，动态内存的生存期由程序员 自己来决定。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自动释放这 些内存。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自释放这 些内存。存放函数参数值，局部变量值等。存放函数参数值，局部变量值等。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。
【数据结构 | PTA】表
最新发布
等风来
10-08 782
例如给定 L 为 21→-15→-15→-7→15，你需要输出去重后的链表 21→-15→-7，还有被删除的链表 -15→15。输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。对每个测试用例，顺序输出重排后的结果链表，其上每个结点占一行，格式与输入相同。
软考程序员数据结构学习笔记
"软考程序员数据结构笔记.doc 是一份针对软考程序员考试的详细学习资料，涵盖了数据结构的基础知识，包括线性结构、树形结构、集合以及数组、顺序表、字符串、特殊矩阵和稀疏矩阵等概念。文档还强调了分析问题、设计...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值