数据结构与算法基础（顺序表、链表）

最新推荐文章于 2024-07-25 17:43:13 发布
最新推荐文章于 2024-07-25 17:43:13 发布
阅读量769 收藏 10
点赞数 9
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fwputty/article/details/138106557
版权

1.线性表的定义和特点

线性表(Linear List)是由n(n>=0)个具有相同特性的数据元素(结点)组成的有限序列。

其中数据元素的个数n定义为表的长度，非空线性表记作(a1,a2,...an)

逻辑特征：非空的线性表中有且仅有一个开始结点，一个终端结点，其余的内部结点都有且仅有一个直接前趋和一个直接后继。

线性表中的数据类型可以为简单类型或复杂类型。

2.线性表的类型定义

抽象数据类型线性表的定义如下：

ADT List{
    数据对象
    数据关系
    基本操作:
    InitList(&L);            DestroyList(&L);
    ListInsert(&L,i,e);    ListDelete(&L,i,e);
    ...
}ADT List

3.线性表的顺序表示和实现

3.1顺序表的概念及特点

线性表的顺序表示又称为顺序存储结构或顺序映像，以物理位置相邻表示逻辑关系，任意元素均可随机存取。

顺序存储：数据元素的逻辑位置和物理位置均相邻的存储结构。依次存储，地址连续，知道某个元素的存储位置就可以知道其他元素的存储位置。

假设每个数据元素占l个存储单元，则有LOC(a(i+1))=LOC(ai)+l，LOC(ai)=LOC(a1)+(i-1)*l。

线性表的第1个数据元素a1的存储位置称为起始位置或基地址。

顺序表可用一维数组表示，其长度属性用变量表示。

数组静态分配：

#define MAX_SIZE 100 //线性表初始内存空间分配
typedef struct{
    ElemType elem[MAX_SIZE];
    int length;    //当前长度
}SqList

数组动态分配：

#include <stdlib.h>
#define MAX_SIZE 100 //线性表初始内存空间分配
typedef struct{
    ElemType* elem;
    int length;    //当前长度
}SqList
​
SqList L;
L.data = (ElemType*)malloc(sizeof(ElemType)*MAX_SIZE);

补充：操作算法中用到的的预定义常量和类型

//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status //函数类型，值为函数结果状态代码
typedef char ElemType

3.2顺序表基本操作的实现

//初始化顺序表
Status InitList_Sq(SqList &L){
        L.elem = new ElemType[MAX_SIZE];
        if(!L.elem)  exit(OVERFLOW);    //存储分配失败
        L.length = 0;
        return OK;
}
//销毁顺序表
void DestroyList_Sq(SqList &L){
        if(L.elem) delete L.elem;
}
//清空顺序表
void ClearList_Sq(SqList &L){
    L.length = 0;
}
//求顺序表长度
int GetLength(SqList L){
    return L.length;
}
//判断顺序表是否为空
int IsEmpty(SqList L){
    if(L.length == 0) return 1;
    else return 0;
}
//顺序表的查找
int LocateElem(SqList L, ElemType e){
    for(int i = 0; i < L.length; i++){
        if(L.elem[i] == e) return i;
    return 0;
}
//顺序表的插入
Status ListInser_Sq(SqList &L, int i, ElemType e){
    if(i<1||i>L.length-1) return ERROR;
    if(L.length==MAX_SIZE) return ERROR;
    for(int j=L.length-1;j>=i-1;j--) L.elem[j+1]=L.elem[j];
    L.elem=e;
    L.length++;
    return OK;
}
//顺序表的删除
Status ListDelete_Sq(SqList &L, int i){
    if(i<1||i>L.length) return ERROR;
    for(j=i;j<L.length-1;j++) L.elem[j-1]=L.elem[j];
    L.length--;
    return OK;
}

需要修改原始数据使用引用传递，不需要修改或要避免复制大型数据结构用值传递。

查找算法分析

平均查找长度(ASL)：为确定数据在表中的位置，与给定值进行比较的关键字的个数的期望值。

设顺序表中每个数据的查找概率相等，则有：

插入算法分析

删除算法分析

优点：存储密度大，可随机存取

缺点：插入删除时需大量移动元素，浪费存储空间，静态存储

4.线性表的链式表示和实现

4.1链表的概念及特点

用一组物理位置任意的存储单元来存放线性表的数据元素，链表中元素的逻辑次序和物理次序不一定相同。

结点：数据元素的存储映像，由数据域和指针域两部分组成。

链表可以分为单链表、双链表和循环链表。

无头结点时，头指针为空表示空表；有头结点时，头结点的指针域为空表示空表。

链表中设置头结点便于首元结点的处理，便于空表和非空表的统一处理。

头结点的数据域可以为空也可以存放链表长度，此结点不计入链表长度。

4.2链表基本操作的实现

带头结点的单链表

单链表由表头唯一确定，因此可以用头指针命名。

typedef struct Lnode {
    ElemType data;
    struct Lnode *next;
}Lnode, *LinkList;// LinkList为指向结构体Lnode的指针类型

//定义链表
LinkList L;
//定义结点指针
Lnode *p;

//单链表的初始化
Status InitList(LinkList &L){
    L = new Lnode;
    L->next = null;
    return OK;
}
//判断链表是否为空
int ListEmpty(LinkList L){
    if(L->next)  return 0;
    else return 1;
}
//单链表的销毁
Status DestroyList(LinkList &L){
    Lnode *p;
    while(L){
        p = L;
        L = L->next;
        delete p;
    }
}
//清空链表
Status ClearList(LinkList &L){
    Lnode *p, *q;
    p = L->next;
    while(p){
        q = p->next;
        delete p;
        p = q;
    }
    L->next = null;
    return OK;
}
//求链表表长
int ListLength(LinkList L){
    p = L->next;
    i = 0;
    while(p){
        i++;
        p = p->next;
    }
}
//取值
Status GetElem(LinkList L, int i, ElemType &e){
    p = L->next;
    int j = 0;
    while(p&&j<i){
        p = p->next;
        j++;
    }
    if(!p||j>i) return ERROR;
    e = p->data;
    return OK;
}
//按值查找地址
Lnode *LocateElem(LinkList L, ElemType e){
    p = L->next;
    while(p&&p->data!=e){
        p = p->next;
    }
    return p;
}
//按值查找序号
int LocateElem(LinkList L, ElemType e){
    p = L->next;int j = 0;
    while(p&&p->next != e){
        p = p->next
        j++;
    }
    return j;
}
//插入
Status InsertList(LinkList &L, int i, ElemType e){
    p = L;j = 0;
    while(p&&j<i-1){
        p=p->next;
        ++j;
    }
    if(!p||j>i-1) return ERROR;
    q = new Lnode; q->data = e;
    q->next = p->next;
    p->next = q;
    return OK;
}
//删除元素
Status DeleteList(LinkList &L, int i, ElemType e){
    p = L;j = 0;
    while(p->next&&j<i-1){
        p=p->next;
        ++j;
    }
    if(!p->next||j>i-1) return ERROR;
    q = p->next;
    p->next = q->next;
    e = q->data;
    delete q;
    return OK;
}
//头插法
void CreateList_H(LinkList &L, int n){
    L = new LNode;
    L->next = null;
    for(i = n; i > 0; --i){
        p = new LNode;
        cin >> p->data;
        p->next = L->next;
        L->next = p;
    }
}
//尾插法
void CreateList_R(LinkList &L, int n){
    L = new LNode;
    L->next = null;
    r = L;
    for(i = 0; i < n; ++i){
        p = new LNode;
        cin >> p->data;
        p->next = null;
        r->next = p;
        r = p;
    }
}

单循环链表

循环链表没有null指针，表中最后一个指针域指向头结点。

注意：执行遍历操作时，终止条件是p!=null, p->next!=null;

//带尾指针循环链表的合并
LinkList Connect(LinkList Ta, LinkList Tb){
    p = Ta->next;
    Ta->next = Tb->next->next;
    delete Tb->next;
    Tb->next = p;
    return Tb;
}

双向循环链表

//插入
void ListInsert_DuL(DuList &L, int i, ElemType e){
    if(!(p=GetElemP_DuL(L,i))) return ERROR;
    s = new DuLNode;
    s->data = e;
    s->prior = p->prior;
    p->prior->next = s;
    s->next = p;
    p->prior = s;
    return OK;
}
//删除
void ListDelete_DuL(DuList &L, int i, ElemType &e){
    if(!(p=GetElemP_DuL(L,i))) return ERROR;
    e = p->data;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    free(p);
    return OK;
}

5.顺序表和链表的比较

6.线性表的应用

线性表的合并

void Union(List &La, List Lb){
    La_len = ListLength(La);
    Lb_len = ListLength(Lb);
    for(i = 1; i <= Lb; i++){
        GetElem(Lb, i, e);
        if(!LocateElem(La, e)) ListInsert(&La, ++La_len, e);
    }
}

有序表的合并

void MergeList(LinkList La, LinkList Lb, LinkList &Lc){
    pa = La.elem;
    pb = Lb.elem;
    Lc.length = La.length + Lb.length;
    Lc.elem = new ElemType[Lc.length];
    pc = Lc.elem;
    pa_last = La.elem + La.length-1;
    pb_last = Lb.elem + Lb.length-1;
    while(pa<=pa_last && pb<=pb_last){
        if(*pa<=*pb) *pc++ = *pa++;
        else *pc++ = *pb++;
    }
    while(pa<=pa_last) *pc++ = *pa++;
    while(pb<=pb_last) *pc++ = *pb++;
}
puttyos
关注
  • 9
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法-顺序表（链表篇）
09-09
在IT领域，数据结构与算法是计算机科学的基础，它们直接影响到程序的效率和设计。本资源专注于"顺序表"中的"链表"部分，这是一组相关数据元素的集合，其内部组织方式不同于传统的数组。链表不依赖于内存中的连续空间...
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
【数据结构与算法】顺序表和链表
比昨天强一点就好的博客
03-16 4070
线性表(linear list)是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。从以上就很容易看出，在缓存利用率方面，顺序表由于内存是连续的，而链表是一个个单个的节点连起来的，顺序表的命中率绝对要比链表高不少！
数据结构与算法——链表（双向链表，顺序表与链表的比较)
weixin_68773927的博客
10-25 1040
在双向链表中有此操作（如：ListLength，GetElem等）因此涉及一个方向的指针。故它们的算法与线性表相同，但在插入，删除时则需要同时修改两个方向上的指针，两者的操作的时间复杂度均为T(n)=O(n)双向链表：在单链表的每个结点里在增加一个指向其直接前驱的指针域prior 这样链表就形成了有两个方向不同的链。p的后继结点的前驱结点为自身。即：p的前驱结点的后继结点为它自身。
数据结构实验报告一 顺序表与链表
G_M_R_的博客
12-31 5971
数据结构实验报告：实验一 顺序表与链表
【数据结构与算法 经典例题】链表的回文结构（图文详解）
2302_78391795的博客
06-04 1887
回文结构（Palindromic structure）是指一个序列或字符串从前往后读和从后往前读是相同的。 计算机科学中，回文结构可以出现在各种数据结构中，如字符串、数组等。对于字符串来说，判断一个字符串是否为回文字符串是一个常见的问题。判断方法是从字符串的两端开始比较字符是否相等，如果都相等，则继续比较下一对字符，直到中间位置。如果在任何时刻存在一对不相等的字符，则该字符串不是回文。 对于数组来说，直接采取上述方法便可以判断是否是回文结构。但对于单链表来说，则是行不通的，因为单链表只能顺序访问，不能
数据结构与算法基础知识总结.pdf
07-14
数据结构与算法是计算机科学的基础，对于理解和优化程序性能至关重要。算法是解决问题的精确步骤描述，它不等同于程序，但程序的高效实现离不开良好的算法设计。算法必须具备可行性、确定性、有穷性和足够的信息，即...
【初阶数据结构篇】单链表的实现（赋源码）
2301_79849925的博客
07-25 1500
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1225
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 418
对于二分搜索的理论与实现的知识点学习。
数据结构（2）
m0_62881487的博客
07-23 1157
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
2024.7.24 作业
qq_64434282的博客
07-24 2062
【代码】2024.7.24 作业。
《数据结构1800题》基础回合总结——第1章 绪论
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-23 448
前言：《数据结构1800》这本书相信大家或多或少都有所耳闻，收录了诸多不同档次学校的考研真题，因为和汤老师的1800撞名所以备受调侃。这1800道题目里面有选择有填空，也有简答和一些编程题，总的来说质量良莠不齐——亦或说没什么性价比。因此无论考研还是备战期末或者面试的同学，当学有余力的时候，再去看本题集的内容~注：基础阶段，强烈建议不要学算法题，这玩意对于大部分人的水平来说非常耽误效率——ACM佬不在此行列。因此本次刷题相当于基础阶段，只针对除了算法设计的一切基础题~答案如下：答案如下：答案如下： 这一部分
数据结构和算法入门
weixin_67852890的博客
07-25 1573
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
MySQL查询加速器：利用Query Cache提升效率
07-31
MySQL是一个流行的开源关系型数据库管理系统（RDBMS），广泛用于Web应用程序的后端数据存储。它基于结构化查询语言（SQL）来管理数据，并且是LAMP（Linux, Apache, MySQL, PHP/Python/Perl）技术栈的一部分，这个技术栈常用于构建动态网站和Web应用程序。 MySQL的特点包括： - **开放源代码**：MySQL的源代码是公开的，任何人都可以自由使用和修改。 - **跨平台**：MySQL可以在多种操作系统上运行，包括Linux、Windows、macOS等。 - **高性能**：MySQL以其快速的查询处理和良好的性能而闻名。 - **可靠性**：MySQL提供了多种机制来确保数据的完整性和可靠性，包括事务支持、备份和恢复功能。 - **易于使用**：MySQL提供了简单直观的界面和丰富的文档，便于用户学习和使用。 - **可扩展性**：MySQL支持从小型应用到大型企业级应用的扩展。 - **社区支持**：由于其广泛的使用，MySQL拥有一个活跃的开发者社区，提供大量的资源和支持。 MySQL被广泛应用于各种场景，包括在线事务处理（OL
Objective-C语言的基础教程.md
最新发布
07-31
Objective-C是一种面向对象的编程语言，是C语言的扩展。它主要用于苹果的iOS和macOS应用程序开发。
暂存暂存暂存暂存暂存暂存暂存暂存
07-31
暂存暂存暂存暂存暂存暂存暂存暂存
数据结构与算法解析：线性表、链表与双向链表
总结来说，这份软考辅导资料全面覆盖了数据结构与算法的基础知识，包括但不限于线性表的各类实现、树和图的基本概念、算法设计与分析基础，以及排序和查找算法的原理。对于准备参加软考的考生，深入理解和掌握这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值