数据结构--线性表

最新推荐文章于 2024-09-30 21:20:40 发布
最新推荐文章于 2024-09-30 21:20:40 发布
阅读量193 收藏 4
点赞数 5
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80320721/article/details/141193731
版权

1.线性表的定义

        相较于数组，线性表可以有效的利用存储空间，是一种由同一数据类型构成的有序序列的线性结构。对于线性表的实现，有利用数组连续存储空间的顺序存储方式，也有通过链表实现的存储方式。为了加深对线性表的理解，以下对线性表的操作都将使用c语言进行演示：

2.顺序表的各种操作：

2.1 定义

#include<stdio.h>
#include<stdlib.h>
#define max 105
//实现一个存放int类型数据的顺序表
typedef struct ArrayList
{
    int *data;//指针模拟数组
    int maxsize;//数组的最大容量
    int length;//顺序表中元素的实际个数
}MyArray;

2.2 初始化

//初始化顺序表
MyArray initArray()
{
    MyArray b;
    //申请最大容量空间
    b.data=(int*)malloc(sizeof(int)*max);
    if(b.data==NULL)
    {
        printf("内存分配失败");
    }
    //顺序表最大容量
    b.maxsize=max;
    //顺序表实际容量
    b.length=0;
    return b;
}

2.3 插入(顺序插入与指定插入)

//顺序插入
void add(MyArray *a,int k)
{
    if(a->length<a->maxsize)
    {
        a->data[a->length]=k;
        a->length++;
    }
    else{
        printf("顺序表已满，不能插入\n");
    }
}

//制定位置i插入k
void insert(MyArray *a,int i,int k)
{

    if(a->length<a->maxsize)
    {
        //空出i的位置
        for(int j=a->length-1;j>=i;j--)
        {
            a->data[j+1]=a->data[j];
        }
        a->data[i]=k;
        a->length++;
    }
    else{
        printf("顺序表已满，不能插入\n");
    }  
}

2.4 查找

//查找某个数据的的位置
int  find(MyArray *a,int k)
{
    for(int i=0;i<a->length;i++)
    {
        if(a->data[i]==k)
        {
            return i;
        }
    }
    return -1;//k不存在
}

2.5 删除

//删除数据k
void delet(MyArray *a,int k)
{
    //查找k的位置
    int i=find(a,k);
    if(i==-1)
    {
        printf("被删除的数据不存在\n");
    }
    for(int j=i;j<a->length-1;j++)
    {
        a->data[j]=a->data[j+1];
    }
    a->length--;
}

 2.5 修改

//将k改为x
void change(MyArray *a,int k,int x)
{
    //查找k的位置
    int i=find(a,k);
    if(i==-1)
    {
        printf("被修改的数据不存在\n");
    }
    a->data[i]=x;

}

3.链式表的各种操作

        链表相较于顺序表，它的存储空间并不固定，而是通过上一节点的指针域链接，因此再链表的节点结构体中，不仅需要存储数据，还需要有个指针域，存储下一节点的地址或者是上一节点的地址（双向链表）。

3.1 单链表

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

typedef struct Node
{
    int data;//节点数据
    struct Node *next;//下一个数据所在节点地址
}Node,*LinkList;
//LinkList=Node*,增加可读性：LinkList指头指针，Node*节点的指针，两者其实没有本质区别

//c中main外调用函数必须申明
Node* findNode(LinkList L,int k);

//初始化带头节点的空链表
LinkList initLinkList()
{
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
    }
    else
    {
        s->next=NULL;
    }
    
}

//头插法
LinkList HeadInsert(LinkList L,int k)
{
    //先申请新节点保存数据k
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
        return L;
    }
    else
    {
        s->data=k;
        s->next=L->next;
        L->next=s;
        return L;
    }
    return L;
}

//尾插法
LinkList RearInsert(LinkList L,int k)
{
    Node* p=L;//p先指向头结点
    while(p->next!=NULL)
    {
        p=p->next;
    }
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
    }
    else
    {
        s->data=k;
        s->next=NULL;
        p->next=s;
    }
    return L;
}

//中间插入
LinkList mid_insert(LinkList L,int x,int k)
{
    Node* p=findNode(L,x);
    if(p==NULL)
    {
       printf("数据%d不存在，插入失败\n",x);
       return L; 
    }
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
    }
    else
    {
        s->data=k;
        s->next=p->next;
        p->next=s;
    }
    return L;
}

//删除k所在的节点位置
LinkList Delet(LinkList L,int k)
{
    if(L->next==NULL)
    {
        printf("空链表，删除失败\n");
        return L;
    }
    Node* pre=L;
    Node* p=L->next;
    while(p!=NULL&&p->data!=k)
    {
        pre=p;
        p=p->next;
    }
    if(p==NULL)
    {
       printf("数据%d不存在，删除失败\n",k);
       return L; 
    }
    pre->next=p->next;
    free(p);
    p=NULL;//防止p成为野指针

    return L;

}

//查找数据k所在节点地址
Node* findNode(LinkList L,int k)
{
    Node* p=L->next;
    while(p!=NULL&&p->data!=k)
    {
        p=p->next;
    }
    return p;
}

void printff(LinkList L)
{
    Node* p=L->next;
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
int main()
{
    LinkList L=NULL;
    //初始化空链表 
    L=initLinkList();
    //头插法插入
    L=HeadInsert(L,5);
    L=HeadInsert(L,8);
    L=HeadInsert(L,6);
    printff(L);
    //尾插
    L=RearInsert(L,9);
    L=RearInsert(L,1);
    printff(L);
    //中间插入
    L=mid_insert(L,5,7);
    printff(L);
    //删除
    L=Delet(L,8);
    printff(L);

    return 0;
}

3.2 双向链表

#include <stdio.h>
#include <stdlib.h>
//带头结点的双链表的节点结构
typedef struct Node
{
    int data;//节点数据
    struct Node* next;//下一个数据所在节点地址
    struct Node* pre;//上一个数据所在节点地址
}Node,*LinkList;
//LinkList=Node*,增加可读性：LinkList指头指针，Node*节点的指针，两者其实没有本质区别

LinkList find(LinkList L,int k);

//初始化带头结点的空链表
LinkList initlist()
{
    Node* p=(Node*)malloc(sizeof(Node));
    if(p==NULL)
    {
        printf("空间分配失败\n");
    }
    else
    {
        p->next=p->pre=NULL;
    }
    return p;
}

//头插法
LinkList headInsert(LinkList L, int k)
{
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
        return L;
    }    
    s->data=k;

    s->pre=L;
    s->next=L->next;
    L->next=s;
    if(s->next!=NULL)//空节点
    {
        s->next->pre=s; 
    }

    return L;
}

//尾插法
LinkList rearInsert(LinkList L,int k)
{
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
        return L;
    }    
    s->data=k;

    //找尾节点
    Node* p=L;
    while(p->next!=NULL)
    {
        p=p->next;
    }
    s->next=p->next;
    s->pre=s;
    p->next=s;

    return L;    
}

//中间插入,数据x后面插入数据k
LinkList midInsert(LinkList L,int x,int k)
{
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
        return L;
    }    
    s->data=k;

    //找x所在节点
    Node* p=find(L,x);
    if(p==NULL)
    {
       printf("数据%d不存在，插入失败\n",x);
       return L; 
    }

    s->pre=p;
    s->next=p->next;
    p->next=s;
    if(s->next!=NULL)//空节点
    {
        s->next->pre=s; 
    }

    return L;

}

//查找
Node* find(LinkList L,int k)
{
    Node* p=L->next;
    while(p!=NULL&&p->data!=k)
    {
        p=p->next;
    }
    return p;
}

//删除
LinkList delet(LinkList L,int k)
{
    if(L->next==NULL)
    {
        printf("空链表，删除失败\n");
        return L;
    }
    Node* p=L->next;
    if(p==NULL)
    {
       printf("数据%d不存在，删除失败\n",k);
       return L; 
    }

    p->pre->next=p->next;
    if(p->next!=NULL)
    {
        p->next->pre=p->pre;
    }

    //傻瓜式
    // Node* pp=p->pre;
    // Node* pn=p->next;
    // pp->next=pn;
    // if(pn!=NULL)
    // {
    //     pn->pre=pp;
    // }
    free(p);
    p=NULL;
    return L;
}

void printff(LinkList L)
{
    Node* p=L->next;
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}

int main()
{
    LinkList L=initlist();
    L=headInsert(L,4);
    L=headInsert(L,5);
    L=headInsert(L,6);
    printff(L);

    L=rearInsert(L,7);
    L=rearInsert(L,9);
    printff(L);

    L=midInsert(L,5,1);
    L=midInsert(L,9,8);
    printff(L);

    L=delet(L,6);
    L=delet(L,7);
    printff(L);

    return 0;
}

3.3 循环链表（单向与双向）

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

typedef struct Node
{
    int data;//节点数据
    struct Node *next;//下一个数据所在节点地址
}Node,*LinkList;

Node* findNode(LinkList L,int k);

//初始化带头节点的空循环单链表
LinkList initLinkList()
{
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
    }
    else
    {
        s->next=s;
    }
    return s;
}

//头插法
LinkList HeadInsert(LinkList L,int k)
{
    //先申请新节点保存数据k
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
        return L;
    }
    else
    {
        s->data=k;
        s->next=L->next;
        L->next=s;
        return L;
    }
    return L;
}

//尾插法
LinkList RearInsert(LinkList L,int k)
{
    Node* p=L;//p先指向头结点
    while(p->next!=L)
    {
        p=p->next;
    }
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
    }
    else
    {
        s->data=k;
        s->next=L;
        p->next=s;
    }
    return L;
}

LinkList mid_insert(LinkList L,int x,int k)
{
    Node* p=findNode(L,x);
    if(p==L)
    {
       printf("数据%d不存在，插入失败\n",x);
       return L; 
    }
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
    }
    else
    {
        s->data=k;
        s->next=p->next;
        p->next=s;
    }
    return L;
}

//删除k所在的节点位置
LinkList Delet(LinkList L,int k)
{
    if(L->next==L)
    {
        printf("空链表，删除失败\n");
        return L;
    }
    Node* pre=L;
    Node* p=L->next;
    while(p!=L&&p->data!=k)
    {
        pre=p;
        p=p->next;
    }
    if(p==L)
    {
       printf("数据%d不存在，删除失败\n",k);
       return L; 
    }
    pre->next=p->next;
    free(p);
    p=NULL;//防止p成为野指针

    return L;

}


//查找数据k所在节点地址
Node* findNode(LinkList L,int k)
{
    Node* p=L->next;
    while(p!=L&&p->data!=k)
    {
        p=p->next;
    }
    return p;
}

void printff(LinkList L)
{
    Node* p=L->next;
    while(p!=L)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}

int main()
{
    LinkList L=NULL;
    //初始化空链表 
    L=initLinkList();
    //头插法插入
    L=HeadInsert(L,5);
    L=HeadInsert(L,8);
    L=HeadInsert(L,6);
    printff(L);
    //尾插
    L=RearInsert(L,9);
    L=RearInsert(L,1);
    printff(L);
    //中间插入
    L=mid_insert(L,5,7);
    printff(L);
    //删除
    L=Delet(L,8);
    printff(L);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
//带头结点的循环双链表的节点结构
typedef struct Node
{
    int data;//节点数据
    struct Node* next;//下一个数据所在节点地址
    struct Node* pre;//上一个数据所在节点地址
}Node,*LinkList;
//LinkList=Node*,增加可读性：LinkList指头指针，Node*节点的指针，两者其实没有本质区别

LinkList find(LinkList L,int k);

//初始化带头结点的空链表
LinkList initlist()
{
    Node* p=(Node*)malloc(sizeof(Node));
    if(p==NULL)
    {
        printf("空间分配失败\n");
    }
    else
    {
        p->next=p->pre=p;
    }
    return p;
}

//头插法
LinkList headInsert(LinkList L, int k)
{
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
        return L;
    }    
    s->data=k;

    s->pre=L;
    s->next=L->next;
    L->next=s;
    s->next->pre=s; 

    return L;
}

//尾插法
LinkList rearInsert(LinkList L,int k)
{
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
        return L;
    }    
    s->data=k;

    //找尾节点
    Node* p=L;
    while(p->next!=L)
    {
        p=p->next;
    }
    s->next=p->next;
    s->pre=s;
    p->next=s;
    s->next->pre=s;

    return L;    
}

//中间插入,数据x后面插入数据k
LinkList midInsert(LinkList L,int x,int k)
{
    Node* s=(Node*)malloc(sizeof(Node));
    if(s==NULL)
    {
        printf("空间分配失败\n");
        return L;
    }    
    s->data=k;

    //找x所在节点
    Node* p=find(L,x);
    if(p==L)
    {
       printf("数据%d不存在，插入失败\n",x);
       return L; 
    }

    s->pre=p;
    s->next=p->next;
    p->next=s;
    s->next->pre=s;

    return L;

}

//查找
Node* find(LinkList L,int k)
{
    Node* p=L->next;
    while(p!=L&&p->data!=k)
    {
        p=p->next;
    }
    return p;
}

//删除
LinkList delet(LinkList L,int k)
{
    if(L->next==L)
    {
        printf("空链表，删除失败\n");
        return L;
    }
    Node* p=L->next;
    if(p==L)
    {
       printf("数据%d不存在，删除失败\n",k);
       return L; 
    }

    p->pre->next=p->next;
    p->next->pre=p->pre;

    free(p);
    p=NULL;
    return L;
}

void printff(LinkList L)
{
    Node* p=L->next;
    while(p!=L)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}

int main()
{
    LinkList L=initlist();
    L=headInsert(L,4);
    L=headInsert(L,5);
    L=headInsert(L,6);
    printff(L);

    L=rearInsert(L,7);
    L=rearInsert(L,9);
    printff(L);

    L=midInsert(L,5,1);
    L=midInsert(L,9,8);
    printff(L);

    L=delet(L,6);
    L=delet(L,7);
    printff(L);

    return 0;
}

        实际上作为最简单的数据结构，链表在操作中要遵守的原则就是不能断表，其他也没什么难点，复习时根据代码画画结构图，就能很清晰的明白线性表的相关原理与操作了。

4.两者的选择

        简单的来说，顺序表操作比较简单，表长变化不大，适合查找某个元素，但没办法动态分配空间，不适合经常进行插入和删除的情况。而链表就适用插入和删除，缺点是存储密度低，查找时间复杂度相对较高。

Vastog
关注
数据结构-线性表
u013341672的博客
09-21 551
循环链表时另一种链式存储结构，它的特点是最后一个节点的指针指向头节点，整个链表形成一个环。循环链表可有单链的循环链表，也可以有多重链的循环链表。循环双链表不仅尾结点指向头结点，且头结点的prior指向尾结点，判断为空时，只要看尾结点下一个是否指向头结点。双向链表 双向链表中存在两个指针域，一个指向直接后继，一个指向直接前驱。是用数组来表示链表,用数组元素的下标来模拟链表的指针.来定义的链表,属于静态储存分配, 因而叫做静态链表.部分算法题目 --力扣。
数据结构--线性表初始化和插入数据
aj的博客
05-17 1282
线性表 按存储方式不同 连续存储空间分组称为顺序存储 非连续存储空间称为链表 线性表基本概念 线性结构是一种最简单且常用的数据结构，基本的特点是节点之间满足线性关系。 线性表是零个或者多个数据元素的有限序列，数据元素之间是顺序的，数据元素个数是有限的，数据元素类型必须相同。 顺序存储 动态数据 默认数组不足之处：不能实现动态增长。动态数组就为解决上述问题。 首先我们要明白数组是一块连续的内存空间。 需要我们提前了解的是： 1、我们必须知道存储数据元素的空间首地址 2、元素的个数 3、数组容量 插入数据代码
数据结构--线性表之顺序表
touchinaiyou的博客
04-24 813
数据结构--线性表之顺序表
数据结构--线性表问题总结
qq_74896248的博客
09-17 554
for循环语句中的逻辑错误，在这个逻辑中其实只循环了一次，第一次如果判断成功，不报错，而只要不是第一次能判断成功，那么都回到else语句中，直接return -1。问题：在find函数中，for循环中不可以写作int i=0；应该在for循环外部定义再在for循环赋值。而当查找为1时，即第一次if内语句未实现，而else语句实现，就会报错。一种可能，vs2010支持不是c99，无法在for中定义。
数据结构--线性表顺序存储
Seinlvan的博客
09-29 723
1 线性表定义 由零个或多个数据元素组成的有限序列。 数学定义 若将线性表记为（a1,…,ai-1,ai,ai+1,…an）,则表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素,ai+1是ai的直接后继元素。 所以线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。 2 抽象数据类型 ADT 一个数学模型及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。 ADT 抽象数据类型名 Data 数据元素
大话数据结构--线性表
全网粉丝10W+、全栈领域优质创作者、掘金、阿里云等社区博客专家、专注于全栈领域和毕业项目实战
11-13 1122
线性表总目录前言三、线性表3.1 线性表的定义3.1.1实例3.2线性表的抽象数据类型3.3 线性表的顺序存储结构3.3.1 顺序存储定义3.3.2顺序存储方式3.3.3数据长度与线性表长度区别3.3.4 地址计算方法3.4 顺序存储结构的插入与删除3.4.1 获得元素操作3.4.2 插入操作3.4.3 删除操作3.4.4 线性表顺序存储结构的优缺点3.5 线性表的链式存储结构3.5.1 顺序存储结构不足的解决办法3.5.2线性表链式存储结构定义1.数据域和指针域2.头指针3.5.3 头指针与头结点的异同3
数据结构-线性表-思维导图+小结
学习记录
11-12 2354
数据结构-线性表-思维导图+习题小结
数据结构 --- 线性表
weixin_47833373的博客
04-21 1058
线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。
数据结构 -线性表
weixin_59725429的博客
11-06 1431
线性表 定义：线性表（linear list）是具有相同特性的数据元素的一个有限序列。线性表的逻辑表示为：( a1，a2，…，ai，ai+1，…，an ) ai（1≤i≤n）表示第i（i表示逻辑位序）个元素。前驱与后继：线性表中相邻的数据元素ai-1和ai之间存在序偶关系(ai-1, ai)，即ai-1是ai的前驱， ai是ai-1的后继；a1 无前驱，an无后继，其它每个元素有且仅有一个前驱和一个后继。线性表长度：线性表中元素的个数。线性表L=（a1,a2,a3……
数据结构--线性表--思维导图.pdf
08-29
数据结构--线性表--思维导图.pdf 该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的...
数据结构-- 线性表
06-09
线性表（linear list）是最基本、最简单、也是最常用的一种数据结构 线性表中数据元素之间的关系是一对一的关系， 即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的 特征1：集合中必存在唯一的一个...
2.C-数据结构-线性表-线性表源码
09-07
2.C-数据结构-线性表-线性表源码
数据结构--线性表.cpp
03-08
数据结构--线性表.cpp
数据结构--线性表PPT学习教案.pptx
10-05
线性表是数据结构的基础，它是一个包含n个相同类型数据元素的有限序列，通常表示为(a1, a2, a3, ..., an)。在实际应用中，线性表非常常见，比如数学中的数列、英文字母表或者电话号码簿等。线性表的特征在于每个元素...
SwipeRefreshLayout和ViewPager滑动冲突的原因和正确的解决方式
杰森丶郭达斯坦森的博客
09-30 120
重写SwipeRefreshLayout的onIntercept方法就可以很简单的解决了。以下就是重写后的SwipeRefreshLayout，直接复制到项目就可以使用了。
每日学习一个数据结构-链表
wendao76的专栏
09-30 677
链表（Linked List）是一种常见的数据结构，由一系列节点（Node）组成，每个节点包含两个部分：一部分用于存储数据（称为数据域），另一部分用于存储指向下一个节点的指针（或链接、引用）。链表是线性数据结构的一种，但与数组不同的是，链表中的元素在内存中的存储位置不必连续。单向链表（Singly Linked List）每个节点包含一个数据域和一个指向下一个节点的指针。最后一个节点的指针为null或None，表示链表的结束。双向链表（Doubly Linked List）
数据结构——计数、桶、基数排序
2301_80401288的博客
09-27 770
数据结构——计数、桶、基数排序 求点赞收藏评论关注！！！ 感谢各位大佬的支持！！！
【笔记】选择题笔记+数据结构笔记
最新发布
m0_52024881的博客
09-30 305
连通分量是极大连通子图一个连通图的生成树是一个极小连通子图。
数据结构-线性表详解
"沈阳工程学院信息工程系的数据结构课件，主要涵盖了线性表的概念、表示及实现" 在计算机科学中，数据结构是组织和管理数据的重要工具，它研究如何高效地存储、检索和操作数据。线性表是数据结构中最基础也是最常用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值