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

最新推荐文章于 2024-10-05 22:19:52 发布
最新推荐文章于 2024-10-05 22:19:52 发布
阅读量76 收藏
点赞数
文章标签： 数据结构 算法 java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53075807/article/details/131010744
版权

定义

具有相同数据类型的n个数据元素的有限序列一种逻辑结构（表示数据之间的一一对应关系）

数据元素：数据元素是数据的基本单位；有数据项构成。

基本操作

lnitList（&L):初始化表。构建一个空的线性表

DestroyList（&L):销毁操作，销毁线性表，释放线性表L所占的内存空间。

ListInsert(&L,i,e): 插入操作。在表L的第i个位置上插入指定元素e。

ListDelete(&L,i,&e):删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。

LocateElem（L,e):按值查找操作。

GetElem（L,i）:按位查找操作。

Length（L）：求表长。

Print List（L）：输出操作。

Empty（L）：判空操作。

存储

顺序表

定义：用顺序存储的方式实现线性表

静态分配

#include <stdio.h>
#define MaxSize 10
typedef struct{
    int data[MaxSize];
    int length;
}SqList;
​
void InitList(SqList &L){
    for(int i=0;i<MaxSize;i++){
        L.data[i]=0;
    }
    L.length=0;
}
int main()
{
    SqList L;
    InitList(L);
    return 0;
}

动态分配

C:malloc动态申请内存空间；free动态释放内存空间

C++:new动态申请内存空间；delete动态释放内存空间

#include <stdlib.h>
#include <stdio.h>
#define InitSize 10
typedef struct{
    int *data;
    int MaxSize;
    int length;
}SeqList;
​
void InitList(SeqList &L){
    L.data=(int *)malloc(InitSize*sizeof(int));
    L.length=0;
    L.MaxSize=InitSize;
}
void IncreaseSize(SeqList &L,int len){
    int *p=L.data;
    L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));
    for(int i=0; i<L.length;i++){
        L.data[i]=p[i];
    }
    L.MaxSize=L.MaxSize+len;
    free(p);
}
int main()
{
    SeqList L;
    InitList(L);
    IncreaseSize(L,7);
    return 0;
}

特点

  • 随机访问，可以在O（1）时间内找到第i个元素

  • 存储密度高，每个节点只存储数据元素

  • 拓展容量不方便（即便采用动态分配的方式实现，拓展长度的时间复杂度也比较高）

  • 插入，删除操作不方便，需要移动大量元素。

基本操作

  • 插入 删除 按位查找

#include <stdlib.h>
#include <stdio.h>
#define MaxSize 10
typedef struct{
    int data[MaxSize];
    int length;
}SqList;
​
void InitList(SqList &L){
    for(int i=0;i<MaxSize;i++){
        L.data[i]=0;
    }
    L.length=0;
}
bool ListInsert(SqList &L,int i, int e){
    
    for(int j=L.length;j>=i;j--){
        L.data[j]= L.data[j-1];
    }
    L.data[i-1] = e;
    L.length++;
    return true;
}
bool ListDelete(SqList &L,int i, int &e){
    e=L.data[i-1];
    for(int j=i;j<L.length;j++){
        L.data[j-1]= L.data[j];
    }
    L.length--;
    return true;
}
int GetElem(SqList L ,int i){
    return L.data[i-1]; 
}
int LocateElem(SqList L,int e){
    for(int i = 0;i<MaxSize;i++){
        
        if(L.data[i]==e){
            return i+1;
        }
    }
    return 0;
}
int main()
{
    SqList L;
    InitList(L);
    ListInsert(L,3,3);
    int e= -1;
    ListDelete(L,3,e);
    int a = GetElem(L,3);
    return 0;
}

单链表

定义

struct LNode{
    ElemType data;
    struct LNode *next;
};
//增加节点
struct LNode *p = (struct LNode*)malloc(sizeof(struct LNode));

typedef<数据类型><别名>

不带头结点单链表

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
bool Initlist(LinkList &L){
    L= NULL;
    return true;
}
void test(){
    LinkList L;(没有创建结点)
    Initlist(L);
}

带头结点单链表(写代码方便)

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;
bool Initlist(LinkList &L){
    L= (LNode *)malloc(sizeof(LNode));
    if(L==NUll){
        return false;
    }
    L->next =NULL;
    return true;
}
void test(){
    LinkList L;(没有创建结点)
    Initlist(L);
}

基本操作

ListInsert(&L,i,e):插入操作。按位序删除

//带头结点
bool ListInsert(LinkList &L,int i,Elemtype e){
    if(i<1)
        return false;
    LNode *p;
    int j=0;
    p = L;//指向头结点（第0个节点）不存数据。
    while(p!=NULL&& j<i-1){
        p= p->next;
        j++;
    }
    if(p==NULL){
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data= e;
    s->next= p->next;
    p->next= s;
    return true;
}
//不带头结点
bool ListInsert(LinkList &L,int i,Elemtype e){
    if(i<1)
        return false;
    if(i==1){
        LNOde *s=(LNode *)malloc(sizeof(LNode));
        s->data=e;
        s-next=L;
        L=s;
        return ture;
    }
    LNode *p;
    int j=1;
    p = L;//第一个节点不是头结点
    while(p!=NULL&& j<i-1){
        p= p->next;
        j++;
    }
    if(p==NULL){
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data= e;
    s->next= p->next;
    p->next= s;
    return true;
}
//前插操作
bool InsertPriorNode(LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s==NULL)
        return false;//内存分配失败
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return ture;
}
//按位序删除（带头结点）
bool ListDelete(LinkList &L int i, ElemType &e){
    if(i<1)
        return false;
    LNode *p;
    int j=0;
    int j=0;
    p = L;//指向头结点（第0个节点）不存数据。
    while(p!=NULL&& j<i-1){
        p= p->next;
        j++;
    }
    if(p==NULL){
        return false;
    }
    if(p->next == NULL){
        return false;
    }
    LNode *q =p->next;
    e = q->data;
    p->next=q->next;
    free(q);
    return true;
}
//删除指定结点
bool DeleteNode(LNode *p){
    if(p==NULL){
        return false;
    }
    LNode *q=p->next;
    p->data=p->next->data;
    p->next=q->next;
    free(q);
    return true;
}
//尾插法建立单链表
LinkList List_TailInsert(LinkList &L){
    int x;
    L=(LinkList)malloc(sizeof(LNode));
    LNode *s,*r=L;
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        scanf("%d",&x);
    }
    r->next=null;
    return L;
}
//头插法建立单链表
LinkList List_HeadInsert(LinkList &L){
    LNode *s;
    int x;
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    scanf("%d",&x);
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        scanf("%d",&x);
    }
    return L;
}
//链表逆置（头插法）
#include<stdio.h>
#include<malloc.h>
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode,*LinkList;
​
LinkList Reverse(LinkList &L)
{
    LinkList p,q;
    p=L->next;
    L->next=NULL;   //重新构造单链表
    while(p!=NULL)
    {
        q=p;
        p=p->next;
        
        q->next=L->next;  //头插法 
        L->next=q;
    } 
    return L;
} 
​
​
int main()
{
    LinkList A = (LinkList)malloc(sizeof(LNode));
    LinkList a1 = (LinkList)malloc(sizeof(LNode));
    LinkList a2 = (LinkList)malloc(sizeof(LNode));
    LinkList a3 = (LinkList)malloc(sizeof(LNode));
    LinkList a4 = (LinkList)malloc(sizeof(LNode));
    A->next=a1;
    a1->next=a2;
    a2->next=a3;
    a3->next=a4;
    a4->next=NULL;
    a1->data=1;
    a2->data=2;
    a3->data=3;
    a4->data=4;
    LinkList p=A->next;
    printf("A中元素：");
    while(p){
        printf("%d ",p->data);
        p=p->next;
    }
    p=Reverse(A);
    printf("\n单链表逆置之后A中的元素：\n");
    for(p=p->next;p!=NULL;p=p->next)
    {
        printf("%d ",p->data);
    }
    return 0;
}    

顺序表输出所有元素跟单链表输出时间复杂度一样

双链表

初始化双链表

typedef struct DNode{
    ElemType data;
    struct DNode *prior,*next;
}DNode,*DLinklist;
bool InitDLinkList(Dlinklist &L){
    L=(DNode *)malloc(sizeof(DNode));
    if(L==NULL){
        return false;
    }
    L->prior = NULL;
    L->next = NULL;
    return true;
}
//插入
//关注插入的结点，s的prior和next都要有人
bool InsertNextDNode(DNode *p,DNode *s){
    if(p==NUll||s==NULL)
        return false;
    s->next=p->next;
    if(p->next!=NULL)
        p->next->prior=s;
    s->prior=p;
    p->next=s;
}
//删除p的后继结点
//想要删除谁，关注谁
bool DeleteNextDNode(DNode *p,){
    if(p==NUll)
        return false;
    DNode *q=p->next;
    p->next=q->next;
    if(q->next!=NULL)
        q->next->prior=p;
    free(q);
    return true;
}
//释放各个结点
void DestoryList(DLinklist &L){
    while(L->next!=NULL)
        DeleteNextDNode(L);
    free(L);
    L=NULL;
}
​
void testDLinkList(){
    DLinklist L;
    InitDLinkList(L);
}

循环单链表

约瑟夫环-

typedef struct LNode{
    ElemType data;
    struct LNode
}LNode,*LinkList;
​
//初始化一个循环单链表
bool InitList(LinkList &L){
    L = (LNode*)malloc(sizeof(LNode));
    if(L==NULL)
        return false;
    L->next = L;
    return true;
}
//是否为空
bool Empty(LinkList L){
    if(L->next ==L)
        return true;
    else
        return false;
}
//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L,LNode *p){
    if(p->next==L)
        return true;
    else
        return false;
}

循环双链表

typedef struct DNode{
    ElemType data;
    struct DNode *prior,*next;
}LNode,*LinkList;
​
//初始化一个循环单链表
bool InitDLinkList(DLinkList &L){
    L = (DNode*)malloc(sizeof(DNode));
    if(L==NULL)
        return false;
    L->prior = L;
    L->next = L;
    return true;
}
//是否为空
bool Empty(LinkList L){
    if(L->next ==L)
        return true;
    else
        return false;
}
//判断结点p是否为循环双链表的表尾结点
bool isTail(DLinkList L,DNode *p){
    if(p->next==L)
        return true;
    else
        return false;
}
//插入
bool InsertNextDNode(DNode *p,DNode *s){
    s->next=p->next;
    p->next->prior=s;
    s->prior=p;
    p->next=s;
}

静态链表

分配一整片连续的内存空间，各个结点集中安置。

#define MaxSize 10
typedef struct{
    ElemType data;
    int next;
}SLinkList[MaxSize];
void testSLinkList(){
    struct Node a[MaxSize];
}
每天进步一捏捏的小王
关注
头歌C++数据结构与算法 - 线性表
03-04
头歌C++数据结构与算法 - 线性表
线性表-数据结构与算法(C语言版)
monkeylvjava
05-01 1246
目录 线性表的基本概念 线性表的顺序存储结构 顺序存储结构的实现 顺序存储结构的应用 线性表的链式存储结构 链式存储结构的实现 单链表的应用 线性表的基本概念 线性表：n个同类型数据元素的有限序列，记为 L=(a1,a2,…,ai,an)；i为数据元素ai在线性表中的位序；n为线性表的表长；n=0时成为空表。 线性表的特点 数据元素类型相同 i位序从1开始 除第一个元素外，每个...
实现顺序表的各种基本运算的算法
热门推荐
kklv__lo的博客
09-09 1万+
内容：编写一个程序，实现顺序表的各种基本算法和整体建表算法，并在此基础上设计一个程序，完成以下功能。 (1)初始化顺序表L。 (2)依次插人a、b、c、d、e元素。 (3)输出顺序表L。 (4)输出顺序表L的长度。 (5)判断顺序表L是否为空。 (6)输出顺序表L的第3个元素。 (7)输出元素a的位置。 (8)在第4个元素位置上插入f元素。 (9)输出顺序表L。 (10)删除顺序表L的第3个元素。 (11)输出顺序表L。 (12)释放顺序表L。 ...
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
本次实验的主题是“数据结构实验报告-线性表-两个有序线性表的归并算法”。实验的主要目的是让学生掌握两个有序线性表的归并算法。具体来说，实验要求学生通过键盘输入数据来建立两个有序线性表，并最终将这两个有序...
数据结构与算法-概念
01-06
其中复杂度是数据结构与算法中最重要的概念 复杂度也叫渐进式复杂度，通常用大O来表示分为时间复杂度与空间复杂度，用来分析算法的执行效率与数据规模的增长关系。 分析复杂度的时候，低阶（n）、常量、系数三部分...
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 374
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】双向链表（Doubly Linked List）
2301_77727857的博客
10-05 306
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1152
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 348
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 1214
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
数据结构之图（6）
2301_76246515的博客
10-05 520
图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为弧头不存在重复边不存在顶点到自身的边。
数据结构篇（绪论）
wlcass zhengge blog
10-05 392
字符类型：char布尔类型：boolean数值类型：byte、short、int、long、float、double。如果系统自定义的数据类型不够，可以自定义数据类型。例如：Person、Animal、. . .算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令。算法代表着用系统的方法描述解决问题的策略机制。
数据结构-哈西表笔记
2302_80490510的博客
10-05 176
如果不用去重就可以用哈希表。
class 004 选择 冒泡 插入排序
最新发布
2301_80967814的博客
10-05 245
我感觉这个真是没有什么好讲的, 这个是比较简单的, 感觉没有什么必要写一篇博客, 而且这个这么简单的排序问题肯定有人已经有写好的帖子了, 肯定写的比我好, 所以我推荐大家直接去看“左程云”老师的讲解就很好了, 一定是能看懂的, 要是用文字形式再写一遍, 反而有点画蛇添足了. 这里就将三个排序的代码写上.这三个排序算法中唯一需要注意的是：插入排序, 这个在小数据量的时候排序的速度是非常快的, 一般认为数组长度在10 ~ 50之间, 插入排序的效率是非常快的. 后续学习的Tim都有插入排序的参与.Tim。
Mysql 索引底层数据结构和算法
weixin_46203834的博客
10-02 1254
索引底层数据结构和算法， 常用的索引结构有：Hash表，二叉树，平衡二叉查找树（红黑树是一个近似平衡二叉树），B树，B+树。
Java.数据结构.HashMap
TJKFYY的博客
10-05 698
1基本概念键值对（key-value）的方式存储数据插入顺序和遍历顺序可能不同2数据结构HashMap的底层实现优化为数组+链表或红黑树假如我们输入1,4,5,6,7,9这串数字，那么其内部就是这样的结构。3。
Java：插入排序
xiaochuan_bsj的博客
09-28 822
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳 定的；直接插入排序是稳定的，由上面图片能看到它是具有稳定性的，但如果是代码部分的 arr[j] > tmp 改为：arr[j] >= tmp，以上面的2a和2b为例，它们的顺序就会发生变化。所谓的排序，就是使一串记录，按照某个或某些关键字的大小，递增或递减的排列起来的操作。
数据结构与算法-线性表
09-13
数据结构与算法-线性表是一种用于存储数据的数据结构，它可以按照一定的逻辑顺序来存储和访问数据。线性表的定义是一个有限个相同类型的数据元素的集合，每个数据元素都有一个唯一的前驱和后继。线性表可以用顺序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值