线性表(数据结构篇)

最新推荐文章于 2024-07-17 12:13:29 发布
最新推荐文章于 2024-07-17 12:13:29 发布
阅读量1k 收藏 28
点赞数 14
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hellmorning/article/details/139721813
版权

数据结构篇之线性表

线性表

定义：

  • 我们将处理一般的形如A1,A2,A3…AN的表成为线性表，N为表的大小，我们称N=0的表为空表。对于除空表外的任何表，我们说Ai+1后继Ai并称Ai-1前驱Ai,表中的第一个元素为A1,而最后一个元素为AN.

简单数组实现表

概念：

  • 表的实现可以通过数组进行实现，而表的插入和删除，就需要对数组元素进行移动，例如插入，如果向第一个位置插入，我们就需要数组元素都向后移动一位，又如删除第一个元素，就需要将第一个元素删掉，数组元素再向前移动一位。
#include <stdio.h?>
#define SIZE 100

struct List{
    int elements[SIZE];
    int len;  //表中元素的长度(即个数)
};

//创建一个空表对象
struct List* createList(){
    struct List *p;
    p=malloc(sizeof(struct List));
    p->len=0;
    return p;
}

//判断表是否为空
bool isEmpty(struct List* p){
    return p->len==0;
}

//头插法
void inserthead(struct List *p,int x){
    if(p->len>=SIZE){
        printf("表已满");
        return;
    }
    for(int i=p->len;i>0;i--){
        p->elements[i]=p->elements[i-1];
    }
    p->elements[0]=x;
    p->len++;
    return;
}

//尾插法
void insertlast(struct List*p,int x){
    if(p->len>=SIZE){
        printf("表已满");
        return;
    }
    p->elements[p->len]=x;
    p->len++;
    return;
}

//打印表中数据
void printList(struct List *p){
    for(int i=0;i<p->len;i++){
        printf("list element is:%d\n",p->elements[i]);
    }
}

//查找指定值，返回索引
int find(struct List *p,int x){
    for(int i=0;i<p->len;i++){
        if(p->elements[i]==x){
            return i;
        }
    }
    printf("没有找到值为%d的数据\n",x);
    return NULL;
}

//查找表中对应索引的值，返回值
int findkth(struct List *p,int pos){
    if(pos>p->len){
        printf("不存在索引为%d的数据\n",pos);
        return NULL;
    }
    return p->elements[pos];
}

//删除
void delete(struct List *p,int x){
    for(int i=0;i<p->len;i++){
        if(p->elements[i]==x){
            for(int j=i;j<p->len-1;j--){
                p->elements[j]=p->elements[j+1];
            }
            p->len--;
           	break;
        }
    }
}

链表

与简单数组实现的优缺点：

  • 优点：简单数组实现表的插入和删除需要花费大量的时间，尤其当数据量大的时候，则程序的耗时将会难以接受，因此为了避免插入和删除的线性开销，我们需要允许表可以不连续存储，否咋表的部分或全部需要整体移动，因此我们将用链表进行实现
  • 缺点：在查找数据的时候，链表所耗的时长更多，因为数组可以直接用索引来获取，但是链表需要遍历表连接的数据，直到找到数据为止。

概念：

  • 链表由一系列不必在内存相连的结构组成，每一个结构均含有表元素和指向包含该元素后继元的结构的指针，我们称之为Next指针。最后一个单元的Next指针指向NULL，NULL是在c中的定义，c中规定为0.
struct Node{
    int data;
    struct Node* next;
};

struct Node *createNode(int data){
    struct Node *p=(struct Node* )malloc(sizeof(struct Node));
    p->data=data;
    p->next=NULL;
    return p;
}

//头插法
struct Node *inserthead(struct Node *head, int data) {
	struct Node *add = createNode(data);
	if (head == NULL) {
		return add;
	}
//	struct Node *p = head;
//	head = add;
//	head->next = p;
//	return head;
	add->next = head;
	return add;
}

//尾插法
struct Node *insert(Node *head,int data){
    struct Node *add=createNode(data);
    if(head==NULL){
        return add;
    }
    while(head->next!=NULL){
        head=head->next;
    }
    head->next=add;
    return head;
}

struct Node *search(Node *head,int data){
    if(head==NULL||head->data==data){
        return head;
    }
    struct Node *p=head;
    while(p->next!=NULL){
        if(p->data==data){
            return p;
        }
        p=p->next;
    }
    return NULL;
}

struct Node *del(Node *head,int data){
    if(head==NULL){
        return head;
    }
    if(head->data==data){
        struct Node *p=head->next;
        free(head);
        return p;
    }
    struct Node *tail=head;
    struct Node *p=head->next;
    while(p!=NULL){
        if(p->data==data){
            break;
        }
        tail=p;
        p=p->next;
    }
    if(p!=NULL&&p->data==data){
        tail->next=p->next;
        free(p);
    }
    return head;
}
//清除链表
struct destoty(Node *head){
    if(head!=NULL){
        destory(head->next);
        free(head);
    }
}

双向非循环链表

作用：

  • 有时候以倒序扫描链表更方便，但是为了实现这个就会多出一条附加链的开销，他增加了空间的需求，同时使得插入和删除的开销增加一倍，但是又简化了删除操作。

概念：

  • 双向非循环链表就是双向的链表，链表中的前后结点都有指向对方的指针，就是A1的next为A2，但是A2又有指针指向A1.

image

代码：

struct doublyNode{
    int data;
    struct doublyNode* next;
    struct doublyNode* prev;
};

struct doublyNode *createNode(int data){
    auto* p=(struct doublyNode*)malloc(sizeof(struct doublyNode));
    p->data=data;
    p->prev=NULL;
    p->next=NULL;
    return p;
}

//头插法
struct doublyNode*inserthead(struct doublyNode* head,int data){
    struct doublyNode*add= createNode(data);
    if(head==NULL){
        return add;
    }
    struct doublyNode*p=head;
    head=add;
    head->next=p;
    p->prev=head;
    return head;
}

//尾插法
struct doublyNode * insertlast(struct doublyNode* head,int data){
    struct doublyNode* add= createNode(data);
    if(head==NULL){
        return add;
    }
    struct doublyNode*p=head;
    while (p->next!=NULL){
        p=p->next;
    }
    p->next=add;
    p->prev=p;
    return head;
}

//删除
doublyNode * del(struct doublyNode* head,int data){
    if(head==NULL){
        cout<<"链表没有数据"<<endl;
        return head;
    }
    if(head->data==data){
        struct doublyNode* p=head->next;
        free(head);
        return p;
    }
    struct doublyNode* tail=head;
    struct doublyNode* p=head->next;
    while (p!=NULL){
        if(p->data==data){
            tail->next=p->next;
            free(p);
            return head;
        }
        tail=p;
        p=p->next;
    }
}

void printlist(struct doublyNode* head){
    if(head==NULL){
        cout<<"链表没有数据"<<endl;
    }
    struct doublyNode* p=head;
    while (p!=NULL){
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}

循环链表

概念：

  • 循环链表就是没有表头表尾的链表，例如一般的链表的表尾为NULL,但是循环链表的下一个指向的表头，不仅有单向循环链表，而且还有双向循环链表，双向循环链表就是表头的前一个指向表尾，表尾的下一个指向表头。
  • C++中的STL库中就已经封装了双向循环链表的类(list)

image

代码：

//单向循环链表
struct CirNode{
    int data;
    struct CirNode* next;
    struct CirNode *prev;
};

struct CirNode* createNode(int data){
    struct CirNode* p=(struct CirNode*)malloc(sizeof(struct CirNode));
    p->data=data;
    p->next=NULL;
    p->prev=NULL;
    return p;
}

struct CirNode* inserthead(CirNode* head,int data){
    struct CirNode* add= createNode(data);
    if(head==NULL){
        add->next=add;
        add->prev=add;
        return add;
    }
    struct CirNode* p=head;
    struct CirNode* p1=head->next;
    while (p1!=head){
        p1=p1->next;
    }
    head=add;
    head->next=p;
    p1->next=head;
    head->prev=p1;
    p->prev=head;
    return head;
}

//尾插法
struct CirNode* insertlast(CirNode* head,int data){
    struct CirNode* add= createNode(data);
    if(head==NULL){
        add->prev=add;
        add->next=add;
        return add;
    }
    struct CirNode* p=head;
    while(p->next!=head){
        p=p->next;
    }
    p->next=add;
    add->prev=p;
    add->next=head;
    return head;
}

struct CirNode* del(CirNode* head,int data){
    if(head==NULL){
        cout<<"链表没有数据"<<endl;
        return head;
    }
    if(head->data==data){
        struct CirNode* p=head->next;
        p->prev=head->prev;
        free(head);
        return p;
    }
    struct CirNode* tail=head;
    struct CirNode* p=head->next;
    while (p!=head){
        if(p->data==data){
            tail->next=p->next;
            p->next->prev=tail;
            free(p);
            return head;
        }
        tail=p;
        p=p->next;
    }
}

void printlist(CirNode* head){
    if(head==NULL){
        cout<<"链表没有数据"<<endl;
    }
    struct CirNode* p=head;
    do{
        cout<<p->data<<" ";
        p=p->next;
    } while (p!=head);
    cout<<endl;
}

跳跃表(跳表)

概念：

  • 跳跃表是一个随机化的数据结构，实质就是一种可以进行二分查找的有序链表。
  • 跳表在原有的有序链表的基础上面通过随机化算法产生随机级数的节点使其通过节点的索引来实现快速查找，提高了插入，删除，查找操作的性能
  • 跳表数据结构是以O(logN)期望时间进行查找和删除操作的数据结构

特性：

  • 有序性
  • 插入新元素通过随机化算法随机分配存储该新元素值的节点级数，而级数就代表着这个节点有多少个指针，例如调表的第k位4阶节点，从最高层到最后一层，每个指针指向第2i+k节点(也就是跳过2i个节点，i为层数)

image

随机化算法：

  • 该算法用于给跳表插入新元素时，进行随机产生k阶节点用于作为新元素值得载体插入在跳表中。
  • 虽然是随机的，但是各阶节点的产生是有概率性的，1/2是一阶节点，1/4是2阶节点，大约1/2i的节点是i阶节点。

查找操作：

  • 首先在最高级索引上查找最后一个小于当前查找元素的位置，然后再跳到次高级索引继续查找，直到跳到最底层为止。
  • 跳表的数据结构大大提高了查找操作，跳表的查找操作类似于二分查找。

插入操作：

  1. 随机产生阶数，然后根据阶数跟数值创建节点

  2. 如果新创建的表头，则直接令表头的第一层索引指针指向新创建的节点，如果不是就根据上步产生的阶数创建prev数组用来存储每层要插入节点位置的前继节点，遍历每一层，将prev赋值完。

  3. 然后根据阶数遍历，插入到存储到prev的前继节点的下一个位置。

删除操作：

  1. 跟插入操作差不多，先进行将prev数组赋值
  2. 然后遍历每层，将每层的前继节点指向被删除节点的下一个节点。
  3. 释放被删除节点的空间。

代码：

struct Node{
    int val;     //存储元素值
    vector<Node*>next;   //存储各层数指针的数组
    int level;  //阶数
};


class skiplist{
public:
    skiplist(int level):Maxlevel(level){
        head= createNode(NULL,Maxlevel);
    }
    ~skiplist() {
        Node* tail=head;
        Node* p;
        while (tail!= nullptr){
            p=tail;
            tail=tail->next[0];
            delete p;
        }
        head= nullptr;
    };

    Node* find(int data);
    void insert(int data);
    void del(int data);
    void print();

private:
    Node* head;
    int Maxlevel;

    Node* createNode(int data,int level){
        auto p = new Node;
        p->val=data;
        p->level=level;
        p->next.resize(level,NULL);
        return p;
    }

    int rand_level(){
        int level=1;
        while(rand()%2&&level<=Maxlevel){
            level++;
        }
        return level;
    }


};

Node *skiplist::find(int data) {
    Node* p=head;
    for(int i=Maxlevel-1;i>=0;i--){
        while (p->next[i]!= nullptr&&p->next[i]->val<data){
            p=p->next[i];
        }
    }
    if(p->next[0]!= nullptr&&p->next[0]->val==data){
        return p->next[0];
    }
    return nullptr;
}

void skiplist::insert(int data) {
    int level=rand_level();
    Node* add= createNode(data,level);
    if(head->next[0]== nullptr){
        head->next[0]=add;
        return;
    }
    Node* p=head;
    Node* prev[level];
    for(int i=level-1;i>=0;i--){
        while (p->next[i]!= nullptr&&p->next[i]->val<data){
            p=p->next[i];
        }
        prev[i]=p;
    }
    for(int i=0;i<level;i++){
        add->next[i]=prev[i]->next[i];
        prev[i]->next[i]=add;
    }
}

void skiplist::del(int data) {
    Node* p=head;
    Node* prev[Maxlevel];
    for(int i=Maxlevel-1;i>=0;i--){
        while (nullptr!=p->next[i]&&p->next[i]->val<data){
            p=p->next[i];
        }
        prev[i]=p;
    }
    if(p->next[0]!= nullptr&&p->next[0]->val==data){
        Node* tail=p->next[0];
        for(int i=Maxlevel-1;i>=0;i--){
            if(prev[i]->next[i]!= nullptr&&prev[i]->next[i]->val==data)
                prev[i]->next[i]=prev[i]->next[i]->next[i];
        }
        delete tail;
    }
}

void skiplist::print() {
    Node* p=head->next[0];
    while (p!= nullptr){
        cout<<p->val<<" ";
        p=p->next[0];
    }
    cout<<endl;
}

尾言

完整版笔记也就是数据结构与算法专栏完整版可到我的博客进行查看，或者在github库中自取(包含源代码)

Moon也爱算法呀
关注
  • 14
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构--线性表
Yzhenfeng7的博客
12-10 972
该篇文章通过学习慕课MOOC《数据结构》做的笔记内容，方便日后复习
数据结构 线性表
11-19
线性表是数据结构中的一种基本类型，它是一组相同类型的元素按照特定顺序排列的集合。这篇内容将深入探讨线性表的概念、合并线性表的策略以及使用C语言实现这一过程时的注意事项。 线性表是数据结构中最直观的形式...
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构-线性表篇
qq_44663230的博客
09-03 1932
线性表思维导图+线性表题目+无详细解析版思考题
数据结构线性表基本操作
lizhi20210729的博客
11-20 1万+
数据结构线性表基本操作基本内容线性表的顺序表示和实现线性表的顺序存储表示顺序表中基本操作的实现 基本内容 因为第一次数据结构阶段考写代码又想规范写又写不出规范的可读性强的代码，让我第一次意识到自己应该在这方面下一些功夫。这篇文章是记录自己把书上写的算法打到电脑上遇到的问题。 线性表的顺序表示和实现 线性表的顺序存储表示 将书中代码复刻如下： #define MAXSIZE 100//顺序表可能达到的最大长度 typedef struct { ElemType *elem;//储存空间的基地址
icoding数据结构——线性表篇
kevvviinn的博客
05-14 735
虽然线性表有顺序表和链表，但是难点主要在于链表，因此练习中链表占绝大一部分 下面配上题目以及解答，如果有需改进的地方欢迎各位大佬指正。 1.1 【解答】 #include <stdio.h> #include <stdlib.h> #include "list.h" // 请不要删除，否则检查不通过 void lnk_merge(LinkList A, LinkList B, LinkList C) { LinkList pa=A->next,pb=..
数据结构——线性表
qq_55867897的博客
04-19 732
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、线性表定义和特点二、 类型定义二、存储方式及特点1.顺序存储的特点2.链式存储 前言 提示：这里可以添加本文要记录的大概内容： —线性表是最基本且最常用的一种线性结构，同时也是其他数据结构的基础，尤其是单链表，是贯穿整个数据结构课程的基本技术 提示：以下是本篇文章正文内容，下面案例可供参考 一、线性表定义和特点 定义：由n(n>=0)个数据特性相同的元素构成的有限序列 特点： 1 存在唯一的一个被称为“第一.
数据结构-线性表（考研篇）
Weightlessly的博客
01-29 1468
线性表 定义 具有相同数据类型的n个数据元素的有限序列（有次序） 几个概念： ai是线性表中“第i个”元素线性表中的位序 a1是表头元素，an是表尾元素 除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后继。 基本运算 顺序存储（顺序表） 定义：用顺序存储的方式实现的线性表。 顺序存储：逻辑上相邻的元素存储在物理位置上也相邻的存储单元中。 如何计算一个数据元素的大小？ 答：C语言中的sizeof(** **)函数 静态分配 #include <stdi
数据结构线性表——队列
2303_78442132的博客
11-14 310
数据结构、线性表、队列
数据结构-线性表
计蒙不吃鱼的博客
10-31 3150
数据结构系列文章目录 数据结构三要素——逻辑结构、数据的运算、存储结构（物理结构） 小提：储存结构不同，运算的实现方式不同。 从此博客开始到后续的一段时间，都是计蒙本人在为考研做准备。预计每周两到四篇用于复习。（加粗字体需要重点理解，每句话后面可能会给出简单解释。） 文章目录数据结构系列文章目录逻辑结构线性表的基本操作（运算）储存结构顺序表（顺序储存）实现-静态分配实现-动态分配动态申请一片连续的储存空间使用C语言初始化表：关键代码顺序表特点：（常考概念题）顺序表插入操作顺序表删除操作顺序表查找操作单链表
数据结构学习--线性表及其应用--链表
06-25
线性表是一种基础的数据结构，它是由n（n>=0）个相同类型元素构成的有限序列。在计算机科学中，线性表可以采用顺序存储结构或链式存储结构来实现。本篇主要讨论的是链式存储结构的线性表，也就是链表。 链表是一种...
数据结构实验一（线性表的操作）c语言
04-25
数据结构实验一（线性表的操作）C语言 在这篇文章中，我们将通过C语言来实现一个线性表的操作实验，包括顺序表的创建、查找、插入、删除等功能。 一、实验内容 在这个实验中，我们将创建一个顺序表，并实现查找、...
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
Java数据结构之线性表细解(附赠源码)源码篇
01-31
线性表作为最简单也是最常见的数据结构之一，是许多高级数据结构的基础。在这个主题中，我们将深入探讨Java中的线性表，特别是单链表的实现。本文将基于提供的"单链表的实现代码"来讲解相关知识。 首先，线性表是一...
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1055
如有错误，欢迎指出~
数据结构第32节 无锁编程
最新发布
hummhumm的专栏
07-17 836
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 826
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1892
栈超超超详解
线性表数据结构：定义、运算与实现
"这篇资料主要介绍了线性表这一数据结构，包括其定义、特性、不同存储方式以及相关操作。线性表是由相同类型元素组成的有序序列，可以是有序或无序的，支持多种操作，如创建、删除、插入、查找和修改等。线性表的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值