数据结构学习—线性表

最新推荐文章于 2022-03-01 00:01:34 发布
最新推荐文章于 2022-03-01 00:01:34 发布
阅读量202 收藏 1
点赞数
分类专栏： 数据结构学习笔记 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jikuidongke5461/article/details/104977864
版权

线性表

线性表的概念

  • 定义
    线性表是由n(n>=0）个类型相同的数据元素组成的有限序列，数据元素之间是一对一的关系，即每个数据元素最多有一个直接前驱和一个直接后驱。
  • 特点：
    1. 同一性：线性表必须由同类数据元素组成
    2. 有穷性：线性表由有限个数据元素组成，表长就是表中数据元素个数
    3. 有序性：线性表中相邻元素之间存在着序偶关系。

线性表的顺序存储

  • 定义
    是指用一组地址连续的存储单元依次线性表中的各个元素，使得线性表在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中。
  • C语言定义
#define MAXSIZE 20
typedef int ElemType;
typedef struct
{
	ElemType elem[MAXSIZE];
	int length;
} SeqList;
SeqList *L;
  • 基本运算
// 查找
//
// Created by deng5 on 2020/3/25.
//
#include <stdio.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;
typedef int ElemType;


Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

typedef struct
{
    ElemType data[MAXSIZE];        //定义数据，用于储存元素
    int length;                    //线性表当前长度
}SeqList;

Status InitList(SeqList *L) //初始化顺序线性表 
{
    L->length=0;
    return OK;
}


Status ListEmpty(SeqList L) //判断表是否为空
{
    if(L.length==0)
        return TRUE;
    else
        return FALSE;
}

Status ClearList(SeqList *L)  //将表L重置为空表 
{
    L->length=0;
    return OK;
}

int ListLength(SeqList L) // 返回L中数据元素个数 
    return L.length;
}


Status GetElem(SeqList L, int i, ElemType *e) //返回第i个元素的值
{
    if(L.length==0 || i<1 || i>L.length)   //判断i是否越界
        return ERROR;
    *e=L.data[i-1];

    return OK;
}


int LocateElem(SeqList L, ElemType e)  //返回表中第一个值为e的元素，在表中位置，
{
    int i;
    if (L.length==0)
        return 0;
    for(i=0;i<L.length;i++)
    {
        if (L.data[i]==e)
            break;
    }
    if(i>=L.length)
        return 0;

    return i+1;
}



Status ListInsert(SeqList *L, int i, ElemType e)  //在第i个元素之前插入元素
{
    int k;
    if (L->length==MAXSIZE)  //顺序线性表是否已满 
        return ERROR;
    if (i<1 || i>L->length+1)//插入位置是否合法
        return ERROR;

    if (i<=L->length) //若插入数据位置不在表尾则需要将要插入位置之后的数据元素向后移动一位 
    {
        for(k=L->length-1;k>=i-1;k--)  
            L->data[k+1]=L->data[k];
    }
    L->data[i-1]=e;      //插入新元素
    L->length++;         //表长+1

    return OK;
}

//删除第i个元素，并返回其值
Status ListDelete(SeqList *L, int i, ElemType *e)
{
    int k;
    if (L->length==0)               //判断表是否为空
        return ERROR;
    if (i<1 || i>L->length)         //删除元素位置是否合法
        return ERROR;
    *e=L->data[i-1];
    if (i<L->length)                //如果删除不是最后位置，则需将删除位置后继元素前移 
    {
        for(k=i;k<L->length;k++)
            L->data[k-1]=L->data[k];
    }
    L->length--;
    return OK;
}


//遍历所有元素，打印元素值
Status ListTraverse(SeqList L)
{
    int i;
    for(i=0;i<L.length;i++)
        visit(L.data[i]);
    printf("\n");
    return OK;
}
//求两个表的并集(合并表)
void unionL(SeqList *La, SeqList Lb)
{
    int La_len,Lb_len,i;
    ElemType e;
    La_len=ListLength(*La);
    Lb_len=ListLength(Lb);
    for (i=1;i<=Lb_len;i++)
    {
        GetElem(Lb,i,&e);
        if (!LocateElem(*La,e))
            ListInsert(La,++La_len,e);
    }
}

int main()
{

    SeqList L;
    SeqList Lb;

    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L后：L.length=%d\n",L.length);
    for(j=1;j<=5;j++)
        i=ListInsert(&L,1,j*j);
    printf("在L的表头依次插入1～5后：L.data=");
    ListTraverse(L);

    printf("L.length=%d \n",L.length);
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    i=ClearList(&L);
    printf("清空L后：L.length=%d\n",L.length);
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    for(j=1;j<=10;j++)
        ListInsert(&L,j,j);
    printf("在L的表尾依次插入1～10后：L.data=");
    ListTraverse(L);

    printf("L.length=%d \n",L.length);

    ListInsert(&L,1,0);
    printf("在L的表头插入0后：L.data=");
    ListTraverse(L);
    printf("L.length=%d \n",L.length);

    GetElem(L,5,&e);
    printf("第5个元素的值为：%d\n",e);
    for(j=3;j<=4;j++)
    {
        k=LocateElem(L,j);
        if(k)
            printf("第%d个元素的值为%d\n",k,j);
        else
            printf("没有值为%d的元素\n",j);
    }


    k=ListLength(L); // k为表长 
    for(j=k+1;j>=k;j--)
    {
        i=ListDelete(&L,j,&e); // 删除第j个数据 
        if(i==ERROR)
            printf("删除第%d个数据失败\n",j);
        else
            printf("删除第%d个的元素值为：%d\n",j,e);
    }
    printf("依次输出L的元素：");
    ListTraverse(L);

    j=5;
    ListDelete(&L,j,&e); //删除第5个数据 
    printf("删除第%d个的元素值为：%d\n",j,e);

    printf("依次输出L的元素：");
    ListTraverse(L);

    //构造一个有10个数的Lb
    i=InitList(&Lb);
    for(j=6;j<=15;j++)
        i=ListInsert(&Lb,1,j);

    unionL(&L,Lb);

    printf("依次输出合并了Lb的L的元素：");
    ListTraverse(L);

    return 0;
}

单链表

单链表的概念

  • 单链表
    链表中每个节点只有一个指针域
    在这里插入图片描述
  • C语言定义
//节点定义
typedef struct  Node
{
    ElemType data;
    struct Node *next;
}LNode,*LinkList;
  • 基本运算
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 

typedef int Status;
typedef int ElemType;


Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList; //定义单链表结构

//初始化顺序线性表 
Status InitList(LinkList *L) 
{
    *L=(LinkList)malloc(sizeof(Node)); //产生头结点,并使L指向此头结点 
    if(!(*L)) //存储分配失败 
        return ERROR;
    (*L)->next=NULL; //指针域为空

    return OK;
}

//判断表是否为空
Status ListEmpty(LinkList L)
{
    if(L->next)
        return FALSE;
    else
        return TRUE;
}

//将表置为空表
Status ClearList(LinkList *L)
{
    LinkList p,q;
    p=(*L)->next;           //p指向第一个结点
    while(p)                //没到表尾
    {
        q=p->next;
        free(p);			//释放节点
        p=q;
    }
    (*L)->next=NULL;        //将头结点指针域置空
    return OK;
}

//计算并返回L中数据元素个数
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next; //p指向第一个结点 
    while(p)
    {
        i++;
        p=p->next;
    }
    return i;
}

//返回L中第i个数据元素的值
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j;
    LinkList p;		
    p = L->next;		//让p指向链表L的第一个结点 
    j = 1;		
    while (p && j<i)  //p不为空或者还没计算第i值时，继续循环 
    {
        p = p->next;  
        ++j;
    }
    if (!p||j>i)
        return ERROR;  //第i个元素不存在 
    *e = p->data;   //得到第i个元素的值
    return OK;
}

//返回表中第一个值为e的元素位置
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e) 
            return i;
        p=p->next;
    }

    return 0;
}


//在第i个元素之前插入元素
Status ListInsert(LinkList *L,int i,ElemType e)
{
    int j;
    LinkList p,s;
    p = *L;
    j = 1;
    while (p && j < i)     //寻找第i个结点 
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
        return ERROR;   //第i个元素不存在 
    s = (LinkList)malloc(sizeof(Node));  // 生成新结点
    s->data = e;
    s->next = p->next;      //将p的后继结点赋值给s的后继
    p->next = s;          //将s赋值给p的后继 
    return OK;
}

//删除第i个位置的元素
Status ListDelete(LinkList *L,int i,ElemType *e)
{
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while (p->next && j < i)	//遍历寻找第i个元素 
    {
        p = p->next;
        ++j;
    }
    if (!(p->next)||j>i)
        return ERROR;           //第i个元素不存在 
    q = p->next;
    p->next = q->next;			//将q的后继赋值给p的后继 
    *e = q->data;               //将删除节点元素值赋值给e 
    free(q);                    //释放节点
    return OK;
}

//遍历所有元素，并打印
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

//建立带表头结点的链表（头插法）
void CreateListHead(LinkList *L, int n)
{
    LinkList p;
    int i;
    srand(time(0));                         //初始化随机数种子 
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;                      //先建立一个带头结点的空表 
    for (i=0; i<n; i++)
    {
        p = (LinkList)malloc(sizeof(Node)); //生成新结点 
        p->data = rand()%100+1;             //随机生成100以内的数字
        p->next = (*L)->next;
        (*L)->next = p;						//插入元素到表头
    }
}

//建立带表头结点的链表（尾插法）
void CreateListTail(LinkList *L, int n)
{
    LinkList p,r;
    int i;
    srand(time(0));                      
    *L = (LinkList)malloc(sizeof(Node)); //建立链表
    r=*L;                                // r为指向尾部的结点 
    for (i=0; i<n; i++)
    {
        p = (Node *)malloc(sizeof(Node)); 
        p->data = rand()%100+1;           
        r->next=p;                        //将表尾终端结点的指针指向新结点 
        r = p;                            //将当前的新结点定义为表尾终端结点
    }
    r->next = NULL;                       //末尾置空
}

int main()
{
    LinkList L;
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L后：ListLength(L)=%d\n",ListLength(L));
    for(j=1;j<=5;j++)
        i=ListInsert(&L,1,j);
    printf("在L的表头依次插入1～5后：L.data=");
    ListTraverse(L);

    printf("ListLength(L)=%d \n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    i=ClearList(&L);
    printf("清空L后：ListLength(L)=%d\n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    for(j=1;j<=10;j++)
        ListInsert(&L,j,j);
    printf("在L的表尾依次插入1～10后：L.data=");
    ListTraverse(L);

    printf("ListLength(L)=%d \n",ListLength(L));

    ListInsert(&L,1,0);
    printf("在L的表头插入0后：L.data=");
    ListTraverse(L);
    printf("ListLength(L)=%d \n",ListLength(L));

    GetElem(L,5,&e);
    printf("第5个元素的值为：%d\n",e);
    for(j=3;j<=4;j++)
    {
        k=LocateElem(L,j);
        if(k)
            printf("第%d个元素的值为%d\n",k,j);
        else
            printf("没有值为%d的元素\n",j);
    }


    k=ListLength(L); 
    for(j=k+1;j>=k;j--)
    {
        i=ListDelete(&L,j,&e); //删除第j个数据
        if(i==ERROR)
            printf("删除第%d个数据失败\n",j);
        else
            printf("删除第%d个的元素值为：%d\n",j,e);
    }
    printf("依次输出L的元素：");
    ListTraverse(L);

    j=5;
    ListDelete(&L,j,&e); //删除第5个数据
    printf("删除第%d个的元素值为：%d\n",j,e);

    printf("依次输出L的元素：");
    ListTraverse(L);

    i=ClearList(&L);
    printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));
    CreateListHead(&L,20);
    printf("整体创建L的元素(头插法)：");
    ListTraverse(L);

    i=ClearList(&L);
    printf("\n删除L后：ListLength(L)=%d\n",ListLength(L));
    CreateListTail(&L,20);
    printf("整体创建L的元素(尾插法)：");
    ListTraverse(L);


    return 0;
}

循环链表

循环链表是一个首尾相接的链表
在这里插入图片描述

双向链表

在单链表的每个节点再增加一个指向前趋的指针域prior

  • 结构
    在这里插入图片描述
typedef struct DNode
{
	ElemType data;
	struct DNode *prior,*next;
}DNode, *DoubleList;
派大星是个小码农
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】之 线性表详解
weixin_30664539的博客
02-10 634
线性表（Linear List） 基本概念 线性表是由n（n>=0）个类型相同数据元素组成的有限序列。数据元素可由若干个数据对象组成，且一个线性表中的数据元素必须属于同一数据对象。 线性表示n个类型相同数据元素的有限序列，对n>0,除第一个元素无直接前驱，最后一个元素无直接后继外，其余的每个数据元素只有一个直接前驱和直接后继。 线性表的逻辑结构如图： 线性表具有如下...
线性表基础知识
qq_45816034的博客
07-19 531
线性表是由n（n≥0）个相同类型的数据元素组成的有限序列。线性表有唯一的开始和结束，除了第一个元素外，每个元素都有唯一的直接前驱；除了最后一个元素外，每个元素都有唯一的直接后继。 线性表有两种存储方式：顺序存储和链式存储。 采用顺序存储的线性表称为顺序表，采用链式存储的线性表称为链表。 顺序表 逻辑上相邻的数据在计算机内的存储位置也是相邻的。 顺序表的优点：操作简单，存储密度高，可以随机存取。 顺序表的缺点：需要预先分配大量的空间，插入和删除操作需要移动大量元素。 单链表 ...
数据结构之线性表
总结论文中的算法并给出论文的复现代码
02-09 4036
线性表是最基本且最常用的一种线性结构，同时也是其他数据结构的基础。本文首先介绍线性表的定义和特点，然后对线性表的主要操作用C语言程序进行实现，最后给出线性表的应用实例。
线性表（Linear List）是由n（n≥0）个相同类型的数据元素组成的有限序列
BLOG域名:programb.blog.csdn.net
03-01 3002
线性表的特点是每个元素都有固定的位置，每个元素都有一个前驱和一个后继，除了第一个元素没有前驱外，最后一个元素没有后继。在实际应用中，根据具体需求，可能需要对线性表进行各种扩展，例如增加栈、队列、树等数据结构的功能。另一个问题是线性表的动态调整。在应用中，线性表的长度可能会不断变化，因此需要动态调整线性表的长度。例如，当线性表中的元素数量超过一定阈值时，可以将线性表分成两个子表，分别存储前半部分和后半部分元素。另外，还有一些扩展问题需要解决，如处理线性表中的重复元素、判断线性表是否包含特定元素等。
线性表的概念及运算
weixin_51638861的博客
07-28 904
线性表的概念及运算线性表的逻辑结构定义特点线性表的运算基本运算线性表的顺序存储代码 线性表的逻辑结构 定义 线性表是n(n >= 0)个数据元素组成的有限序列。在表中，元素之间存在着线性的逻辑关系：表中有且仅有一个开始结点；有且仅有一个终端结点；除开始结点外，表中的结点均只有一个前驱结点(predecessor);处终端结点外，表中每个结点都仅有一个后继结点(successor)。根据它们之间的关系可以排成一个线性序列，记作：(a1,a2,…,an)。 在这里ai属于同一数据对象，具有相同的数据类型。
数据结构之线性表.rar
04-07
线性表是计算机科学中一种基础且重要的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在本资料“数据结构之线性表.rar”中，我们将探讨如何使用C++实现线性表，并涵盖增、删、改、查等基本操作。 1. **...
用C#学习数据结构之线性表
12-22
　线性表是简单、基本、常用的数据结构。线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即：（1）除第一个位置的...
数据结构考研线性表
06-04
这是数据结构中C语言版部分线性表的学习记录，有关动态在我的博客里有对应。方便大家参考。
数据结构实验线性表实验报告（代码是java编写的）
05-10
实验报告涉及的知识点主要集中在数据结构中的线性表，包括顺序表和循环链表的实现与操作。线性表是一种逻辑结构，其中的数据元素按照线性顺序排列，可以通过顺序存储或链式存储来实现。 1. **顺序表**：顺序表是用...
数据结构中线性表的应用，约瑟夫环算法 便于数据结构的学习.zip
最新发布
02-01
通过学习线性表和约瑟夫环算法，我们可以更好地理解数据结构的原理，提高编程能力，同时也能锻炼解决问题的逻辑思维。在C#环境下，结合.NET框架提供的便利工具，实现这些算法更加便捷。对于初学者而言，这是一次极好...
数据结构基础知识（一）——链表
xinyu2015的博客
05-20 3277
1.  链表 链表作为最基本的数据结构，存储特点：可以用任意一组存储单元来存储单链表中的数据元素(即存储单元可以是不连续的)，其中一个结点(数据域,地址域)，数据域:数据元素，地址域：链表元素的前驱或后继元素的地址。一个线性链表必须使用一个头指针记住元素a0的节点地址。 时间复杂度：1)O(1):isEmpty;               O(n):toString();size();ge
王道课后习题2.3.3：单链表从尾到头反向输出每个结点的值
qq_34941153的博客
08-20 3454
题目描述： 设L为带头结点的单链表，编写算法实现从尾到头反向输出每个结点的值 算法思想： 核心代码： void ReversePrintList(LNode* L) { if(L==NULL) return; ReversePrintList(L->next); printf("%d",L->data); } 这个算法需要在main（）...
java实现单链表
热门推荐
congge
03-06 4万+
链表是java数据结构中一种很基础很常见却也很重要的数据结构，JDK中许多内置jar包基于单链表实现，比如像我们熟悉的linkedList等，为什么要使用链表呢？ 我们知道java中很多集合的底层是基于数组实现的，数组有一个很重要的结构就是索引，通过索引可以快速定位数据，并对数据进行删除等操作，但问题是，我们的业务中，数组有自身的局限性，如果知道索引还好，如果不知道索引就需要一个个遍历查找，然后再...
复习基础-数据结构-链表介绍( 1 )
weixin_34233618的博客
06-14 108
2019独角兽企业重金招聘Python工程师标准>>> ...
一个程序学会链表的创建与使用_C语言
瓷丁
03-21 338
约瑟夫环（Josephus）问题 约瑟夫环（Josephus）问题是由古罗马的史学家约瑟夫（Josephus）提出的，他参加并记录了公元66—70年犹太人反抗罗马的起义。约瑟夫作为一个将军，设法守住了裘达伯特城达47天之久，在城市沦陷之后，他和40名死硬的将士在附近的一个洞穴中避难。在那里，这些叛乱者表决说“要投降毋宁死”。于是，约瑟夫建议每个人轮流杀死他旁边的人，而这个顺序是由抽签决定的。约瑟...
数据结构03——链表
寒山道杳
07-26 524
  一.开头语 对于链表是我们一个非常熟悉的数据结构，它的定义：链表是一种递归的数据结构，它或者为空（null），或者指向一个节点（node）的引用，该节点含有一个泛型的元素和一个指向另一条链表的引用。当然这只是一种比较教科书式的定义。对于链表的数据是存储在“节点”中的，它的优点是真正的动态，不需要处理固定容量的问题，但它的缺点是丧失了随机访问的功能。因此它与数组相比，其优缺点就非常明显了。在...
链表
weixin_45087108的博客
02-29 133
链表 #include "node.h" int main(int argc,char const *argv[]) { Node *head=NULL;//定义一个Node的指针，叫做head,一开始等于NULL，一开始没有任何东西 int number; do{ scanf("%d",&number); if(number!=-1...
基础的数据结构就是数组和链表
qq_41450275的博客
10-18 271
学了这么久的数据结构和算法，今天突然顿悟，基础的数据结构就是数组和链表， 而后面更加复杂的 树 队列 图 等等 都可以通过数组和链表等方式存储， 出现树 队列 图 等数据结构的原因 就是为了解决 部分问题处理过程中时间复杂度过高的问题， 所以数据结构就是为了算法而生的！ 尤其是学习了时间复杂度过后 在工作和学习过程中 就应该分析自己的代码复杂度 以进行优化或者选择更好的数据结构和算法！这样才能写出更好的代码更好的解决问题 转载数据结构与算法之美：https://time.geekbang.org/c.
【Java基础数据结构】链表相关练习
Sampson_S的博客
03-19 142
单链表相关练习 判断链表中是否存在环，并返回环的入口 public Entry<T> isLoopAndGetEntry(){ if(isEmpty() || size == 1){ return null; } Entry<T> fast = headEntry, slow = headEntry;//快慢引用 -> 两者...
数据结构-线性表详解
"沈阳工程学院信息工程系的数据结构课件，主要涵盖了线性表的概念、表示及实现" ...理解线性表的定义、结构特征和各种操作，以及其不同的存储实现（如顺序表和链表），对于深入学习和应用数据结构至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值