数据结构线性结构

已于 2022-12-15 11:15:49 修改
阅读量56 收藏 1
点赞数
文章标签： 数据结构 算法 c++
于 2022-12-14 16:36:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54005982/article/details/128318435
版权

1.顺序表

//源文件,存放函数的实现
#include <stdio.h>
#include <assert.h>
#include "seqlist.h" //引用本项目的头文件

//初始化
void InitList(PSqList pl)
{
    pl->length = 0;
    //pl->elem;//不需要处理
}

//销毁顺序表
void Destroy(PSqList pl)
{
    Clear(pl);
}

//清空,清除所有数据
void Clear(PSqList pl)
{
    pl->length = 0;
}

//判空
bool IsEmpty(PSqList pl)
{
    return pl->length == 0;
}

//判满,内部函数
static  bool IsFull(PSqList pl)
{
    return pl->length == MAXSIZE;
}

//获取长度
int GetLength(PSqList pl)
{
    return pl->length;
}

//获取i下标的值
bool  GetElem(PSqList pl, int i, ElemType* rtval)//O(1)
{
    if (i < 0 || i>=pl->length) //失败
        return false;
    *rtval = pl->elem[i];
    return true;
}

//获取i下标的前驱值
bool GetPrio(PSqList pl, int i, ElemType* rtval)
{
    if (i <= 0 || i >= pl->length)
        return false;
    *rtval = pl->elem[i-1];

    return true;
}

//获取i下标的后继值
bool GetNext(PSqList pl, int i, ElemType* rtval)
{
    if (i < 0 || i >= pl->length - 1)
        return false;
    *rtval = pl->elem[i + 1];
    return true;
}

//查找val的位置,返回下标,失败返回-1
int Seach(PSqList pl, int val)
{
    for (int i = 0; i < pl->length; i++)
    {
        if (pl->elem[i] == val)
            return i;
    }
    return -1;
}

//在i下标插入数据val
bool Insert(PSqList pl, int i, ElemType val)//O(n)
{
    if (i<0 || i>pl->length || IsFull(pl))//i不合法,满
        return false;
    //把i及后面的数据后移
    for (int j = pl->length - 1;j>=i; j--)
    {
        pl->elem[j + 1] = pl->elem[j];
    }
    //val存放在i下标
    pl->elem[i] = val;
    //处理pl->length
    pl->length++;

    return true;
}

//头插
bool Insert_head(PSqList pl, ElemType val)//O(n)
{
    return Insert(pl,0,val);
}

//尾插
bool Insert_tail(PSqList pl, ElemType val)//O(1)
{
    if (IsFull(pl))
        return false;
    pl->elem[pl->length] = val;
    pl->length++;
    return true;
}

//删除第一个val的值
bool Delete(PSqList pl, ElemType val)//O(n)
{
    int index = Seach(pl,val);
    if (index < 0)
        return false;

    for (int i = index; i <pl->length-1 ; i++)
    {
        pl->elem[i] = pl->elem[i + 1];
    }
    pl->length--;

    return true;
}

//输出顺序表
void Show(PSqList pl)
{
    for (int i = 0; i < pl->length; i++)
    {
        printf("%d ",pl->elem[i]);
    }
    printf("\n");
}

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "dsqlist.h"

没有头节点的顺序表

需要二次应用当遇到需要修改头指针形参**p，实参&p

//初始化
void InitList(PDSqList pl)
{
    assert(pl != NULL);
    pl->elem = (ElemType*)malloc(INIT_SIZE * sizeof(ElemType));
    assert(pl->elem!=NULL);
    if (pl->elem == NULL)
        return;
    pl->length = 0;
    pl->size = INIT_SIZE;
}

//销毁顺序表
void Destroy(PDSqList pl)
{
    free(pl->elem);
    pl->elem = NULL;
    pl->length = 0;
    pl->size = 0;
}

//清空
void Clear(PDSqList pl)
{
    pl->length = 0;
}

//判空
bool IsEmpty(PDSqList pl)
{
    return pl->length == 0;
}

//获取长度
int GetLength(PDSqList pl)
{
    return pl->length;
}

//获取i下标的值
bool  GetElem(PDSqList pl, int i, ElemType* rtval)
{
    if (i < 0 || i >= pl->length)
        return false;
    *rtval = pl->elem[i];
    return true;
}

//获取i下标的前驱值
bool GetPrio(PDSqList pl, int i, ElemType* rtval);

//获取i下标的后继值
bool GetNext(PDSqList pl, int i, ElemType* rtval);

//查找val的位置,返回下标,失败返回-1
int Seach(PDSqList pl, int val);

static bool IsFull(PDSqList pl)
{
    return pl->length == pl->size;
}

//扩容
static void Inc(PDSqList pl)
{
    pl->elem = (ElemType*)realloc(pl->elem,2*pl->size*sizeof(ElemType));
    assert(pl->elem != NULL);
    pl->size *= 2;
}

//在i下标插入数据val
bool Insert(PDSqList pl, int i, ElemType val)//O(n)
{
    if (i<0 || i>pl->length)
        return false;
    if (IsFull(pl))
    {
        Inc(pl);
    }
    //把i及后面的数据后移
    for (int j = pl->length - 1; j >= i; j--)
    {
        pl->elem[j + 1] = pl->elem[j];
    }

    //把val放在i下标
    pl->elem[i] = val;
    
    pl->length++;

    return true;
}

//头插
bool Insert_head(PDSqList pl, ElemType val)//O(n)
{
    return Insert(pl,0,val);
}

//尾插
bool Insert_tail(PDSqList pl, ElemType val)//O(1)
{
    return Insert(pl,pl->length,val);
}

//删除第一个val的值
bool Delete(PDSqList pl, ElemType val);

//输出顺序表
void Show(PDSqList pl)
{
    for (int i = 0; i < pl->length; i++)
    {
        printf("%d ",pl->elem[i]);
    }
    printf("\n");
}

//放测试代码
#include <stdio.h>
#include <string.h>
#include "dsqlist.h"

//A=A n B
//例如:A={1,2,3,5,4};B={5,3,1} ;结果为{5,3,1}
void Merge(PDSqList pa, PDSqList pb)
{
    for (int i = 0; i < GetLength(pa);)
    {
        if (Seach(pb, pa->elem[i]) == -1)//pb没有这个元素,需要删除
        {
            Delete(pa, pa->elem[i]);
        }
        else
            i++;
    }
}

//A=AUB,并集
//例如:A={1,2,3,5,4};B={5,3,1,8} ;AUB={1,2,3,4,5,8};
void Unio(PDSqList pa, PDSqList pb)
{
    for (int i = 0; i < GetLength(pb); i++)
    {
        if (Seach(pa, pb->elem[i]) == -1)//不在,添加到pa
        {
            Insert_tail(pa,pb->elem[i]);
        }
    }
}

int main()
{
    DSqList ds;
    InitList(&ds);

    for (int i = 0; i < 21; i++)
    {
        Insert(&ds,i,i);
    }
    Insert_head(&ds,-1);
    Insert_tail(&ds,100);
    Show(&ds);

    return 0;
}
//#include "seqlist.h"
//
extern bool IsFull(PSqList);//引用外部符号
//
编译:只需要函数声明
链接:
//int main()
//{
//    SqList sq;
//    InitList(&sq);
//
//    for (int i = 0; i < 20; i++)
//    {
//        Insert(&sq,i,i);
//    }
//    Insert_head(&sq,-1);
//    Insert_tail(&sq,100);
//    Delete(&sq,10);
//    Show(&sq);
//    
//    return 0;
//}

2.链表

需要定位来进行操作

LNode表示任意节点

Llist表示头节点开始

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "list.h"

/*
*遍历链表所有节点总结:
*   1.需要前驱(需要修改链表结构)  for(LNode *p=pl;p->next!=NULL;p=p->next) ...
*   2.不需要前驱,只遍历数据节点  for(LNode *p=pl->next;p!=NULL;p=p->next) ...
*/

//初始化
void InitList(LinkList pl)
{
    assert(pl != NULL);
    //pl->data,不使用
    pl->next = NULL;
}

//销毁顺序表
void Destroy(LinkList pl)
{
    LNode* p;
    //总是删除第一个节点(食堂阿姨打饭)
    while (pl->next != NULL)//还有第一个节点
    {
        p = pl->next;//保存第一个节点
        pl->next = p->next;//剔除第一个节点
        free(p);//删除第一个节点
    }
    //LNode* p = pl->next;
    //LNode* q ;//p的后继
    //pl->next = NULL;
    //while (p != NULL)
    //{
    //    q = p->next;
    //    free(p);
    //    p = q;
    //}
}

//清空(原来的数据节点还要吗?,当前的设计是不要)
void Clear(LinkList pl)
{
    Destroy(pl);
}

//判空
bool IsEmpty(LinkList pl)
{
    return pl->next == NULL;//只有头节点
}

//获取长度(数据个数,不包括头节点)
int GetLength(LinkList pl)
{
    int count = 0;
    //遍历所有的数据节点
    for (LNode* p = pl->next; p != NULL; p = p->next)
    {
        count++;
    }

    return count;
}

//获取i下标的值,设第一个数据节点的下标为0
bool  GetElem(LinkList pl, int i, ElemType* rtval)//O(n)
{
    if (i < 0 || i >= GetLength(pl))
        return false;
    int j = 0;
    LNode* p;
    for (p = pl->next; j < i; j++, p = p->next)
        ;//空语句
    *rtval = p->data;

    return true;
}

//获取i下标的前驱值
bool GetPrio(LinkList pl, int i, ElemType* rtval)//O(n)
{
    if (i <= 0 || i >= GetLength(pl))
        return false;
    LNode* p;
    int j = 0;
    for (p = pl; j < i; ++j, p = p->next)  //找到i的前驱节点
        ;
    *rtval = p->data;

    return true;
}

//获取i下标的后继值
bool GetNext(LinkList pl, int i, ElemType* rtval)//O(n)
{
    if (i < 0 || i >= GetLength(pl) - 1)
        return false;
    int j=0;
    LNode* p;
    for (p = pl->next; j < i; ++j, p = p->next)//找到i下标的数据节点
        ;
    *rtval = p->next->data;

    return true;
}

//查找val的位置,返回节点地址,失败返回NULL
LNode* Seach(LinkList pl, int val)//LinkList ==LNode *,但是语义不同
{
    for (LNode* p = pl->next; p != NULL; p = p->next)
    {
        if (p->data == val)
            return p;
    }
    return NULL;
}

//在i下标插入数据val
bool Insert(LinkList pl, int i, ElemType val)
{
    if (i<0 || i>GetLength(pl))
        return false;
    //创建新节点
    LNode* p = (LNode*)malloc(sizeof(LNode));
    assert(p != NULL);
    if (p == NULL)
        return false;
    p->data = val;

    //找到合适的位置
    LNode* q;
    int j = 0;
    for (q = pl; j < i; ++j, q = q->next)
        ;

    //插入,p插入在q的后面
    p->next = q->next;
    q->next = p;

    return true;
}

//头插
bool Insert_head(LinkList pl, ElemType val)
{
    //LNode newnode = {val}; //局部变量:生命周期(进入函数创建,函数结束销毁)
    //newnode.next = pl->next;
    //pl->next = &newnode;
    LNode* p = (LNode*)malloc(sizeof(LNode));
    assert(p!=NULL);
    if (p == NULL)
        return false;
    p->data = val;
    p->next = pl->next;
    pl->next = p;

    return true;
}

//尾插
bool Insert_tail(LinkList pl, ElemType val)
{
    //创建新节点
    LNode* p = (LNode*)malloc(sizeof(LNode));
    assert(p != NULL);
    if (p == NULL)
        return false;
    p->data = val;
    //找尾巴
    LNode* q;
    for (q = pl; q->next != NULL; q = q->next)
        ;
    //新节点插在尾巴的后面
    p->next = q->next;//p->next = NULL;
    q->next = p;

    return true;
}

//删除第一个val的值
bool Delete(LinkList pl, ElemType val)
{
    //LNode *p = Seach(pl,val);//不可以
    //if (p == NULL)
    //    return false;
    
    //1.找到val的前驱节点
    LNode* p;
    for (p = pl; p->next != NULL; p = p->next)
    {
        if (p->next->data == val)//找到了
            break;
    }
    if (p->next == NULL)//没有找到
        return false;

    //2.把val节点从链表中剔除
    LNode* q = p->next;//q就是将要删除的节点
    p->next = q->next;//剔除q
    //3.删除val节点
    free(q);

    return true;
}

//输出顺序表
void Show(LinkList pl)
{
    for (LNode* p = pl->next; p != NULL; p = p->next)
    {
        printf("%d ",p->data);
    }
    printf("\n");
}
 

liuyani12138
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构——线性结构总结
doubelief's blog
06-11 1万+
数据结构——线性结构总结 数据结构——线性结构总结 写在前面 线性结构的特点 线性表 栈 队列 相关的Standard Template Library（STL）容器 list vector stack queue deque 习题 reference 写在前面 数据元素的存储（顺序存储和链式存储）和数据元素的操作（插入和删除）是数据结构的重要部分。 数据结构中的...
数据结构线性结构板块思维导图.pdf
12-10
数据结构线性表，栈和队列以及串和数组章节的知识概括的思维导图，主要有线性表的定义，特点；顺序表、链表的初始化，查找，插入，删除操作的执行与算法。栈和队列的定义，特点，以及插入，删除操作，以及串和数组的...
线性表初始化插入消毁
weixin_33860528的博客
03-13 51
#include "stdio.h"#include "iostream.h"#include "malloc.h"typedef struct{int no;int grade;}ElemType; typedef struct{ElemType *elem;int CurrentLength;int MaxSize;}SqList; void InitLis...
数据结构：顺序表基础操作
wh_0727的博客
11-06 166
       线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存储的线性表的特点：  1.线性表的逻辑顺序与物理顺序一致;  2. 数据元素之间的关系是以元素在计算机内“物理位置相邻”来...
数据结构线性结构和非线性结构
weixin_57219176的博客
07-20 2675
数据结构线性结构和非线性结构
数据结构-线性结构和非线性结构
没出过地球
06-15 812
数据结构的线性结构和非线性结构是数据组织的基本方式，它们在结构特点、应用场景、操作方式等方面存在显著的差异。
数据结构(全)
s6664的博客
06-21 5万+
线性结构, 树形结构, 图结构, 排序, 查找, 数据结构, 算法
数据结构之线性结构
123
05-10 1万+
  数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。   常见的数据结构可分为：线性结构、树形结构 和 图状结构。   线性结构是一个有序数据元素的集合。   常用的线性结构有：数组, 链表，栈 ，队列等。 一、数组   数组是是由相同类型的元素（element）的集合所组成的数据结构，分配一块连续的内存来存储。利用元素的下标位置可以计算出该元素对应的存
数据结构——线性结构
ZXlxilin
11-25 3114
数据结构——线性结构 一、线性结构 在学习线性表之前肯定是需要对线性结构进行理解，如果按我个人的经验来说的话对于线性结构的理解是在学习数据结构中最为重要的，几乎后面所有学习结构都或多或少对线性结构进行利用。 线性结构 特点 前提 在数据结构的非空有限集合中 1 存在唯一的一个被称做“第一个”的元素 2 存在唯一的一个被称做“最后一个”的数据元素 3 除最后元素之外，其它...
数据结构中的 线性结构和非线性结构
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
08-17 2273
数据结构中的 线性结构和非线性结构 线性结构： 1、最常用的数据结构、元素之间存在一对一的线性关系 2、两种不同的存储方式，顺序存储结构，链式存储结构。 3、顺序存储结构称为顺序表，顺序表中的存储元素是连续的。 4、链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点存放数据元素以及相邻元素的地址信息 5、线性结构常见的有：数组、队列、链表、栈 单链表 ：https://blog.csdn.net/weixin_43304253/article/details/119758276 双向链表
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构1 线性结构1
08-08
线性结构是数据结构的基础类型，其中数据元素按照特定顺序排列，每元素都有唯一的前驱和后继。线性结构包括多种具体形式，如线性表、栈和队列。 线性表是最基本的线性结构，由n个数据元素组成，每个元素都有一个...
线性数据结构Python实现
08-26
利用python实现了堆栈、队列、双端队列和链表等线性数据结构，可以直接使用也可以用作学习。注释较全。
线性数据结构动态演示
06-04
在这个“线性数据结构动态演示”中，我们主要关注的是链表和顺序表这两种常见的线性结构，它们在Java编程语言中得到了实现，并通过一个动态演示系统进行展示。 首先，链表是一种非连续的内存存储结构，它的每个元素...
数据结构教程.docx
08-10
线性数据结构：数据元素按顺序排列，如数组、链表、栈和队列。 非线性数据结构：数据元素之间的关系复杂，如树和图。 二、线性数据结构 1. 数组（Array） 数组是一组具有相同类型的数据元素的集合，通过索引进行...
图解大顶堆的构建、排序过程
sagima_sdu的博客
08-12 505
开始，
【长度最小的子数组】python刷题记录
m0_73629042的博客
08-12 242
【代码】【长度最小的子数组】python刷题记录。
深入理解MySQL索引：原理、数据结构与优化策略
最新发布
乙壳虫的博客
08-16 612
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
知识改变命运 数据结构【洗牌算法(顺序表)】
2402_84062064的博客
08-13 276
a：这个类里面包括一个String类型的数据和int数据类型的数据分别存储花色和牌号b：创建一个构造方法对牌号和花色赋值·c：进行toString重写a：创造一个数组里面包含了四种花色b：利用for循环对花色与牌号结合 然后赋值给牌中。
数据结构线性结构顺序查找
04-11
线性结构是一种简单的数据结构，它的元素之间存在一对一的关系。其中，顺序查找是线性结构中最基本的查找算法之一。 顺序查找，也称为线性查找，是一种逐个比较目标元素和数据结构中每个元素的查找方法。具体步骤如下： 1. 从数据结构的第一个元素开始，逐个与目标元素进行比较。 2. 如果找到与目标元素相等的元素，则返回该元素的位置。 3. 如果遍历完整个数据结构仍未找到目标元素，则返回查找失败。 顺序查找的时间复杂度为O(n)，其中n为数据结构中元素的个数。由于需要逐个比较元素，所以在数据量较大时效率较低。但在数据量较小或无序的情况下，顺序查找是一种简单有效的查找方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值