数据结构笔记--线性表

最新推荐文章于 2024-05-03 16:54:29 发布
最新推荐文章于 2024-05-03 16:54:29 发布
阅读量297 收藏
点赞数
分类专栏： 数据结构学习 文章标签： 数据结构 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011015935/article/details/51804670
版权

线性表

（linear list）简称表，是n(n≥0)个具有相同类型的数据元素的有限序列。

顺序表

——线性表的顺序存储结构

  • 只要确定了存储顺序表的起始地址，计算任意一个元素的存储地址的时间是相等的，具有这种特点的存储结构称为随机存储结构。
  • 存储结构定义
const int MaxSize = 10;
typedef int DataType;
typedef struct
{
    DataType data[MaxSize];
    int length;
} SeqList;
  • 简单实现
// 初始化
void InitList(SeqList &L)
{
    L.length = 0;
}
// 创建，根据数组a创建长度为n的顺序表
void CreateList(SeqList &L, DataType a[], int n)
{
    int i;
    if(n > MaxSize) {
        printf("参数非法！");
        exit(-1);
    }
    for(i = 0; i < n; i++)
    {
        L.data[i] = a[i];
    }
    L.lenght = n;
}
// 按位、值查找
DataType GetData(SeqList &L, int i)
{
    if(i<1 || i>L.length) {
        printf("查找位置非法")
        exit(-1);
    }
    return L.length[i]
}
int LocateData(SeqList &L, DataType d)
{
    int i;
    for(i = 0; i < L.length; i++)
    {
        if (L.data[i] == d)
            return i+1; // 返回位置（第几个）
    }
    return 0; // 没有找到
}
// 插入
void Insert(SeqList &L, int i, DataType d)
{
    if(L.length >= MaxSize) {
        printf("上溢");
        exit(-1);
    }
    if(i < 1 || i > L.length) {
        print("位置错误");
        exit(-1);
    }
    int j;
    for(j = L.length; j>= i; j--)
        L.data[j] = L.data[j-1];
    L.data[i-1] = d;
    L.length++;
}
// 删除第i个元素
DataType Delete(SeqList &L, int i)
{
    if (L.length == 0) {
        printf("下溢");
        exit(-1);
    }
    if (i < 1 || i > L.length) {
        printf("删除位置错误");
        exit(-1);
    }
    int j;
    DataType d = L.data[i-1];
    for(j = i; j < L.length; j++)
        L.data[j-1] = L.data[j];
    L.length--;
    return d;
}

单链表

  • 简单定义：使用一组任意的存储单元存放线性表的元素，存储单元即可以是连续的也可以是不连续的，可以分散在内存的任意位置。
    带有头结点的单链表
  • 存储结构
typedef int DataType;
typedef struct Node
{
    DataType data;
    Node *next;
} Node, *first;
  • 简单实现
// 初始化
Node* InitList(Node * first)
{
    first = (Node *)malloc( sizeof( Node ) );
    first->next = NULL;
    return first;
}
// 遍历
void PrintList(Node *first)
{
    p = first->next;
    whilh (p != NULL) {
        print(p->data);
        p = p->next;
    }
}
// 按位、值查找
DataType GetData(Node *first, int i)
{
    p = first->next;
    int count = 1;
    while(p != NULL && count < i) {
        p = p->next;
        count++;
    }
    if(p == NULL) { 
        printf("查找失败");
        exit(-1);
    } else {
        return p->next;
    }
}
int Locate(Node *first, DataType d)
{
    p = first->next;
    int count = 1;
    while(p != NULL) {
        if(p->data == d)
            return count;
        p = p->next;
        count++;
    }
    return 0;
}
// 插入
void Insert(Node *first, int i, DataType d)
{
    p = first;
    int count = 0;
    while(p != NULL && count < i-1) {
        p = p->next;
        count++;
    }
    if(p == NULL) {
        printf("插入失败");
        exit(-1);
    } else {
        Node *s;
        s = (Node *)malloc( sizeof(Node) );
        s->data = d;
        s->next = p->next;
        p->next = s;
    }
}
// 删除
DataType Delete(Node *first, int i)
{
    p = first;
    int count = 0;
    while(p != NULL && count < i-1) {
        p = p->next;
        count++;
    }
    if(p == NULL || p->next == NULL) {
        printf("删除失败");
        exit(-1);
    } else {
        Node *q;
        DataType d;
        q = (Node *)malloc( sizeof(Node) );
        q = p->next;
        d = p->data;
        p->Next = q->next;
        free(q);
        return d;
    }
}
// 头插法建立单链表
Node* Create(Node *first, DataType a[], int n)
{
    first = (Node *)malloc( sizeof(Node) );
    first->next = NULL;
    int i;
    for(i = 0; i < n; i++)
    {
        Node *s;
        s = (Node *)malloc( sizeof(Node) );
        s->data = a[i];
        s->next = first->next;
        first->next = s;
    }
    return first;
}
// 尾插法建立单链表
Node* Create(Node *first, DataType a[], int n)
{
    first = (Node *)malloc( sizeof(Node) );
    Node *r;
    r = first;
    int i;
    for(i = 0; i < n; i++)
    {
        Node *s;
        s = (Node *)malloc( sizeof(Node) );
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
    return first;
}

双链表

  • 在单链表的基础上设置一个前驱节点
    双链表的结构
  • 存储结构定义
typedef int DataType;
typedef struct DulNode
{
    DataType data;
    DulNode *prior, *next
} DulNode, *first;
  • 简单实现
// 插入
void Insert(DulNode *first, int i, DataType d)
{
    Node *p;
    p = first;
    int count = 0;
    while(p != NULL && count < i-1) {
        p = p->next;
        count++;
    }
    if(p == NULL) {
        printf("插入失败");
        exit(-1);
    } else {
        Node *s;
        s = (Node *)malloc( sizeof(Node) );
        s->data = d;
        s->prior = p;
        s->next = p->next;
        p->next->prior = s;
        p->next = s;
    }   
}
// 删除
DataType Delete(Node *first, int i)
{
    Node *p;
    p = first;
    int count = 0;
    while(p != NULL && count < i) {
        p = p->next;
        count++;
    }
    if(p == NULL) {
        printf("删除失败");
        exit(-1);
    } else {
        Node *q;
        DataType d;
        q = p->next;
        d = q->data;
        (p->prior)->next = p->next;
        (p->next)->prior = p->prior;
        free(q);
        return d;
    }
}

循环链表

  • 循环单链表
    这里写图片描述
  • 循环双链表
    这里写图片描述

静态链表

  • 用数组来表示单链表，用数组下标来模拟单链表的指针
    这里写图片描述
  • 存储结构定义
const int MaxSize = 10;
typedef int DataType;
typedef struct
{
    DataType data;
    int next;
} SNode, SList[MaxSize];
  • 简单实现
// 插入
s = avail;
avail = SList[avail].next;
Slist[s].data = d;
SList[s].next = SList[p].next;
SList[p].next = s
// 删除
q = SList[p].next;
Slist[p].next = SList[q].next;
SList[q].next = avail;
avail = q;

约瑟夫环问题

  • 问题描述
    约瑟夫环问题由古罗马史学家约瑟夫提出，他参加并记录了公元66-70年犹太人反抗罗马帝国的起义。在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。
    约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3…n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
  • C++实现
#include<iostream>
#include<list>
#include<cstdlib>
int main()
{
    int total=0;
    int key=0;
    cout<<"input total:";
    cin>>total;
    cout<<"input key:";
    cin>>key;
    if(key>total || key <1||total <1)
    {
        cout<<"error input!"<<endl;
    }
    list<int>* table = new list<int>();
    for(int i =1;i<=total;++i)
        table->push_back(i);
    int shout = 1;
    for(list<int>::iterator it=table->begin();table->size()!=1;)
    {
        if(shout++==key) {
            it = table->erase(it);
            shout=1;
        } else {
            ++it;
        }
        if(it==table->end()) {
            it=table->begin();
        }
    }
    cout<<"the last one:";
    cout<<*table->begin()<<endl;
    return 0;
}
士林ya
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法笔记-线性表定义和特点
01-07
线性表示相当灵活的数据结构，其长度可以根据需要适当的增长或者缩短，即对线性表的数据元素不仅可以进行访问，而且可以进行擦汗如和删除等操作。 一、下列给出线性表的抽象数据类型定义： ADT 线性表 （list） Data...
单链表
梦醒已隔万重秋的博客
06-14 262
/*单链表*/ //储存结构定义 typedef int DataType; typedef struct Node {     DataType data;     Node *next;     Node *first;        //指向链表头指针 } //初始化单链表 Node *InitList(Node *first) {     first
C++之单链表
爱编程的小屁孩的博客
10-07 190
一、学习要点： 1.模板函数、模板类的应用； 2.尾节点的指针内容为空，有利于计算链表长度，和插入和删除节点是否越界； 3.加深对成员变量应用的认识. 二、程序运行代码： #include&lt;stdlib.h&gt; #include&lt;iostream&gt; using namespace std; template&lt;class DataType&gt; struct Node{...
实验三 单链表实现学生成绩管理系统
nika_jy_L的博客
05-16 958
#include&lt;iostream&gt; using namespace std; //template&lt;class DataType&gt; typedef int DataType; struct Node { DataType data; struct Node *next; }; //template&lt;class DataType&gt; class Linkl...
数据结构第二章总结
zhangjunpengziyu的专栏
11-29 707
线性表简称表，是n个具有相同类型的数据元素的有限序列。 线性表中数据元素的个数称为线性表的长度。长度为零时称为空表。 线性表中数据元素的类型是同一的。 线性表的顺序存储结构称为顺序表。 存储结构是数据及其逻辑结构在计算机中的表示； 存取结构是在一个数据结构上对查找操作的时间性能的一种描述。 随机存取结构：只要确定了存储顺序表的起始地址（即基地址），计算任意一个元素的存储地址的时间是相等
数据结构笔记---线性表
派小汤的博客
04-17 381
数据结构笔记二、线性表1.线性表的定义和基本操作1.1 基本概念和术语1.2 线性表的基本操作 二、线性表 1.线性表的定义和基本操作 1.1 基本概念和术语 线性表：线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，n为表长。若用L命名线性表，则表示为：(a1a_1a1​,a2a_2a2​,a3a_3a3​…aia_iai​,ai+1a_{i+1}ai+1​…,ana_nan​...
数据结构--笔记--线性表
tao0212的博客
08-22 122
线性表------逻辑结构线性表是具有（每个数据元素所占空间一样大）数据类型的n（n≥0）个的（有次序），其中n为，当n = 0时线性表是一个。注：数据结构三要素——逻辑结构、数据的运算、存储结构（物理结构）
考研数据结构笔记--线性表概述
BELL__Meng的博客
08-15 297
线性表一、线性表的基本概念二、线性表的结构体定义 一、线性表的基本概念 1.1 线性表的定义 线性表是具有相同特性的数据元素的一个有限序列。该序列中所含元素的个数叫做线性表的长度。 1.2 线性表的逻辑特性 只有一个表头元素，只有一个表尾元素，表头元素没有前驱，表尾元素没有后继，除表头和表尾元素元素之外，其他元素只有一个直接前驱，也只有一个直接后继。 1.3 线性表的存储结构 线性表的存储结构有顺...
数据结构笔记-线性表
weixin_50567482的博客
02-19 435
线性表篇 线性表有两种物理存储结构:顺序存储结构和链式存储结构。 线性表的顺序存取结构是最简单以及最常用的线性表的存储方式 我们用一段地址连续的存储单元依次存储线性表中的数据元素，其实就是和数组一样 通过占位的方式将一定空间占有，再把相同数据元素类型的数据元素依次放到空间里 描述顺序表的属性 1.存储空间的起始位置 也就是数组data 2.顺序表的容量（最大长度） MaxSize 3.顺序表的当前长度 Length 这个是当前长度，会随着你所做的变化而变化，与Ma...
大话数据结构笔记-线性表
Clew123的博客
11-20 373
大话数据结构笔记-线性表基础知识线性表(List)：零个或多个数据元素的有限序列。重点：有顺序、有限例如有一个线性表：a, b, c, d, ···, z则： a是b的直接前驱元素 b是a的直接后继元素 每个元素至多有一个直接前驱元素和直接后继元素 所有线性表元素的个数n(n>=0)为线性表的长度，n=0时，为空表。在复杂的线性表中，一个数据元素可以是若干个数据项组成，例如花名册。顺序存储结构线性表
java基础数据结构-线性表
12-26
java基础笔记数据结构-线性表，详细描述了线性表的原理及其实现方式，基础数据结构。
Java基础复习笔记04数据结构-线性表
05-08
Java基础复习笔记04数据结构-线性表。
基于《大话数据结构》线性表笔记
11-06
只供博主个人学习
数据结构笔记：栈
01-20
分类目录——数据结构笔记](https://blog.csdn.net/bbjg_001/category_9753496.html) 栈（stack），有些地方也成为堆栈，是一种容器，可存储元素、访问元素、删除元素，他的特点是值能允许在容器的一段（称之为 栈顶...
数据结构——链表（精简易懂版）
最新发布
qq_34434522的博客
05-03 673
1，链表（Linked List）是一种常见的数据结构，用于存储一系列元素。它由一系列节点（Node）组成，每个节点包含两部分：数据域（存储数据的部分）和指针域（指向下一个节点的指针）。链表的特点是节点在内存中的存储位置不必是连续的，而是通过指针来相互连接。具体可以想象成一个很多个积木连接的蛇链表可以分为单向链表和双向链表两种常见形式单向链表（Singly Linked List）：每个节点包含一个指针，指向下一个节点。单向链表只能从头节点开始顺序访问，无法从尾节点快速访问到头节点。（就是上面那种）
数据结构可视化（适合考研党）
qq_51281451的博客
04-30 549
还在疑惑平衡二叉树、红黑树、B树、B+树怎么插入构建的吗，不要慌张，这个网站会一步一步来演示.
数据结构中的栈（C语言版）
z6665454的博客
04-30 1274
被移除的元素是最后一个入栈的元素，即栈顶元素。出栈操作会改变栈的结构，并返回被移除的元素。对于基于数组实现的栈，如果数组已满，即栈已满，该函数返回真；获取栈顶元素：获取栈顶的元素，但不对栈进行修改。如果栈中没有元素，即栈为空，该函数返回真；函数检查栈是否为空，如果为空，则打印错误信息并返回-1；函数检查栈是否为空，如果为空，则打印错误信息并返回-1；3.栈中的元素没有编号或索引，只有栈顶指针来指示栈的当前位置。1.元素的插入和删除操作只能在栈的一端进行，该端被称为栈顶。等于-1，表示栈为空，返回1；
C语言/数据结构——每日一题（移除链表元素）
yiqingaa的博客
04-30 489
今天在leetcode刷到了一道关于单链表的题。想着和大家分享一下。废话不多说，让我们开始今天的知识分享吧。
数据结构中的线性表笔记
08-20
- *2* [数据结构笔记——线性表](https://blog.csdn.net/weixin_43461520/article/details/123783563)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值