（二）线性表——顺序表和链表

最新推荐文章于 2021-02-05 12:01:57 发布
最新推荐文章于 2021-02-05 12:01:57 发布
阅读量464 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 线性表 顺序表 双链表 循环链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FightFightFight/article/details/60871075
版权

2.线性表

2.1.定义、特点：

        1.线性表是一种线性结构。

        2.特点：1 数据元素之间是线性关系，即“一对一”；2 除第一个元素，每一个元素都有且只有一个前驱元素；3 除最后一个元素，每个元素都有且只有一个后继元素；4.均匀性；5 有序性；

2.1.2.基本操作：

        1.置线性表为空：L->len=0;

        2.求线性表的长度：L->len的长度；

        3.查询线性表中的元素：

        4.插入元素；

        5.删除元素；

2.2.线性表的顺序存储结构及运算实现：

2.2.1.顺序表：

        1.定义：线性表的顺序存储方式使用一组地址连续的存储单元按顺序依次存放线性表中的每一个元素，这种方式也称为顺序表；

        2.使用一维数组来存储顺序表最适合；

        3.顺序表的结构体：

        typedef struct
        {
            int data[MAXSIZE];
            int len;
        }SeqList;

2.2.2.顺序表的基本操作：

        1.顺序表的初始化：需要童泰分配存储空间，并置表长为0：

        SeqList *init_SeqList(){
            SeqList *L;
            L=(SeqList *)malloc(sizeof(SeqList));
            L->len=0;
        }

 

        2.建立顺序表：获取表长：

        void createList(SeqList *L){
            int n,i;
            puts("请输入表长：");
            scanf("%d",&n);
            for(i=1;i<=n;i++){
                scanf("%d",&i);
            } 
            L->len=n;
            puts("创建顺序表成功！！");
        }

 

        3.插入元素：将n~i的元素依次后移，然后将x放在i处，最后将表长增大1位；

        插入时可能出现的情况：1 L->len==MAXSIZE-1,说明表已经存满了;2 i<1||i>L->len,说明存储时不会连续；因此需要条件语句进行判断；

        void insertList(SeqList *L,int i,int x){
            int j;
            if(L-len==MAXSIZE-1){
                puts("存满！！");
                return; 
            }else if(i<1||i>L->len+1){
                puts("非法地址！！");
                return; 
            }else{
                for(j=L->len;j>=i;j--){
                    L->data[j+1]=L->data[j]; 
                }
                L->data[i]=x;
                L->len++;
                puts("插入成功！！");
            } 
        }

 

        4.删除运算：将i+1到n的值依次前移，然后将表长减1；

        删除元素时可能出现的情况：1 L->len==0,说明表为空;2 i<0||i>L->len,说明删除元素位置非法；

        int deleteList(SeqList *L,int i){
            int j;
            if(L->len==0){
                puts("表为空！！");
                return 0;
            }else if(i<1||i>L->len){
                puts("非法地址！！");
                return 0;
            }else{
                for(j=i+1;j<=L->len;j++)
                    L->data[j-1]=L->data[j]; 
            }
            return L->len--;
        }

 

        5.查找运算：从1开始到len依次查找，并返回下标值：

        int queryList(SeqList *L,int x){
            int i=1;
            while(i<L->len&&L->data[i]!=x){
                i++;
            }
            if(L->data[i]==x)
                return i;
            else
                return 0;
        }

 

2.3.线性表的链式存储结构及其实现：

2.3.1.单链表：每个结点只有一个指向后继结点的指针；

        1.顺序表的优点是可以随机存取表中的任意一个元素，但是缺点是需要移动大量元素，线性表的链式存储可以用连续或者不连续的存储空间来存储线性表中的元素，通过指针链接起各元素；

        2.链式存储需要占用额外的空间来存储指针；

        3.结点：通过指针建立起元素之间的线性关系，这个元素叫做结点；

        4.结点存放数据信息的部分叫做数据域，存放指向后继结点指针的部分叫做指针域；

        5.单链表的定义:

        typedef struct node{
            datatype data;
            struce node *next;
        }LNode;

 

        6.特点：1 逻辑关系相邻的元素的存储地址可以不相邻；2 表中的元素只能顺序访问，不能随机访问；3 表的大小可以动态变化；4 插入、删除只需移动指针，不需移动元素；

        7.为了便于单链表的建立和运算的统一，使用头指针，即指向第一个结点的指针，它不存储任何数据；

2.3.2.单链表的基本运算：

        1.建立单链表：有两种方式，头插法和尾接法；

        1.1.头插法：每次插入到头指针的后面，这样生成结点的顺序恰好和线性表中存储的元素相反，如下：

        LNode *createLinkList_tou(){
            LNode *p,*head;
            char x;
            head=(LNode *)malloc(sizeof(LNode));
            head->next=NULL;
            printf("请输入字符：\n");
            scanf("&c",&x);
            while(x!='\n'){
               p=(LNode *)malloc(sizeof(LNode));
                p->data=x;
                p->next=head->next;
                head->next=p;
                scanf("%c",&x);
            }
            return head;
        }

 

        1.2.尾接法：比起头插法较复杂，将新的结点插入到链尾，因此需要再增加一个指针，如下：

        LNode *createLinkList_wei(){
            LNode *q,*p,*head;
            char x;
            head=(LNode *)malloc(sizeof(LNode));
            head->next=NULL;
            p=head;
            q=p;
            printf("请输入字符：\n");
            scanf("&c",&x);
            while(x!='\n'){
                p=(LNode *)malloc(sizeof(LNode));
                p->data=x;
                p->next=NULL;
                q->next=p;
                q=p;
                scanf("%c",&x);
            }
            return head;
        }

 

        2.求表长:

        int len_LinkList(LNode *L){
            int i=0;
            LNode *p=L;
            while(p->next!=NULL){
                p=p->next;
                i++;
            }
            return i;
        }

 

        3.查找：分为按序号查找和按值查找，如下：

        LNode *queryList_value(LNode *L,int x){
            LNode *p=L;
            while(p->next!=NULL&&p->data!=x){
                p=p->next;
            }
            return p;
        }
        LNode *queryList_index(LNode *L,int i){
            LNode *p=L;
            int j=0;
            while(p->next!=NULL&&j<i){
                p=p->next;
                j++
            }
            return p;
        }

 

        4.插入：q->next=p->next;p->next=q;

        void insertLinkList(LNode *L,int i,char c){
            LNode *p,*q;
            p=queryList_index(L,i-1);
            if(p=NULL){
                printf("ERROR!!!");
            }else{
                q=(LNode *)malloc(sizeof(LNode));
                q->data=c;
                q->next=p->next;
                p->next=q;        
            }
        }

 

        5.删除：p->next=p->next->next;

        void deleteLinkList(LNode *L,int i){
            LNode *p,*q;
            p=queryList_index(L,i-1);
            if(p==NULL){
                printf("ERROR!!!");
            }else{
                if(p->next=NULL) printf("ERROR!!!"); 
                q=p->next;
                p->next=q->next;
                free(q);
            }
        }

 

2.2.3.循环链表：将链尾结点的指针值由NULL改为指向头结点，整个链表形成一个环；

        1.在操作循环链表时，不用头指针head,而是使用一个指向链尾的指针R来表示循环链表，这样可以很快的找到链尾元素和头指针，即R->next;

        2.将两个循环链表链接成一个循环链表：

        P=R1->next;R1->next=R2->next->next;free(R2->next);R2->next=P;

2.2.4.双向链表：

        1.相对于单链表来说，循环链表只能从前向后进行遍历，无法直接到达当前节点的前驱节点；因此采用双向链表满足这些需要沿着两个方向遍历的链表；

        2.组成：前驱指针域+数据域+后继指针域；

        3.定义：

        typedef struct dnode
        {
            datatype data;
            struct dnode *prior,*next;
        }DLNode;

 

        4.假设p是双向链表中的某一节点的指针，则有：p->prior->next=p;p->next->prior=p;

        5.双链表的建立：

        void DLNode *createDLink(){
            DLNode *p,*head;
            char c;
            head=(DLNode *)malloc(sizeof(DLNode));
            head->next=head;
            head->prior=head;
            scanf("%c",&c);
            while(c!='\n'){
                p=(DLNode *)malloc(sizeof(DLNode));
                p->data-c;
                p->prior=head;
                p->next=head->next;
                head->next->prior=p;
                head->next=p;
                scanf("%c",&c);
            }
            return p;
        }

 

        6.在结点*p后插入结点*s的步骤:

        s->prior=p； s->next=p->next;  p->next->prior=s;  p->next=s;

        7.在结点*p前插入结点*s的步骤:

        s->next=p;  s->prior=p->prior;  p->prior->next=s;  p->prior=s;

        8.删除结点*p的步骤：

        p->prior->next=p->next;  p->next->prior=p->prior; free(p);

2.2.5.静态链表：有些高级语言没有指针，因此想使用链表时，用一个一维数组来模拟链表，称之为静态链表；

        2.定义：用一个一维数组的数组元素表示结点，结点中的数据域用来存放数据，下标域取代指针域；

        typedef struce
        {
            datatype data;
            int cursor;
        }SNode;
        SNode L[MaxSize];

 

        3.数组中序号为0的元素看成固定的头结点，下标域为0时表示该结点为链表的链尾结点，下标域为-1时表示该结点未使用，这种存储结构要事先分配内存；

FightFightFight
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[数据结构]数据结构简介和顺序表
carry_carial的博客
11-03 770
今天正式第一节数据结构，我们从顺序表开始讲起，和小明和小亮一起打开数据结构之路---顺序表
数据结构实验 顺序表和链表
最新发布
10-08
顺序表和链表的基本实现 数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍...
数据结构-线性表的两种实现方式：顺序表和链表
a2352159950的博客
07-16 1176
顺序表就是在内存中按顺序连续开辟一段空间来存储数据的结构，在java中就是数组，如a所示 链表就是在内存中随机开辟内存一段段存储数据的结构，如图b所示 线性表的接口 使用一个接口表明基本操作的需求： public interface Ilist { //清空线性表 public void clear(); //判断线性表是否为空 public boolean isEmpty(); //获取线性表的长度 public int length(); /.
线性表（顺序表和链表）
qq_41586013的博客
08-12 1207
线性表 线性表是常用且最简单的一种数据结构，简言之，一个线性表是n个数据元素的有限序列。 c语言实现顺序表 java实现顺序表 c语言实现链表表 java实现顺序表 ...
数据结构与算法 - 线性表之顺序表与链表结构
绿龙术士的专栏
02-05 252
线性表，全名为线性存储结构。 简介：将具有“一对一”关系的数据“线性”地存储到物理空间中，这种存储结构就称为线性存储结构（简称线性表）。 注意：使用线性表的数据所使用的数据类型必须是一致的。 有两种方式线性地存储数据到内存中，即顺序存储和链式存储。 下图为顺序存储在内存中的存储方式： 说明：将表格中每一个Cell看作是1个单位的内存空间，左边是内存的地址，右边是保存的值； 当需要从内存中将存放的值全部取出来时，只需要从第一个地址依次遍历即可取到。 下图为链式存储在内存中的存储方..
数据结构（线性表预习）
Clearfix_Xia
10-24 451
数据结构（线性表预习）
线性表——顺序表PPT学习教案.pptx
10-04
线性表可以分为顺序表和链表两种存储结构，今天我们主要讨论顺序表。 1. 线性表的定义 线性表是具有相同数据类型的n(n≥0)个数据元素组成的有限序列。数据元素之间具有的逻辑关系为线性关系的数据元素集合称为...
线性表——链表PPT学习教案.pptx
10-01
链表的操作，如插入和删除，通常比顺序存储的线性表更灵活，因为它们主要涉及到节点之间的指针修改，而不需要像顺序表那样移动大量元素。然而，这也意味着链表的访问速度可能较慢，因为必须从头节点开始遍历，寻找...
数组、链表、堆栈和队列、线性表和顺序表 数组和链表.pdf
04-18
数组、链表、堆栈和队列、线性表和顺序表 数组、链表、堆栈和队列是最基本的数据结构，任何程序都会涉及到其中的一种或多种。数据结构是指数据之间的相互关系，即组织形式，有逻辑结构和物理结构之分。逻辑结构有...
2第二章 线性表（顺序表 链表）.pdf
04-20
根据提供的文档信息，我们可以深入探讨线性表的相关概念及其两种主要实现形式——顺序表与链表。 ### 线性表定义 线性表是一种基本的数据结构，它由一系列具有相同特性的数据元素组成，这些元素按照一定的顺序排列...
顺序表结构体
11-21
该顺序表头文件包含顺序表的结构体，初始化，插入节点，删除等功能
顺序表2种结构体构造方法
weixin_30596735的博客
03-16 788
昨天上课讲到了顺序表的结构体在构造时候可以应用指针做数据成员，而不需要定义一个数组，那么具体方法是这样的： typedef struct{ int *data; int length; }SqList; 这种方式构造顺序表，data项不用数组，这样可以动态生成，不浪费空间，但是data是个指针，怎么表示多个连续的数据呢，所以他的CreateSqlist写法是 ...
数据结构Java实现02----线性表与顺序表
weixin_34377919的博客
08-25 108
【声明】  欢迎转载，但请保留文章原始出处→_→  生命壹号：http://www.cnblogs.com/smyhvae/ 文章来源：http://www.cnblogs.com/smyhvae/p/4758808.html   【正文】 本节内容： 线性结构 线性表抽象数据类型 顺序表 顺序表应用 ...
4-2 顺序表操作集
H_237785的博客
12-18 162
函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef int Position;...
顺序表的基本运算
木质的旋律
07-28 724
#include #include #define maxsize 20 typedef struct {  int data[maxsize];  int len;  }sqlist; /*顺序表的初始化*/ sqlist *init_sqlist() {  sqlist *L;  L=(sqlist*)malloc(sizeof(sqlist));  L->len=0
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值