数据结构（一）——实现线性表顺序存储结构的增改删查

最新推荐文章于 2022-11-20 11:57:06 发布
最新推荐文章于 2022-11-20 11:57:06 发布
阅读量1k 收藏 9
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44244154/article/details/104738573
版权

一.线性表的定义

线性表：简称表，是n（n≥0）个具有相同类型的数据元素的有限序列。
}
线性表的长度：线性表中数据元素的个数。
空表：长度等于零的线性表，记为：L=( )。
非空表记为：L＝（a1, a2 , …, ai-1, ai , …, an)
其中，ai（1≤i≤n）称为数据元素；
下角标 i 表示该元素在线性表中的位置或序号 。

二.顺序存储结构实现线性表的增改删查

2.1 采用C++实现，代码如下：（数组的第一个元素a[0]未使用）

#include<iostream>
#define MaxListLen 15
using namespace std ;
int Error = 0 ;
int ListLen = 0 ;
int SeqList [MaxListLen + 1] ;

//顺序表的插入
void InsertSeqList (int NewItem , int i)
{
    int j ;

    if ((i > ListLen + 1) || (i < 1) || (ListLen == MaxListLen))
    {
        Error = -2 ;    //插入出错返回
        cout << "插入出错！！！";
    }
    else
    {
        for (j = ListLen ; j >= i ; j -- )    //从后往前移
        {
            SeqList [j+1] = SeqList [j] ;
        }
        SeqList [i] = NewItem ;        //插入新元素
        ListLen = ListLen + 1 ;        //表长加一
    }
}


//顺序表查找
int SearchSeqList (int i)
{
    if ((i > ListLen+1) || (i < 1) || (ListLen == 0))
    {
        Error = -1 ;
        cout << "查找位置出错！！！" ;
        return (Error) ;    //查找出错返回
    }
    else
    {
        return SeqList[i] ;    //返回指定位置的元素值
    }
}


//顺序表指定位置数据的删除
int DeleteSeqList (int i)
{
    int j ;

    if ((i > ListLen)||(i < 1) || (ListLen == 0))
    {
        Error = -3 ;    //删除出错返回
        cout << "删除位置出错！！！" ;
        return (Error) ;
    }
    else
    {
        for (j = i ; j < ListLen ; j ++ )    //从前往后移
        {
            SeqList [j] = SeqList [j+1] ;
        }
        ListLen = ListLen - 1 ;        //表长减一
    }
}


//顺序表显示
void ShowSeqList ()
{
    int i ;

    cout << "The list : " <<endl     ;
    for (i = 1 ; i <= ListLen ; i ++ )
    {
        cout <<SeqList[i]<<" " ;    //逐个显示数据元素
    }
    cout << endl ;            //换行
}


//主函数
int main (int argc , char * argv[])
{
    int  i , SearchPos , NewPos , NewItem , DelPos ;

    cout << "请输入样本数目: " <<endl ;
    cin >> ListLen ;    //输入样本数目（表长）
    //创建顺序表
    for (i = 1 ; i <= ListLen ; i++)
    {
        cout << "Please input No." << i <<" Item : ";
        cin >> SeqList[i] ;
    }
    ShowSeqList () ;    //显示顺序表

    cout << "请输入你想查找的位置: "<<endl  ;
    cin >> SearchPos ;    //输入查找位置

    cout << "Your Searched Item is : " <<SearchSeqList (SearchPos) << endl ;    //输出查找的数据元素值

    cout << "请输入你想插入的位置: " <<endl ;
    cin >> NewPos ;        //插入位置输入
    cout << "After insert " <<endl ;
    cin >> NewItem ;    //插入元素输入
    InsertSeqList (NewItem , NewPos) ;    //新数据插入顺序表MAXLISTLEN 100
    cout << "After Insert : " ;
    ShowSeqList () ;    //显示顺序表
    cout << "请输入你想删除的位置: " ;
    cin >> DelPos ;        //输入删除元素位置
    DeleteSeqList (DelPos) ;    //按位置删除数据
    cout << "After delete : " ;
    ShowSeqList () ;
    if (Error < 0) cout <<"Error: " << Error << endl ;
    return 0 ;

}

实验结果如下：
在这里插入图片描述

2.2 采用类模板实现顺序存储结构线性表的增改删查，代码如下：

#include <iostream>           //引用输入输出流库函数的头文件
using namespace std;
#define random(x) (rand()%x)+1

const int MaxSize = 15;          //15只是示例性的数据，可以根据实际问题具体定义
template <class DataType>        //定义模板类SeqList
class SeqList
{
	public:
		SeqList( ) {length = 0;}            //无参构造函数，建立一个空的顺序表
		SeqList(DataType a[ ], int n);       //有参构造函数，建立一个长度为n的顺序表
		~SeqList( ) { }                   //析构函数为空
		int Length( ) {return length;}        //求线性表的长度
		DataType Get(int i);               //按位查找，在线性表中查找第i个元素
		int Locate(DataType x );           //按值查找，在线性表中查找值为x的元素序号
		void Insert(int i, DataType x);       //插入操作，在线性表中第i个位置插入值为x的元素
		DataType Delete(int i);              //删除操作，删除线性表的第i个元素
		void PrintList( );                     //遍历操作，按序号依次输出各元素
	private:
		DataType data[MaxSize];           //存放数据元素的数组
		int length;                        //线性表的长度
};

template <class DataType>
SeqList<DataType> :: SeqList(DataType a[ ], int n)
{
  if (n > MaxSize) throw "参数非法";
  for (int i = 0; i < n; i++)
	  data[i] = a[i];
  length = n;
}

template <class DataType>
DataType SeqList<DataType> :: Get(int i)
{
  if (i < 1 && i > length) throw "查找位置非法";
  else return data[i - 1];
}

template <class DataType>
int SeqList<DataType> :: Locate(DataType x)
{
  for (int i = 0; i < length; i++)
    if (data[i] == x) return i+1;       //下标为i的元素等于x，返回其序号i+1
  return 0;                        //退出循环，说明查找失败
}

template <class DataType>
void SeqList<DataType> :: Insert(int i, DataType x)
{
    if (length >= MaxSize) throw "上溢";
    if (i < 1 || i > length + 1) throw "插入位置非法";
	for (int j = length; j >= i; j--)
			data[j] = data[j - 1];             //注意第j个元素存在数组下标为j-1处
	data[i - 1] = x;
	length++;
}

template <class DataType>
DataType SeqList<DataType> :: Delete(int i)
{
  if (length == 0) throw "下溢";
  if (i < 1 || i > length) throw "删除位置非法";
  DataType x = data[i - 1];              //取出位置i的元素
  for (int j = i; j < length; j++)
    data[j - 1] = data[j];        //注意此处j已经是元素所在的数组下标
  length--;
  return x;
}

template <class DataType>
void SeqList<DataType> :: PrintList( )
{
  for (int i = 0; i < length; i++)
    cout << data[i]<<" ";                   //依次输出线性表的元素值
  cout << endl;
}


void main( )
{
      char r[10];
      for(int i = 0; i < 10; i++)
	     r[i] =char(65+random(26));		
      SeqList<char> L(r, 10);
      cout<<"执行插入操作前数据为："<<endl;
      L.PrintList( );              //输出所有元素
      try                       
	  {
	    L.Insert(5,'a');					}
        catch (char *s)
		{
           cout<<s<<endl;
		}
      cout<<"执行插入操作后数据为："<<endl;
      L.PrintList( );              //输出所有元素
      cout<<"值为'a'的元素位置为:";
      cout<<L.Locate('a')<<endl;    //查找元素3，并返回在单链表中位置
      cout<<"执行删除第五个元素操作，删除前数据为："<<endl;
      L.PrintList( );              //输出所有元素
	  try                       
	  {
	    L.Delete(5);                //删除第1个元素
	  }
      catch (char *s)
	  {
	    cout<<s<<endl;
	  }
      cout<<"删除后数据为："<<endl;
      L.PrintList( );              //输出所有元素
}

实验结果如下：
在这里插入图片描述

三.小结

顺序存储结构采用数组实现，是数据结构中最简单的一种存储方式。顺序表的优缺点如下：

顺序表的优点：

⑴ 无需为表示表中元素之间的逻辑关系而增加额外的存储空间；
⑵ 随机存取：可以快速地存取表中任一位置的元素。

顺序表的缺点：

⑴ 插入和删除操作需要移动大量元素；
⑵ 表的容量难以确定，表的容量难以扩充；
⑶ 造成存储空间的碎片。

诶你爱我吗
关注
专栏目录
数据结构——线性表——顺序存储结构——C++实现线性表
MISAYAONE的博客
05-12 1794
顺序存储结构C++实现篇：主要实现了线性表的定义、初始化、显示、增、删结点操作。 切记亲力亲为，动手实践写代码 main.cpp /*************************************************************************** * @file main.cpp * @author MISA
线性表的顺序存储 增删改查功能
03-16
线性表的顺序存储 增删改查功能 dos窗口输入输出
线性表1：顺序表的增 删 改 查
hellohelloe的博客
01-28 591
顺序存储结构【顺序表】的增 删 改 查seqlist线性表新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 此系列文主要用于自查、复习。所以行文、逻辑、思路是按照个人的思考方式来的，但也希冀能帮到一二三位初学者。 线性表 你
数据结构 线性表之顺序表的增删改查
faith_girl的博客
04-24 182
#include<stdio.h> #include<stdlib.h> #define InitSize 10//顺序表的初试长度 typedef struct{ int *data; int MaxSize; int length; }SeqList; void InitList(SeqList &L){//顺序表 L.data=(int *)malloc(InitSize*sizeof(int)); L.length=0; L.MaxSize=InitSi
线性表的顺序储存，包括了增删改查操作
11-02
线性表的顺序储存，该源文件包括了线性表的增删改查等操作，对于学习数据结构的同学有帮助，
顺序表实现线性表中常见的操作（增删改查）
weixin_48072522的博客
01-06 450
1.创建ArrayList实例 //多态，向上转型 List<String> arrayList1 = new ArrayList<>(); 2.往ArrayList中添加一些元素 //add其中一个参数版本是添加到顺序表末尾 arrayList.add("c"); arrayList.add("c++"); arrayList.add("java"); arrayList.add("python"); //add的另一个参数版本是把元素添加到下标指定位置上 ar.
数据结构（一）——线性表的顺序存储原理及实现
hml111666的博客
02-09 2660
一、线性表介绍 1、定义：由n（n>0）个相同类型的元素组成的有序集合，如图 这里所说的线性表是逻辑结构，表示元素一对一的相邻关系，是独立于存储结构（顺序表和链表）的，他们属于不同层面的概念 2、特点： ➢表中元素的个数是有限的。 ➢表中元素的数据类型都相同。意味着每一个元素占用相同大小的空间 ➢表中元素具有逻辑上的顺序性，在序列中各元素排序有其先后顺序 3、实现方式——顺序表及链表 3.1顺序表：线性表的顺序表示 逻辑上相邻的两个元素在物理位置上也相邻 以上代码描述：.
数据结构算法代码实现——线性表的顺序表示与实现（二） 定义线性表节点的结构.pdf
04-18
数据结构算法代码实现——线性表的顺序表示与实现（二）定义线性表节点的结构 本资源主要介绍了数据结构中线性表的顺序表示和实现，包括线性表的定义、顺序存储结构、基本操作等内容。 线性表的定义 线性表是一种...
数据结构——线性表（顺序表的增、删、查）
Duanqi1的博客
07-06 661
-------顺序表介绍------- 线性表的顺序存储又称顺序表; 用一组地址连续的存储单元（数组)依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。一维数组可以静态分配，也可以动态分配。关于静态分配，数组的大小可空间事先固定，空间占满，加入新数据就会溢出。动态分配，存储空间通过执行程序中的动态分配存储语句实现，一旦数据空间占满，就另外开辟一块更大的存储空间，用来替换原来的存储空间，从而达到扩充存储的目的。 特点： 增删操作需移动大量数据元素; 支持随机存取。 ---------
数据结构——线性表顺序存储结构（C++代码）
09-28
线性表是数据结构中最基础且重要的概念之一，它是由n（n≥0）个相同类型元素构成的有限序列。顺序存储结构则是线性表的一种常见实现方式，它将...通过实际操作，可以加深对线性表顺序存储结构的理解，并提升编程技能。
2、 掌握线性表的基本操作：初始化，插入，删除，查找，判空，求线性表长度等运算在顺序存储结构和链式存储结构上的实现
10-29
一、 实验目的 1、 掌握线性表的结构特点。 2、 掌握线性表的基本操作：初始化，插入，删除，查找，判空，求线性表长度等运算在顺序存储结构和链式存储结构上的实现。 3、 通过本章实验帮助学生加深对C语言的使用（特别是函数的参数调用、指针类型的应用）。 二、 实验要求 1、 选择何时的存储方式实现线性表。其中，必须实现的线性表基本操作为：InitList、 ClearList、ListEmpty、ListLength、GetElem、PriorElem、ListInsert、ListDelete这8个基本操作，其余的可以选作。 2、 所写源代码编程风格良好，有详细注释。 3、 程序运行界面良好，使用菜单实现每个基本操作。 4、 实验报告书写规范。
数据结构单链表的创建，插入，修改，查找以及删除
10-24
数据结构单链表的创建，插入，修改，查找以及删除。线性表操作
顺序表区间元素删除
03-23
若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。
数据结构线性表的动态顺序实现增删改查
Lover
07-03 670
#include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 typedef int Status ; typedef int ElementType ;
c语言链表的基本操作 一（线性表链式存储结构的创建，链表元素的增加，删除，修改，查找）...
weixin_30300523的博客
07-30 673
#include<stdio.h> #include<malloc.h> typedef struct LNode { int data; struct LNode *next; }; LNode *Init_LNode() { LNode *head; head=(LNode *)malloc(sizeof(LNode)); ...
编程实现顺序存储结构和链式存储结构线性表的建立、查找、插入、删除等基本操作
热门推荐
foreverlove111的博客
10-30 1万+
#include #include typedef struct LNode{ int data; //链表数据 struct LNode* next; //链表指针 }LNode,*LinkList; typedef enum __bool { false = 0, true = 1, } bool; /*头插法-建立单链表*/ LinkList HeadCreate(Li
C++语法实现线性表顺序存储的增删查操作
Nanqipro的研究日常
03-24 1335
今天给大家分享我学习数据结构的学习成果： 用C++实现线性表的顺序存储操作： 首先定义一个结构体类型的变量（不要忘记头文件！！！） #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> //定义一个常量 #define MaxSize 15 //顺序表中的元素类型 typedef int ElemType; //定义一个线性表 typedef struct { ElemType d
线性表-顺序表的增`删`改`查
Router12的博客
04-22 285
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; struct LinearList { //定义线性表结构 int *list; int size; int MaxSize; }; typedef struct LinearList LIST; void InitList(LIST *L,i...
【数据结构】线性表 _顺序表 &链表的增删查改 _[细节分析+代码实现]
最新发布
qq_63179783的博客
11-20 1582
我们实现的链表存储的数据是int类型，所以对int进行重命名，如果存储的数据不是int类型，把int改成其他的类型即可。当容量为100时，满了之后扩容为200，但是我们只需要再插入5个数据，后面就没有数据插入了，就浪费了95个数据空间。我们在这里主要学习的是带头双向循环链表，虽然它看起来复杂，但是实现起来并不复杂，而且相比于其他类型有很大的优势。还有一个需要去注意的点是pos是数组下标，是有范围的，一定要注意数组的越界问题。如果传的是结构体，那么形参是实参的一份临时拷贝，形参的改变不会影响实参。
数据结构实验：线性表操作与实现——顺序表与链表
"该文档是关于浙江理工大学数据结构实验，主要关注线性表的操作与实现。实验分为两部分，一是顺序表的操作，包括创建、查找、插入和删除，以及顺序表的反转；二是链表的操作，同样涉及创建、输出、反转等。实验要求...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值