数据结构——顺序表和链表的封装

最新推荐文章于 2024-02-22 20:07:24 发布
最新推荐文章于 2024-02-22 20:07:24 发布
阅读量178 收藏
点赞数 1
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/THNunlimited/article/details/127201105
版权

顺序表

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100 /* 存储空间初始分配量 */

typedef int ElemType;
typedef struct//定义顺序表
{
    ElemType length;
    int* data;
}SqList;

void InitList(SqList& L)//初始化顺序表
{
    L.data = new ElemType[MAXSIZE];
    L.length = 0;
}

void WriteList(SqList& L)//把元素放入顺序表
{
    printf("请输入你要创建的顺序表的长度：");
    scanf_s("%d", &L.length);
    printf("请输入%d个你要放入顺序表里的元素：", L.length);
    for (int i = 0; i < L.length; i++)
        scanf_s("%d", &L.data[i]);
}


bool ListInsret(SqList& L)//插入元素
{
    int i, e,j;
    printf("请输入要插入顺序表的元素和元素位置：");
    scanf_s("%d %d", &e, &i);
    if (i<1 || i>L.length + 1)
        return false;
    if (L.length == MAXSIZE)
        return false;
    for (j = L.length-1; j >= i-1; j--)
    {
        L.data[j + 1] = L.data[j];
    }
    L.data[i-1] = e;
    ++L.length;
    printf("插入的元素是%d，插入的位置是%d\n", e, i);
    return true;
}

bool ListDelete(SqList& L)//删除操作
{
    int i, e, j;
    printf("请输入要删除的元素位置：");
    scanf_s("%d", &i);
    if (i<1 || i>L.length)
        return false;
    if (!L.data)
        return false;
    e = L.data[i-1];
    for (j = i; j <= L.length-1; j++)
    {
        L.data[j - 1] = L.data[j];
    }
    --L.length;
    printf("删除的元素是%d，这个元素的位置是%d\n", e, i);
    return true;
}

bool GetElem(SqList& L)//按位查找
{
    int i;
    printf("你要找第几个元素：");
    scanf_s("%d", &i);
    if (!L.data || i<1 || i>L.length)
    {
        printf("查找失败\n");
        return false;
    }
    printf("第%d个元素是%d\n", i, L.data[i-1]);
    return true;
}

void LocateElem(SqList& L)//按值查找
{
    int e;
    int k = 1;
    printf("输入你要查找的元素值：");
    scanf_s("%d", &e);
    for (int i = 0; i < L.length; i++)
        if (L.data[i] == e)
        {
            printf("找到了，是第%d个元素\n", i + 1);
            k = 0;
            break;
        }
    if (k)
        printf("找不到元素%d\n", e);
}

bool PrintList(SqList& L)//打印顺序表
{
    if (!L.data)
        return false;
    printf("顺序表里的元素有：");
    for (int i = 0; i < L.length; i++)
        printf("%d ", L.data[i]);
    printf("\n");
    return true;
}

void DestroyList(SqList& L)//销毁顺序表
{
    char a;
    getchar();
    printf("是否销毁顺序表(Y/N):");
    scanf_s("%c", &a);
    if (a == 'Y')
    {
        L.length = 0;
        delete L.data;
        printf("顺序表已销毁\n");
    }
}

int Length(SqList& L)//求表长
{
    if (L.length == 0)
        return 0;
    return L.length;
}

int main()
{
    SqList L;
    InitList(L);
    WriteList(L);
    PrintList(L);
    ListInsret(L);
    PrintList(L);
    ListDelete(L);
    PrintList(L);
    GetElem(L);
    LocateElem(L);
    int len = Length(L);
    printf("顺序表的表长:%d\n", len);
    DestroyList(L);
    return 0;
}

单链表

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef int ElemType;
//定义单链表结构
typedef struct Node
{
    ElemType data;//数据域
    struct Node* next;//指针域，指向下一节点
}LNode,* LinkList;
//函数声明（若未声明，可能会有警告甚至错误）
LinkList initList(LinkList &L);
LinkList createList(int len);
int GetElem(LinkList L, int i, ElemType &e);
int ListInsert(LinkList &L, int i, ElemType e);
int ListDelete(LinkList &L, int i, ElemType *e);
void reverseLinkList(LinkList L);
int LocateElem(LinkList L, ElemType e);
int getLen(LinkList L);
int isEmpty(LinkList L);
void printLinkList(LinkList L);
int main()
{
    LinkList L;
    ElemType e;
    int len, i;
    printf("创建元素个数：");
    scanf_s("%d", &len);
    printf("\n请输入：");
    L = createList(len);
    printf("当前链表所有元素：");
    printLinkList(L);
    printf("\n请输入查找元素位置：");
    scanf_s("%d", &i);
    GetElem(L, i, e);
    printf("\n元素%d已取值", e);
    printf("\n插入位置和插入值(中间用空格隔开)：");
    scanf_s("%d%d", &i, &e);
    ListInsert(L, i, e);
    printf("\n插入元素后链表所有元素：");
    printLinkList(L);
    printf("\n请输入删除元素位置：");
    scanf_s("%d", &i);
    ListDelete(L, i, &e);
    printf("\n元素%d已删除", e);
    printf("\n删除后链表所有元素：");
    printLinkList(L);
    printf("\n请输入查找元素：");
    scanf_s("%d", &e);
    if (LocateElem(L, e) != -1)
    {
        printf("\n%d位于：%d", e, LocateElem(L, e));
    }
    else printf("\n%d未找到", e);
    reverseLinkList(L);
    printf("\n转置后链表所有元素：");
    printLinkList(L);
    return 0;
}

//初始化，创建头结点
LinkList initList(LinkList &L)
{
    L = new LNode;//为头结点分配空间
    L->next = NULL;//头结点指针域置空
    return L;
}
//创建指定个数的单链表 后差
LinkList createList(int len)
{
    int i;
    ElemType e;
    LinkList L = initList(L),  r,  n;//分别定义头指针、尾指针、新指针
    r = L;//尾指针初始化为头指针
    for (i = 0; i < len; i++)
    {
        scanf_s("%d", &e);
        n = new LNode;//申请空间
        n->data = e;
        n->next = NULL;//新指针指针域置空
        r->next = n;//将新指针链入单链表末尾
        r = r->next;//尾指针往后移
    }
    return L;
}

int GetElem(LinkList L, int i, ElemType &e)
{
    if (isEmpty(L)) return -1;
    LinkList p;
    p = L->next;
    int j = 1;
    while (p && j<i)
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
        return -1;
    e = p->data;
    return 1;
}

//将元素插入指定位置
int ListInsert(LinkList& L, int i, ElemType e)
{
    LinkList p = L, s;
    int j=0;
    while (p&&(j<i-1))
    {
        p = p->next;
        ++j;
    }
    if (i < 1 || i > getLen(L) + 1) return 0;//插入位置错误
    s = new LNode;
    s->data = e;
    s->next = p->next;//先把新指针（插入值）链入尾指针后一个节点
    p->next = s;//再把新指针（插入值）链入尾指针之后
    return 1;
}
//将指定位置元素删除
int ListDelete(LinkList& L, int i, ElemType *e)
{
    LinkList p = L,q;
    int j=0;
    while ((p->next) && (j<i-1))
    {
        p = p->next;
        ++j;//将尾指针移动到删除位置
    }
    if (i < 1 || i > getLen(L)) return 0;//删除位置错误
    q = p->next;//删除元素节点
    *e = q->data;//保存删除元素值
    p->next = q->next;//将尾指针跳过删除节点链入下一个节点
    delete q ;//释放删除节点
    return 1;
}
//转置单链表：采用前插法
void reverseLinkList(LinkList L)
{
    LinkList r,  p,  q;//定义尾指针（紧贴头指针）、欲插入指针、遍历指针
    r = L->next;//尾指针紧贴头指针
    p = q = r->next;//从第二个元素开始
    r->next = NULL;//尾指针置空
    while (q)//q相当于q != NULL
    {
        q = q->next;//遍历指针后移
        p->next = r;//欲插入指针链入尾指针之前
        L->next = p;//欲插入指针链入头指针之后
        r = p;//尾指针向前移
        p = q;//欲插入指针与遍历指针同步
    }
}
//查找指定元素，返回指定元素位序
int LocateElem(LinkList L, ElemType e)
{
    if (isEmpty(L)) return -1;
    int i = 1;//位序从1开始、下标从零开始
    LinkList p = L->next;
    while (p && p->data!=0)
    {
        if (p->data == e) 
            return i;//找到指定元素，返回位序
        p = p->next;//尾指针后移
        i++;
    }
    return -1;//遍历完成仍未找到返回-1
}
int getLen(LinkList L)
{
    if (L->next == NULL) return 0;//头指针指针域为空，说明单链表不含任何元素
    int len = 0;
    LinkList r = L->next;
    while (r)
    {
        r = r->next;//尾指针后移
        len++;
    }
    return len;
}
int isEmpty(LinkList L)
{
    return !L->next;//L->next == NULL亦可
}
void printLinkList(LinkList L)
{
    LinkList p;
    p = L->next;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
}

THNunlimited
关注
【数据结构】封装顺序表
Vcrossover的博客
12-15 1212
  最近在看《大话数据结构》，回顾一下之前数据结构的学习，之前是用C语言来完成的代码，鉴于已经学习了C++，此次便使用类来进行顺序表的封装吧！ 一、概念   顺序表，全名顺序存储结构，是线性表的一种，他符合线性表“一对一”的逻辑关系。同时又占用一组地址连续的存储单元。 动态顺序表：指的是用来存储数据的数组大小是我们动态申请的，用起来比较灵活。 静态顺序表：在设计的时候，就已经规定了数组的大小，不灵活。 此次我们使用的是动态顺序表来进行的操作。 二、设计顺序表 线性表的动态分配顺序存储结构 typedef
【数据结构】顺序表/链表的运算及实现
weixin_44799923的博客
12-01 1086
数据结构的基础知识，包括顺序表/链表运算及实现
C语言单链表实现初始化、创建、增、删、查等基本操作（详细）
热门推荐
Qian_Qian_IT的博客
09-25 6万+
C语言单链表实现初始化、创建、增、删、查等基本操作 #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef int ElemType; //定义单链表结构 typedef struct Node { ElemType data;//数据域 struct Node *next;//指针域 } LinkList; //初始化 LinkList *initList(LinkList *
顺序表的封装
03-24 257
#include<iostream>typedef int DataType;typedef int Status;#define MaxSize 100typedef struct{ DataType data[MaxSize]; int length;}SeqList;#define TRUE 1#define FALSE 0#define OK 1#de...
C语言链表的基本操作
weixin_33744141的博客
04-30 74
*/ * Copyright (c) 2016，烟台大学计算机与控制工程学院 * All rights reserved. * 文件名：text.cpp * 作者：常轩 * 微信公众号：Worldhello * 完成日期：2016年4月230日 * 版本号：V1.0 * 问题描述：链表的基本操作 * 程序输入：无 * 程序输出：见运行结果 */ #include"stdi...
单链表 C++
weixin_34220623的博客
10-28 247
单链表 C++ 题目 1、创建单链表2、初始化单链表3、释放单链表4、获取单链表中元素的数量5、输出单链表中的所有数据6、获取单链表中指定位置的元素7、根据键值查找指定元素8、采用头插法向单链表中插入一个元素9、采用尾插法向单链表中插入一个元素10、向单链表中的指定位置插入一个元素11、删除指定位置的元素 设计类图 文件结构 效果 ...
数据结构——顺序表
m0_74310998的博客
04-08 1657
本篇为数据结构系列的第一篇文章，数据结构是一种有效地存储和管理数据的方法，在应对实际问题时的重要性不亚于算法。本系列为我在学习数据结构后对于数据结构的理解，使用的语言为C。这里提几点建议，数据结构最重要的是思想，先有思路再进行代码还原能提高学习效率，在学习时，建议多画图辅助理解，图形能更直观地表达出数据结构。
C++基础应用———通讯录(链表）.rar
07-17
这个系统基于结构体和链表数据结构，旨在教授初学者如何运用C++的基本概念来创建一个实用的程序。下面我们将详细探讨通讯录系统中的关键知识点。 1. **C++语言基础**： - C++是一种通用的、面向对象的编程语言，...
数据结构——链表
m0_74310998的博客
05-04 1150
链表是一种基础的线形数据结构，但是其与顺序表有着较大的差别。但是由于链表与顺序表均为线形结构，本篇将穿插对比分析它们在部分性能上的优劣性。建议萌新先学习顺序表，再来看链表。
C++数据结构 —— 哈希表、unordered_map/set封装
weixin_59913110的博客
03-17 1613
顺序结构以及平衡二叉搜索树结构中，在查找一个元素时需要经过比较。顺序查找时间复杂度为O(N)，平衡二叉搜索树查找时间复杂度为O(log_2N)。理想的搜索方法便是不经过任何比较，通过常数次的操作从表中得到搜索的元素。如果构造一种存储结构，如果某种函数使元素的存储位置与它存储的元素之间形成一种映射关系，那么在查找中可以通过该函数很快找到搜索元素。该方式称为哈希(散列)方法，哈希方法使用的转换函数称为哈希函数， 构造出来的数据结构称为哈希表。
C/C++语言：顺序表 的封装
weixin_45580017的博客
04-09 1774
C/C++语言：顺序表的封装
链表的初始化【C语言】
少年一贯快马扬帆，道阻且长不转弯； 要盛大，要绚烂，要哗然； 要用理想的泰坦尼克，去撞现实的冰川； 要当烧赤壁的风，而非借鉴草船； 要为了一片海，就肯翻万山。
07-20 4325
/*By yangbocsu 线性表之链表 2021.07.20*/ #include <stdio.h> #include <stdlib.h> /*预定义常量和类型*/ /*函数结果状态码*/ #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -
C++封装顺序表
qq_55904031的博客
09-22 354
文章目录前言一、顺序表是什么？二、需求分析三、具体实现 前言 前几期讲过类，构造函数，运算符重载，这一期就利用这三块的知识做一期简单的应用，用C++封装顺序表。 一、顺序表是什么？ 如图所示，在内存中的一块连续的空间 这种内存布局非常像数组，因此也被成为动态数组 在C++标椎模板库中有一个顺序表vector容器，我们要做的就是封装一个丐版的vector容器 二、需求分析 1.定义Myvector类，和内部接口 2.初始化、销毁、深拷贝 3.自动扩容 4.增删查改 5.获取大小和容量 6.用 [ 索引
C语言实现单链表的初始化、增删查改基本操作)
MZYYZT的博客
01-27 1545
C语言实现单链表的初始化、增删查改基本操作引言定义原理优点缺点比较时间上空间上实验过程及结果代码运行结果总结 引言 定义 ★★★单链表是线性表的链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。 原理 <1> 链表中的数据是以结点来表示的，每个结点的构成：数据域+指针域。 <2> 数据域即是存储数据的存储单元，指针域即是存储后继结点的地址。 优点 <1> 单链表在插入或删除元素时，只需要改变它的前驱元素及插入或删除元素的指向。 <2> 在存储
【C++】---封装顺序表
weixin_44915076的博客
07-22 347
封装顺序表：基础的数据结构有：顺序表、链表、栈、队列。这些数据结构我们都需要用到，但是在C语言中没有这样的库去供我们使用。但是C++中是有这样的库，也就是STL标准模板库中有一个组件是容器组件，容器组件中有一个顺序容器vector<int>就是来封装顺序表的，这样我们可以不用建立数据结构，可以直接使用这些数据结构。 由于数组是定长的，所以在封装顺序表的时候我们用到了扩容机制： 1、以倍数的形式开辟更大的空间 2、旧数据拷贝到新的空间中 3、旧空间释放 4、指针指向新空间 STL(标准模...
C语言链表的基本操作—建表，遍历，增加，删除，翻转
Priscilla_cola的博客
08-16 870
链表节点的增加和删除，最重要的就是要找到要增加或删除的这个节点的前一个节点，所以如果要删除第n个节点，那么就需要让索引index=n-1，index要从0开始计数。这里要注意的就是要删除和增加的节点是链表的第一个节点的情况，所以最好单独进行处理。如果再严谨一点，还可以加入对要操作节点的索引的判断，看其是否处于链表当中。链表的基本操作就是创建链表，遍历整个链表，增加节点，删除节点，翻转链表这些。创建链表一般使用的是尾插法，就是始终有一个指针指向新建节点的前一个节点。链表的翻转，很容易。...
C语言链表的基本操作：增、删、遍历、翻转
素炒瓢儿白的CSDN博客
04-19 826
内容 实现了单链表的基本操作，包括：节点的创建、添加、插入、删除、遍历、翻转。 代码 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #include &lt;assert.h&gt; #include &lt;time.h&gt; typedef unsigned long Da...
链表的基础操作（c语言）
最新发布
m0_72714248的博客
02-22 2270
概述：链表的现状背景是指链表在当前的使用环境中的应用和状况。链表在实际开发中有广泛的应用，特别是在需要频繁插入和删除元素的场景中，链表的动态性能够发挥出很大的优势。链表也有多种变种，如双向链表、循环链表等，根据不同的需求选择不同类型的链表。除了常见的单链表之外，还有其他一些特殊的链表结构，如带头结点的链表和虚拟链表。带头结点的链表在链表的第一个节点之前增加一个特殊节点作为头结点，可以简化链表的操作和处理边界情况。虚拟链表是一种特殊的链表，它通过使用虚拟节点来简化链表的实现和操作。
c语言:链表的基本操作
weixin_45695535的博客
03-19 190
说明:c语言的一个收尾之作，对链表的处理包括插入，排序（冒泡排序），删除，编辑，本应该早就写的这个因种种原因拖到现在才写完 ps:这个收尾不包括文件处理二级指针以及行指针,学习c不会停; #include<stdio.h> #include<string.h> #define NULLL 0 typedef struct lb { char name[20],num...
C++实现数据结构：线性表与链表的奇偶数分离
在这个主题中，我们关注的是两种基本的数据结构——顺序线性表和单链表，并讨论了如何在C++中实现它们以及如何利用这些数据结构进行特定的操作，例如根据数值的奇偶性进行分类。 首先，顺序线性表是一种简单的数据...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值