数据结构与算法01----线性表

最新推荐文章于 2024-09-11 15:01:00 发布
最新推荐文章于 2024-09-11 15:01:00 发布
阅读量699 收藏 1
点赞数 1
分类专栏： 数据结构与算法分析 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Genius_M/article/details/122341816
版权

线性表 [逻辑结构] 的顺序存储和链式存储 [存储结构(物理结构)]

在这里插入图片描述

Key 1：线性表是指各数据元素间保持“1对1”关系的数据结构
Key 2：线性表分为顺序表(数组)和链表，分别通过元素相邻和保存指针域的方式来实现“1对1”

线性表的基本操作：顺序表、(单) 链表

查找(定位)元素：按值查找

  • 给定长度为 n 的线性表，查找值为 v 的元素
  • (最坏)从头到尾遍历 => 时间复杂度O(n)
    在这里插入图片描述

顺序表新增 / 删除元素

  • 给定长度为 n 的顺序表，在指定位置 i 插入一个新元素

  • 给定长度为 n 的顺序表，删除位置 i 的元素
    在这里插入图片描述

  • 需要将位置 i 到位置 n - 1的所有元素都向后或向前挪一格

  • 在最坏情况(i = 0)下，需要挪动全部的 n 个元素 => 时间复杂度为O(n)

  • 无需利用额外空间 => 空间复杂度为O(1)

(单)链表新增元素

  • 给定长度为 n 的顺序表，在第 i 个节点插入一个新元素在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  • 首先需要从头结点开始逐个向后找 i - 1次 => 时间复杂度为O(n)

  • 找到后插入只需要修改第 i - 1个结点和待插入节点的 [后继结点地址] 即可 => O(1)

  • 无需利用额外空间 => 空间复杂度为O(1)

(单)链表删除元素

  • 给定长度为 n 的单链表，删除第 i 个结点在这里插入图片描述

  • 需要移动到第 i 个结点的前驱结点，最坏情况下移动 n - 1次 => 时间复杂度为O(n)

  • 修改前驱结点的后继指针 => O(1)

  • 无需利用额外空间 => 空间复杂度为O(1)

顺序表更新元素

  • 给定长度为 n 的顺序表，更新位置 i 的元素在这里插入图片描述

  • 无论 i 的值如何，都可以通过 i 直接访问位置 i 的元素，将其更新为 v’ => 时间复杂度为O(1) => 随机存取

(单)链表更新元素

  • 给定长度为 n 的 (单)链表，更新第 i 个结点的值
  • 需要从头结点开始按顺序找到第 i 个结点才能访问并更新它 => 顺序存取
  • 最坏情况遍历整个链表 => 时间复杂度为 O(n)

Key 1：顺序表中增加和删除一个元素将导致该位置后的元素前移或后移，复杂度为O(n)
Key 2：单链表增加和删除元素虽然不用移动元素，但需先找到其前驱结点，复杂度为O(n)
Key 3：若线性表需要频繁更新元素 -> 选择用顺序表实现（数组）
Key 4：若线性表需要频繁插入删除元素 -> 选择用链式表实现

线性表合并操作：集合表合并、有序表合并

线性表的集合式合并：只合并不同元素
在这里插入图片描述

  • 设A表长度为n，B表长度为m
  • 对于B表中的每个元素，都需要先判断其是否已经存在A里 => O(mn)
  • 如果存在，无需插入，如果不存在，将其插入在A的末尾 => O(1)
  • 总时间复杂度为 O(mn)
  • 空间复杂度：顺序表 O(m + n) 链表 O(1)

合并两个有序表：本来分别有序，合并结果仍然有序
在这里插入图片描述
合并两个有序顺序表
在这里插入图片描述
在这里插入图片描述

  • 设A表长度为n，B表长度为m
  • 先预留结果表空间：n + m个元素
  • 从表头开始同时逐个访问A表和B表元素，将当前位置上较小者放入结果表并后移一位
  • 总时间复杂度为 O(m + n)
  • 空间复杂度为 O(m + n)

合并两个有序单链表

在这里插入图片描述
注意：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
一直重复上图操作
在这里插入图片描述

  • 设A表长度为n，B表长度为m
  • 先创建一个头结点(哑结点dummy)，其数据没有实际意义，只为用它的指针域
  • 从表头开始逐个同时遍历A和B，将当前已完成合并的表尾元素的后继结点设置为当前A和B游标中较小的一个，并将该游标向后移动一位
  • 时间复杂度为 O(m + n)
  • 空间复杂度为 O(1)

Key 1：合并两个有序表：逐一比较两表当前元素，将正确的元素添加进结果表并移动游标

代码实现(顺序表)

main.c

#include <stdio.h>
#include <stdlib.h>
#include "sqlist.c"

int main()
{
    sqlist list;
    sqlist_init(&list, 100);
    
    int i;
    //测试插入
    for (i = 1; i < 10; i++)
    {
        sqlist_insert(&list, 0, i);
        sqlist_print(&list);
    }

    sqlist_insert(&list, 9, 33);
    sqlist_print(&list);

    int r;

    r = sqlist_insert(&list, 11, 44);

    printf("invaild insert ret = %d\n", r);
    
    sqlist_print(&list);
    //size函数测试
    i = sqlist_size(&list);

    printf("list size = %d \n", i);
    //测试查找
    i = sqlist_search(&list, 5);

    printf("pos of 5 is %d \n", i);

    int v;
    //测试删除
    for (i = 0; i < 10; i++)
    {
        sqlist_delete(&list, 1, &v);
        
        printf("delete ret is %d \n", v);
        
        sqlist_print(&list);
    }
    //测试empty函数
    i = sqlist_empty(&list);

    printf("is empty? %d\n", i);
    //测试full函数
    i = sqlist_full(&list);

    printf("is full? %d\n", i);
    
    sqlist_destory(&list);

    return 0;
}

sqlist.h

#ifndef _SQLIST_H_
#define _SQLIST_H_

typedef struct sqlist
{
    int size; //空间大小
    int n; //当前数组中元素个数
    int* data; //数组 int data[100]
} sqlist;

int sqlist_init(sqlist* list, int size);
int sqlist_destory(sqlist* list);
//pos = 0插入到最前面 pos = 1插入到第一个元素后面
int sqlist_insert(sqlist* list, int pos, int value);
int sqlist_delete(sqlist* list, int pos, int* outv);
void sqlist_print(sqlist* list);
int sqlist_size(sqlist* list);
int sqlist_search(sqlist* list, int v);

int sqlist_empty(sqlist* list);
int sqlist_full(sqlist* list);

#endif

sqlist.c

#include "sqlist.h"
#include <stdio.h>

int sqlist_init(sqlist* list, int size)
{
    list->size = size;
    list->n = 0;
    list->data = (int*)malloc(size * sizeof(int));
    
    return list->data != NULL; //如果分配内存成功，返回1，否则返回0
}

int sqlist_destory(sqlist* list)
{
    //安全隐患，在堆溢出中有个很著名的溢出方法叫做double free
    if (list->data == NULL)
    {
        return 0;
    }

    free(list->data);
    list->data = NULL;

    return 1;
}

int sqlist_insert(sqlist* list, int pos, int value)
{
    int i;

    if (pos < 0 || pos > list->n)
    {
        return 0; //位置不合法
    }

    if (list->n == list->size)
    {
        return -1; //内存不够了。
    }
    //通过个案分析的方法确定循环的起始和结束！！！！！
    for (i = list->n; i > pos; i--)
    {
        list->data[i] = list->data[i - 1];
    }

    list->data[pos] = value; //一定要测试一下！！！！！
    list->n++;

    return 1; //插入成功
}

void sqlist_print(sqlist* list)
{
    int i;

    printf("sqlist: size = %d, n = %d [ ", list->size, list->n);

    for (i = 0; i < list->n; i++)
    {
        printf("%d ", list->data[i]);
    }

    printf("]\n");
}
//pos >= 1 <= n
int sqlist_delete(sqlist* list, int pos, int* outv)
{
    if (pos < 1 || pos > list->n)
    {
        return 0; //参数非法!!
    }

    if (list->n == 0)
    {
        return -1; //内容不够了
    }

    *outv = list->data[pos - 1];
    
    int i;
    //个案分析，着重分析循环的开始和结束
    //具体做法就是代入法。n = 3 pos = 1, date 0 = datee 1, date 1 = date 2
    for (i = pos; i < list->n; i++)
    {
        list->data[i - 1] = list->data[i];
    }

    list->n--;

    return 1; //删除成功
}

int sqlist_size(sqlist* list)
{
    return list->n;
}
//返回数组的下标还是逻辑下标？  返回逻辑下标
int sqlist_search(sqlist* list, int v)
{
    int i;

    for (i = 0; i < list->n; i++)
    {
        if (list->data[i] == v)
        {
            return i + 1;
        }
    }

    return 0; //找不到
}

int sqlist_empty(sqlist* list)
{
    return list->n == 0;
}

int sqlist_full(sqlist* list)
{
    return list->n == list->size;
}

代码实现(链表)

main.c

#include <stdio.h>
#include <stdlib.h>
#include "linkedlist.c"

int main()
{
    int i, x;

    node* head = linkedlist_init();
    //判空
    x = linkedlist_empty(head);

    printf("empty return %d\n", x);
    //测试插入
    for (i = 1; i < 9; i++)
    {
        linkedlist_insert(head, 0, i);
    }

    linkedlist_print(head);
    
    linkedlist_insert(head, 8, 99);
    linkedlist_print(head);
    
    linkedlist_insert(head, 18, 99);
    linkedlist_print(head);
    //测试删除
    printf("delete:");
    
    for (i = 0; i < 5; i++)
    {
        linkedlist_delete(head, 3, &x);
        
        printf("%d ", x);
    }

    printf("\n");
    
    linkedlist_print(head);
    //测试size
    printf("size = %d\n", linkedlist_size(head));
    //判空
    x = linkedlist_empty(head);

    printf("empty return %d\n", x);
    //测试搜索
    printf("pos of 99 is %d\n", linkedlist_search(head, 99));
    
    linkedlist_destory(head);

    return 0;
}

linkedlist.h

#ifndef _LINKED_LIST_H
#define _LINKED_LIST_H

typedef struct node
{
    int data; //数据
    struct node* next; //指向下一个节点的指针
} node;

node* linkedlist_init();
void linkedlist_destory(node* head);

int linkedlist_insert(node* head, int pos, int x);
//返回值为是否成功运行，1成功，0失败，删除的节点放在x中。
int linkedlist_delete(node* head, int pos, int* x);
void linkedlist_print(node* head);
int linkedlist_size(node* head);
int linkedlist_search(node* head, int x);

int linkedlist_empty(node* head);

#endif

linkedlist.c

#include "linkedlist.h"
#include <stdio.h>
//初始化 带有头结点的单链表
// h -> [ head ] -> [ first ] -> [ second ] -> [...] -> [ ]
node* linkedlist_init()
{
    node* p = (node*)malloc(sizeof(node));
    p->data = 0;
    p->next = NULL;

    return p; //这就是头结点，返回他
}

void linkedlist_destory(node* head)
{
    node* p;
    while (head != NULL)
    {
        p = head->next; //找到下一个节点
        free(head);
        head = p; // head指向原本的下一个节点
    }
}
// h -> [ head ] ->[1]->[2]->[3]->[4]
// 插入的位置，给0插入到1之前，给1插入到1之后
int linkedlist_insert(node* head, int pos, int x)
{
    int i;

    if (pos < 0)
        return 0;// 失败

    node* p = head;// p应该指向插入位置前一个
    for (i = 0; i < pos; i++)
    {
        if (p == NULL)
        {
            return 0;// 失败
        }

        p = p->next; // 向后移动一格
    }

    node* nn = (node*)malloc(sizeof(node));
    nn->next = p->next;
    nn->data = x;
    p->next = nn;

    return 1;// 成功
}

// h -> [ head ] ->[1]->[2]->[3]->[4]
// 假设pos从1开始编号
int linkedlist_delete(node* head, int pos, int* x)
{
    int i;

    node* p = head;
    // 验证循环次数对不对，就是通过代数的方法
    // 假设pos = 1，看他执行多少次，p最终指向了哪一个元素。
    for (i = 0; i < pos - 1; i++)
    {
        if (p == NULL)
        {
            return 0;// pos不合法，删除失败
        }

        p = p->next;// 向后一格
    }

    node* q = p->next;// 这就是要删除的节点
    *x = q->data;// 取出数据放入传出参数
    p->next = q->next;
    free(q);

    return 1;// 成功
}

void linkedlist_print(node* head)
{
    node* p = head->next;// 指向第一个有数据的节点
    while (p != NULL)
    {
        printf("%d ", p->data);
        
        p = p->next;
    }

    printf("\n");
}
// h -> [ head ] ->[1]->[2]->[3]->[4]
int linkedlist_size(node* head)
{
    node* p = head->next;

    int c = 0;

    while (p != NULL)
    {
        c++;
        p = p->next;
    }

    return c;
}
//根据值x获取位置，是一个从1开始编号的下标
int linkedlist_search(node* head, int x)
{
    node* p = head->next;

    int pos = 1;

    while (p != NULL)
    {
        if (p->data == x)
        {
            return pos;
        }

        p = p->next;
        pos++;
    }

    return 0; // 找不到返回0
}

int linkedlist_empty(node* head)
{
    return head->next == NULL;
}
Len1Mi
关注
专栏目录
找1到n中缺失的数字（长度为n-1的整形数组，数字的范围在1到n，找其中一个缺失的数字）
qq_24336773的博客
08-15 1万+
给定一个长度为n-1的整形数组，数字的范围在1到n（无重复），其中有一个缺失的数字，写一段高效的程序找出该数字。 一、数组有序 对于该数组是否有序，题目没有说明，假设有序，则可使用二分查找，时间复杂度为O(logN)。 如果中间元素的值和下标相等，那么下一轮查找只需要查找右半边；如果中间元素的值和下标不相等，并且它前面一个元素和它的下标相等，这意味着这个中间的数字正好是第一个值和下标不相等的...
数据结构与算法系列--线性表
2302_77343936的博客
10-01 513
针对顺序表的缺点，一种改进的思路是让相邻元素间留有足够的余地，即所有的元素都不考虑相邻的位置，哪里有空位就空到哪里，而只是让每个元素都知道它下一个元素在哪儿就可以了，这样，假设我们在表中的第一个元素，我们便知道了第二个元素的内存地址，在第二个元素，知道第三个元素的内存地址，依此类推，通过遍历的形式便可以找到所有元素的内存地址。这种思想便是线性表链式存储结构建立的前提。1.线性链表:采用链式存储结构的线性表。
数据结构与算法实验-实验一：线性表基本操作
soul_mingling的博客
04-01 2550
线性表基本操作 文章目录线性表基本操作题目1题目2题目3 题目1 线性表是最常见和常用的ADT。假设线性表的元素为整数，请基于顺序存储结构实现线性表ADT。 基本功能包括： （1）建立线性表； 输入有两行，第一行是一个整数n，线性表的长度； 第二行是n和数据元素 （2）插入： 输入两个整数，即元素插入的位置和元素值 （3）删除： 输入一个整数，即要删除的元素 （4）搜索： 输入一个整数，即搜索元素...
2022牛客寒假2 小沙的算数（并查集解法 乘法逆元）
Jacob0824的博客
05-05 679
#include<bits/stdc++.h> using namespace std; #define int long long const int N = 2e6+10, mod = 1e9+7; int n, q; char op[N]; int num[N]; int pro[N]; int p[N]; int Find(int x) { if(p[x]!=x) p[x] = Find(p[x]); return p[x]; } int qm...
Java数据结构与算法-线性表
ly_better的博客
11-02 662
1.1线性表的基本概念 线性表是由n个数据元素所构成的有限序列. 对于同一个线性表，其每一个数据元素的值虽然不同，但必须具有相同的数据类型；同时，数据元素之间具有一种线性
数据结构与算法--线性表
joker_sxj的博客
12-08 5319
数据结构与算法--线性表
数据结构与算法01-线性表概述
zl4178的博客
03-12 615
数据结构与算法-线性表-顺序表和链表
数据结构与算法---线性表1
qq_65198010的博客
03-15 698
线性表 重点： 线性表的逻辑结构 线性表的顺序存储结构 线性表的链式存储结构 一元多项式的表示及相加 定义： 线性表n(n>=0)的同质元素的有限数列，每个元素有唯一的前驱和后继。首元素只有后继，尾元素只有前驱，n为0时是空表，n叫做线性表的长度。 线性表的基本操作 初始化 InitList(&L) 销毁 DestroyList(&L) 清空 ClearList(&L) 判断空表 ListEmpty(L) 求长度 ListLength(L) 取i值 GetElem(L,i
头歌-数据结构与算法 - 线性表
mlws1900的博客
10-06 4098
【代码】头歌-数据结构与算法 - 线性表。
数据结构与算法-线性表
whdehcy的博客
01-23 545
最简单的线性结构 ：线性表。特征：唯一前驱 唯一后继。-后继为头节点：空表。
数据结构与算法分析--线性表实现
04-01
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素构成的序列，元素之间存在一对一的顺序关系。线性表在实际应用中非常广泛，例如数据库中的记录、数组、队列、栈等都是其具体实例。在本资料中...
头歌C++数据结构与算法 - 线性表
03-04
头歌C++数据结构与算法 - 线性表
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
本次实验的主题是“数据结构实验报告-线性表-两个有序线性表的归并算法”。实验的主要目的是让学生掌握两个有序线性表的归并算法。具体来说，实验要求学生通过键盘输入数据来建立两个有序线性表，并最终将这两个有序...
数据结构应用实例(四)——最小生成树
Blogs of zcy1221
09-10 1218
每次选择最近顶点，需要进行一次遍历，比较 N 次，之后将其添加进最小生成树，更新 weight 和 pre，一次遍历，N 次操作，总共需要选择 N-1 次，所以 prim 算法的时间复杂度为。4、 kruskal 算法，为图的结构体添加成员 E ——存放边的结构体数组，成员为两节点编号和边的权值，这样在创建图时，可以直接创建 E，同时，图的数据文件中添加边的条数；综合所述，Prim 算法适合顶点相对较少而边相对稠密的网的最小生成树的求解，而 Kruskal 算法适合于求边比较稀疏的网的最小生成树；
【数据结构-二维前缀最小值】力扣3148. 矩阵中的最大得分
最新发布
sjsjs11的博客
09-11 1008
也就是说，当grid[i][j]为终点的时候，要在以(0,0)为左上角，(i,j)为右下角的矩阵中（不包括(i,j)）找到最小的那个元素值mn。如果用列来表示我们需要的信息，也就是从0到j-1列的最小值，然后第j列的从0到i-1行的最小值，这两个最小值我们进行比较，更小的那个就是我们需要的信息。所以说在遍历每一行的时候，我们都要重置pre_min为INT_MAX，pre_min的作用就是找到从0到j-1列的最小值，col_min的作用就是储存第j列的从0到i-1行的最小值。
数据结构----树
2301_77841194的博客
09-07 996
1、树(Tree)是n(n≥0)个结点的有限集。n=O时称为空树。在任意一棵非空树中:(1）有且仅有一个特定的称为根(Root)的结点;(2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1、T2、……、Tm,其中每一个集合本身又是一棵树,并且称为根的子树(SubTree)2、树的结点包含一个数据元素及若干指向其子树的分支。结点拥有的子树数称为结点的度(Degree)。度为0的结点称为叶结点（Leaf）或终端结点;度不为0的结点称为非终端结点或分支结点。
数据结构归并两个链表并按照学号升序
wsdsbtzk的博客
09-07 396
int id;int score;int N,M;cin>>N>>M;return 0;i<n;i++)Student* q;while(p!=NULL)q=p;p=p->next;free(q);=NULL)p=p->next;p->next=s2;=NULL)
Java-数据结构-栈和队列-Stack和Queue (oﾟ▽ﾟ)o
2303_80388948的博客
09-07 920
栈：是一种特殊的线性表，其 只允需在固定的一端进行插入和删除操作。 进行插入和删除的一端叫做栈顶，另一端叫做栈底。并且要遵循 先进后出 的规则。 队列：是一种只允许一端进行插入元素，在另一端进行删除元素的特殊的线性表。 队列具有 先进先出 的性质：进行插入的一端叫做队尾，进行删除的一端叫做队头。也就是队尾进，队头出。
数据结构与算法解析-线性表插入操作
"这篇资源主要讨论的是算法与数据结构的主题，包括线性表的插入操作以及数据结构在计算机科学中的重要性。提供的代码是C语言实现的线性表顺序插入函数Insert_SqList，该函数将元素插入到指定位置并更新线性表长度。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Len1Mi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值