数据结构第二篇——线性表的顺序存储

?注:未经博主同意,不得转载。

线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。

由于高级程序语言中的数组类型也有随机存取的特性,因此,通常都用数组来描述数据结构中的书序存储结构。

如下描述:

 1 const int MaxListSize=100;                //最大数据个数
 2 //other way
 3 //define MaxListSize  100
 4
 5 class List{
 6
 7     private:
 8     Data data[MaxListSize];          //存放数据
 9     int size;                     //数据个数
10
11     public:
12     List(){size=0;    }         //构造函数
13     //~List();                //析构函数
14
15     void Clear(){size=0;}        //清空
16     bool IsEmpty();            //判断是否为空
17     Data GetElem(int i);        //返回第i个元素的值
18     int Locate(Data e);        //返回第一个与e匹配的元素的位序
19     Data Prior(Data e);        //返回e的前驱
20     Data Next(Data e);        //返回e的后继
21     void Insert(Data e,int i);     //第i个位置插入新元素e
22     Data Delete(int i);            //删除第i个元素,返回该元素
23     int Length(){return size;}    //返回长度
24     void print();             //输出元素
25 };
26             

这些基本操作在顺序表中的实现如下:

  1 //插入元素
  2 void List::Insert(Data e,int i)
  3 {
  4     if(i<1||i>size+1||i>=MaxListSize)
  5     {
  6         cout<<"插入位置错误!"<<endl;
  7         exit(0);
  8     }
  9     else
 10     {
 11         for(int j=size-1;j>=i-1;--j)    //将i后的元素整体往后移一个单位
 12             data[j+1]=data[j];
 13
 14         data[i-1]=e;                            //将元素e插入
 15         ++size;
 16     }
 17 }
 18
 19 //删除元素
 20 Data List::Delete(int i)
 21 {
 22     if(i<1||i>size)
 23     {
 24         cout<<"删除位置错误!"<<endl;
 25         exit(0);
 26     }
 27     else
 28     {
 29         Data e=data[i-1];
 30         for(int j=i-1;j<size-1;++j)
 31             data[j]=data[j+1];
 32         --size;
 33         return e;
 34     }
 35 }
 36
 37 //查找与e匹配的第一个元素
 38 int List::Locate(Data e)
 39 {
 40     int i=1;
 41     while(i<=size&&data[i-1]!=e)
 42     ++i;
 43     if(i>size)
 44     return 0;
 45     else
 46     return i;
 47 }
 48
 49 //判断线性表是否为空
 50 bool List::IsEmpty()
 51 {
 52     if(size==0)
 53     return true;
 54     else
 55     return false;
 56 }
 57
 58 //取元素操作
 59 Data List::GetElem(int i)
 60 {
 61     if(i<1||i>size)
 62     {
 63         cout<<"位置错误!"<<endl;
 64         exit(0);
 65     }
 66     else
 67     return data[i-1];
 68 }
 69
 70 //输出所有元素
 71 void List::print()
 72 {
 73     if(size==0)
 74     {
 75         cout<<"空表,无元素!"<<endl;
 76         exit(0);
 77     }
 78     else
 79     {
 80         for(int i=0;i<size;++i)
 81         cout<<data[i]<<‘ ‘;
 82         cout<<endl;
 83     }
 84 }
 85
 86 //返回e的前驱
 87 Data List::Prior(int e)
 88 {
 89     for(int i=0;i<size;++i)
 90     {
 91         if(e==data[i])
 92         {
 93             if(i==0)
 94             {
 95                 cout<<"这已是第一个元素"<<endl;
 96                 return -100;
 97             }
 98             else
 99             return data[i-1];
100         }
101     }
102     cout<<"表中无此元素"<<endl;
103     return -101;
104 }
105
106 //返回e的后继
107 Data List::Next(int e)
108 {
109     for(int i=0;i<size;++i)
110     {
111         if(e==data[i])
112         {
113             if(i==(size-1))
114             {
115                 cout<<"这已是最后一个元素"<<endl;
116                 return -100;
117             }
118             else
119             return data[i+1];
120         }
121     }
122     cout<<"表中无此元素"<<endl;
123     return -101;
124 } 

对上述算法的调试则放在main函数里:

 1 int main()
 2 {
 3     system("color 0A");
 4     int a[8]={3,6,9,12,15,18,21,24};
 5     int i,j;
 6     Data x;                                //    定义元素x
 7     List list;                            //定义线性表对象
 8
 9     if(list.IsEmpty())
10     cout<<"当前为空表"<<endl<<endl;
11
12     for(i=1;i<=8;++i)                    //将数组a的元素插入线性表中
13     list.Insert(a[i-1],i);
14     list.print();
15     cout<<"当前线性表长度:"<<list.Length()<<endl;
16     cout<<endl;
17
18     cout<<"输入要插入的元素和位置:";
19     cin>>x>>i;
20     list.Insert(x,i);                //插入元素
21     list.print();
22     cout<<"当前线性表长度:"<<list.Length()<<endl;
23     cout<<endl;
24
25     cout<<"输入要插入的元素和位置:";
26     cin>>x>>i;
27     list.Insert(x,i);                //插入元素
28     list.print();
29     cout<<"当前线性表长度:"<<list.Length()<<endl;
30     cout<<endl;
31
32     cout<<"输入要插入的元素和位置:";
33     cin>>x>>i;
34     list.Insert(x,i);                //插入元素
35     list.print();
36     cout<<"当前线性表长度:"<<list.Length()<<endl;
37     cout<<endl;
38
39     if(list.IsEmpty())
40     cout<<"当前为空表"<<endl;
41     else
42     cout<<"当前非空"<<endl<<endl;
43
44     cout<<"输入要查找的元素:";    //查找某一个元素
45     cin>>x;
46     j=list.Locate(x);
47     if(j)
48     cout<<"查找成功,是第"<<j<<"个元素"<<endl;
49     else
50     cout<<"没有此元素"<<endl;
51     cout<<endl;
52
53     cout<<"输入要查找的元素:";    //查找某一个元素
54     cin>>x;
55     j=list.Locate(x);
56     if(j)
57     cout<<"查找成功,是第"<<j<<"个元素"<<endl;
58     else
59     cout<<"没有此元素"<<endl;
60     cout<<endl;
61
62     cout<<"当前表中元素:/t";
63     list.print();
64     cout<<"输入想要查找元素的位置:";        //    输出某个位置的元素
65     cin>>i;
66     cout<<list.GetElem(i)<<endl;
67     cout<<endl;
68     cout<<"输入想要查找元素的位置:";        //    输出某个位置的元素
69     cin>>i;
70     cout<<list.GetElem(i)<<endl;
71     cout<<endl;
72
73     cout<<"输入想要删除元素的位置:";        //    删除某个位置的元素
74     cin>>i;
75     cout<<list.Delete(i)<<endl;
76     list.print();
77     cout<<"当前线性表长度:"<<list.Length()<<endl;
78     cout<<endl;
79     cout<<"输入想要删除元素的位置:";        //    删除某个位置的元素
80     cin>>i;
81     cout<<list.Delete(i)<<endl;
82     list.print();
83     cout<<"当前线性表长度:"<<list.Length()<<endl;
84     cout<<endl;
85
86     cout<<"输入想要查找前驱的元素:";        //    查找某元素前驱
87     cin>>i;
88     if(list.Prior(i)>-100)
89     cout<<list.Prior(i)<<endl;
90
91     cout<<"输入想要查找后继的元素:";        //    查找某元素后继
92     cin>>i;
93     if(list.Next(i)>-100)
94     cout<<list.Next(i)<<endl;
95
96     return 0;
97 } 

最终的实现效果如下:

时间: 2024-11-08 07:57:08

数据结构第二篇——线性表的顺序存储的相关文章

数据结构第一篇——线性表的逻辑结构

?注:未经博主同意,不得转载. 线性表(linear list)是最常用且最简单的数据结构.简言之,一个线性表是n个数据元素的有限序列.至于每个数据元素的具体含义,在不同的情况下各不相同.例如,26个英文字母的字母表: (A,B,C,D,......Z) 线性表的抽象数据类型定义如下: 1 ADT List 2 { 3 Data: D={Ai|Ai<DataSet,i=1,2,...,n, n>=0} 4 //称n为线性表的表长 5 //称n=0时的线性表为空表 6 Structure: R=

数据结构导论 四 线性表的顺序存储VS链式存储

前几章已经介绍到了顺序存储.链式存储 顺序存储:初始化.插入.删除.定位 链式存储:初始化.插入.删除.定位 顺序存储:初始化 strudt student{ int ID://ID char name[30];//姓名 char sex; //性别 int class;//班级 int age;//年龄 } student={"01",“zhangsan”,"m","201","20"}: 链式存储:初始化 //建立一个空链

简要比较线性表的顺序存储结构和链式存储结构

我们分别从存储分配方式.时间性能.空间性能三方面来做对比. 存储分配方式 顺序存储结构用一段连续的存储单元依次存储线性表的数据元素. 单链表采用链式存储结构,用一组任意的存储单元存放线性表的元素. 时间性能 <1>查找 顺序存储结构O(1) 单链表O(n) <2>插入和删除 顺序存储结构需要平均移动表长一半的元素,时间为O(n) 单链表在计算出某位置的指针后,插入和删除时间仅为O(1) 空间性能 顺序存储结构需要预分配存储空间,分大了,容易造成空间浪费,分小了,容易发生溢出. 单链

数据结构期末复习第二章线性表

第二章:线性表 1.线性结构的基本特征答:线性结构是若干数据元素构成的有序(次序)集① 集合中必存在唯一的一个“第一元素”:② 集合中必存在唯一的一个 “最后元素”:③ 除第一元素之外,均有 唯一的前驱:④ 除最后元素之外,均有 唯一的后继. 2.线性表的顺序存储结构和链式存储结构分别是______.(  D )   A. 顺序存取的存储结构.顺序存取的存储结构  B. 顺序存取的存储结构.随机存取的存储结构   C. 随机存取的存储结构.随机存取的存储结构  D. 随机存取的存储结构.顺序存取

数据结构之线性表之顺序存储结构(3)

1 前言 经过前两张的理论基础,我相信大家都能简单的明白了数据结构和算法一些常用的概念了,从今天开始我们开始学习数据结构中线性表,一起叩响数据结构的大门. 2 详述 线性表(List):零个或者多个数据元素的有限序列. 如果用数学语言来进行定义: (声明:由于下标不是很好弄出来,所以只能表示下面这种方式了,请见谅!) 若线性表记作(a1,...ai-1,ai,ai+1,...,an),则表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素,ai+1是ai的直接后继元素.当i

数据结构之线性表(顺序存储结构)

小学生放学都是要按顺序排队的,一个接一个,每个小学生的前后位置是固定的,这样便于迅速清点. 其实这就是一个线性表,从这件事里我们就可以找到很多关于线性表的特性,如 1.线性表是一个序列,它是有顺序的(排队) 2.第一个元素无前驱,最后一个无后继,其他每个元素都有一个前驱和后继(一个接一个) 3.元素是有限的(小学生的个数是有限的) 4.数据类型都相同(都是小学生在排队) 说明白线性表示什么,下面我们直接看线性表的实现 线性表的实现分顺序存储结构和链式存储结构 顺序存储结构: #define LI

数据结构之第二章线性表

1 线性表的顺序存储 (1)线性表的顺序存储特点:逻辑上相连的元素,物理位置也相连.可随机访问表中元素,表中的存储位置可以用一个简单的,直观的公式表示,但是插入和删除都要移动大量的元素,效率不高,适合元素个数变化不大的情况,此时,如数据元素按照一定的顺序存储,则称为顺序存储的有序表,简称为    静态表. (2)线性表的动态分配顺序存储结构 typedef struct{ Elemtype *elem; //存储空间起始地址 int length; //当前长度 int listsize; //

《大话数据结构》笔记(2)--线性表的顺序存储结构

线性存储结构的Java实现代码: https://github.com/Lyu0709/data-structure/tree/master/src/com/coding/basic/array 第三章 线性表 定义 数学语言 若将线性表记为(a1, ..., ai-1, ai, ai+1, ..., an),则表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素,ai+1是ai的直接后继元素.当i=1,2,..,n-1时,ai有且仅有一个直接后继,当n=2,3,...,n

数据结构-线性表之顺序存储结构

一.线性表的顺序存储需要三个属性 1.存储空间的起始位置 2.线性表的最大存储容量 3.线性表的当前长度 二.线性表的时间复杂度: 线性表的顺序存储结构,在存.读数据时,不管是哪个位置,时间复杂度都是O(1); 插入删除的时间复杂度是O(n),所以线性表适合元素个数不太变化,而更多是存取数据的应用. 三.线性表的结构示意图: 四.代码示例: /*我们的计量方式,除下标从0开始外,其余都从1开始算,所以只有在涉及访问数组的时候,要注意是否要+1 或-1*/ #include <stdio.h>