线性表()

合集下载

第一章线性表

11.线性表是A.一个有限序列，可以为空B.一个有限序列，不能为空C.一个无限序列，可以为空D.一个无限序列，可以为空正确答案是：【A】解析：线性表的定义如下：线性表是具有n（n≥0）个元素的一个有限序列，当n=0时称为空表。

2在n个结点的顺序表，算法的时间复杂度是O(1)的操作是A.访问第i个结点(1≤i≤n)和求第i个结点的直接前驱(2≤i≤n)B.在第i个结点后插入一个新结点(1≤i≤n)C.删除第i个结点(1≤i≤n)D.顺序查找与给定值x相等的元素正确答案是：【A】解析：顺序表可以按元素下标直接存和直接取，其时间复杂度为O(1)。

在第i个元素后面插入新元素和删除第i个元素的时间复杂度都是O(n)，顺序查找的时间复杂度也是O(n)。

3若长度为n的线性表采用顺序存储结构，在表的第i个位置插入一个数据元素，需要移动表中数据元素的数目为A.iB.n+iC.n-i+1D.n-i-1正确答案是：【C】解析：在线性表的第i个位置插入一个新的数据元素之前，需要先将线性表的第i个数据元素至第n个数据元素依次后移1个位置，一共需要移动n-i+1个数据元素。

4将两个各有n1和n2个元素的有序表（递增）归并成一个有序表，仍保持其递增顺序，则最少的比较次数是A.B.C.D.正确答案是：【C】解析：由于将长度为n的单链表链接在长度为m的单链表之后的操作，需要把长度为m的单链表遍历一遍，找到最后的一个结点，所以时间复杂度为O （m）。

5已知L是带头结点的单链表，结点p既不是第一个结点，也不是最后一个结点，删除p结点的直接后继结点的语句序列是A.p=p→nextB.p→next=pC.p→next=p→next→nextD.p=p→next→next正确答案是：【C】解析：选项A是删除了当前p结点；选项B是把p结点之后的所有结点都丢失了，同时在p结点本身形成了一个环；选项C正确；选项D是把p和p的后继结点都删除了。

6设双向循环链表中结点的结构为（prior，data，next），且不带表头结点。

2.1 线性表的类型定义1.线性表的定义是由n(n=0)个数据元素a1.

18
20 21
健康
一般健康
张立立
……..
790634
……..
男
…….
17
…….
神经衰弱
…….
3
• 注意：
（1）线性表中的所有数据元素的数据类型是一致的。（2）数据元素在线性表中的位置只取决于它的序号。（3）相邻数据元素之间存在着序偶关系。（4）结点间的逻辑关系是线性的。
4
3.抽象数据类型线性表的定义如下：
11
（2）插入运算在第i（1<=i<=n+1)个元素之前插入一个新的数据元素x。使长度为n的线性表变为长度为n+1的线性表：
（a1,a2,…,ai-1,ai,…,an）
（a1,a2,…,ai-1,x, ai,…,an）
12
•
插入算法的思想：
1. 将线性表中的第i个至第n个数据元素后移一个位置（共需移动n-i+1个数据元素),
1
2.线性表（a1,a2,a3, ……an）的特点：
在数据元素的非空有限集中，（1）存在唯一的一个被称为“第一个”的数据元素；（2）存在唯一的一个被称为“最后一个”的数据元素；（3）除第一个之外，集合中的每个数据元素均只有一个前驱；（4）除最后一个外，集合中的每个数据元素均只有一个后继。线性表中的数据元素类型多种多样，但同一线性表中的元素必定具有相同特性，在一些复杂的线性表中，每一个数据元素又可以由若干个数据项组成，在这种情况下，通常将数据元素称为记录（record）。
10
4.顺序表的几种基本运算
（1）初始化运算 Status InitList_Sq(Sqlist &L){ L.elem=(Elemtype *)malloc (LIST_INIT_SIZE*sizeof(Elemtype)); //分配内存单元 if (! L.elem) exit (OVERFLOW); //存储分配失败 L.Length=0; //空表长度为0 L.Listsize=LIST_INIT_SIZE; //初始存储容量 return OK; }//InitList_Sq

线性表

举例:
La=(34，89，765，12，90，-34，22) 数据元素类型为int。 Ls=(Hello,World, China, Welcome) 数据元素类型为 string。 Lb=(book1,book2,...,book100) 数据元素类型为下列所示的结构类型： struct bookinfo { int No; //图书编号 char *name; //图书名称 char *auther; //作者名称 ...; };
素的方法被称为随机存取法，使用这种存取方法的存储结构被
称为随机存储结构。
在C语言中，实现线性表的顺序存储结构的类型定义
typedef int ElemType; //定义顺序表中元素的类型 #define INITSIZE 100 //顺序表存储空间初始分配量 #define LISTINCREMENT 10 //线性表存储空间的分配增量 typedef struct { ElemType *data; int length; //存储空间的基地址 //线性表的当前长度
说明：
1. 某数据结构上的基本运算，不是它的全部运算，而是一些常用的基本的运算，而每一个基本运算在实现时也可能根据不同的存储结构派生出一系列相关的运算来，没有必要全部定义出它的运算集。掌握了某一数据结构上的基本运算后，其它的运算可以通过基本运算来实现，也可以直接去实现。 2. 在上面各操作中定义的线性表Ｌ仅仅是一个抽象在逻辑结构层次的线性表，尚未涉及到它的存储结构，因此每个操作在逻辑结构层次上尚不能用具体的某种程序语言写出具体的算法，而算法的实现只有在存储结构确立之后。
4. 求顺序表的长度 int getlen(sqlist L) { return (L.length); } 5. 判断顺序表是否为空 int listempty(sqlist L) { if (L.length==0) return 1; else return 0; }

线性表

2.1 线性表的类型定义
例3：下图为10个个学生的成绩表,它也是一个线性表,该线性表的数据元素类型为结构体类型。
2.1 线性表的类型定义
从以上例子可看出线性表的逻辑特征是：在非空的线性表中，有且仅有一个被称作 “第一个”的数据元素a1，它没有直接前趋，而仅有一个直接后继a2；有且仅有一个被称作“最后一个”的数据元素an，它没有直接后继，而仅有一个直接前趋 a n-1；其余的数据元素ai(2≦i≦n-1)都有且仅有一个直接前趋a i-1和一个直接后继a i+1。线性表是一种典型的线性结构。
2.2 线性表的顺序表示和实现
＃define MAXNUM 100 Elemtype List1[MAXNUM] ; /*定义线性表L1*/ int length1;
Elemtype List2[MAXNUM] ; /*定义线性表L1*/ int length2;
Elemtype List3[MAXNUM] ; /*定义线性表L1*/ int length3;
2.2 线性表的顺序表示和实现
而只需要将数组和表长封装在一个结构体中，然后定义三个结构体变量即可： struct L_list { Elemtype List[MAXNUM]; int length; }； struct L_list L1, L2, L3; /*定义三个线性表L1，L2，L3*/
2.1 线性表的类型定义
例1：26个英文字母组成的字母表（A，B，C、…、Z）例2：某公司2000年每月产值表(单位：万元) （400，420，500，…，600，650）是一个长度为12的线性表。

上述两例中的每一个数据元素都是不可分割的，在一些复杂的线性表中，每一个数据元素又可以由若干个数据项组成。

数据结构C语言版部分习题及答案[2]

第二章习题与解答一判断题1．线性表的逻辑顺序与存储顺序总是一致的。

2．顺序存储的线性表可以按序号随机存取。

3．顺序表的插入和删除操作不需要付出很大的时间代价，因为每次操作平均只有近一半的元素需要移动。

4．线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此是属于同一数据对象。

5．在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上并不一定紧邻。

6．在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。

7．线性表的链式存储结构优于顺序存储结构。

8．在线性表的顺序存储结构中，插入和删除时，移动元素的个数与该元素的位置有关。

9．线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。

10．在单链表中，要取得某个元素，只要知道该元素的指针即可，因此，单链表是随机存取的存储结构。

二单选题 (请从下列A，B，C，D选项中选择一项)1．线性表是( ) 。

(A) 一个有限序列，可以为空；(B) 一个有限序列，不能为空；(C) 一个无限序列，可以为空；(D) 一个无序序列，不能为空。

2．对顺序存储的线性表，设其长度为n，在任何位置上插入或删除操作都是等概率的。

插入一个元素时平均要移动表中的（）个元素。

(A) n/2 (B) n+1/2 (C) n -1/2 (D) n3．线性表采用链式存储时，其地址( ) 。

(A) 必须是连续的；(B) 部分地址必须是连续的；(C) 一定是不连续的；(D) 连续与否均可以。

4．用链表表示线性表的优点是（）。

(A)便于随机存取(B)花费的存储空间较顺序存储少(C)便于插入和删除(D)数据元素的物理顺序与逻辑顺序相同5．某链表中最常用的操作是在最后一个元素之后插入一个元素和删除最后一个元素，则采用( )存储方式最节省运算时间。

(A)单链表(B)双链表(C)单循环链表(D)带头结点的双循环链表6．循环链表的主要优点是( )。

(A)不在需要头指针了(B)已知某个结点的位置后，能够容易找到他的直接前趋(C)在进行插入、删除运算时，能更好的保证链表不断开(D)从表中的任意结点出发都能扫描到整个链表7．下面关于线性表的叙述错误的是( )。

数据结构(线性表)习题与答案

数据结构(线性表)习题与答案数据结构(线性表)习题与答案1. 线性表的定义线性表是一种常用的数据结构，它由一系列元素组成，并且每个元素具有前驱和后继关系。

线性表可以通过顺序存储或链式存储来实现。

2. 线性表的实现方式2.1 顺序存储顺序存储是利用数组来实现线性表的一种方式。

数组的每个元素可以存储一个数据项，通过下标可以快速访问和操作其中的元素。

2.2 链式存储链式存储是通过节点之间的指针关联来实现线性表的一种方式。

每个节点包含数据域和指针域，指针域指向下一个节点。

3. 线性表的基本操作3.1 初始化线性表初始化线性表需要给表头节点分配内存空间，并将头节点的指针域置为空。

3.2 插入元素在线性表的某个位置插入元素，需要先找到插入位置的前一个节点，然后将新节点插入到该位置。

调整节点之间的指针关联即可完成插入操作。

3.3 删除元素删除线性表中的某个元素，需要找到待删除元素的前一个节点，然后将该节点的指针指向待删除节点的下一个节点，释放待删除节点的内存空间即可。

3.4 查找元素查找线性表中某个元素的位置，可以从表头节点开始逐个比较节点的数据域，直到找到目标元素或者遍历结束。

4. 线性表的习题与答案4.1 习题1已知线性表L中的元素按非递减顺序排列，设计一个算法，将元素x插入到L中，保持L的有序性。

解答：1) 从表头节点开始，顺序遍历节点的数据域，找到第一个大于等于x的节点的前一个节点，记为p。

2) 创建新的节点node，将x赋值给node的数据域。

3) 将node的指针域指向p的下一个节点。

4) 将p的指针域指向node。

5) 插入完成。

4.2 习题2已知线性表L中的元素按递减顺序排列，设计一个算法，删除L中所有大于x的元素。

解答：1) 从表头节点开始，顺序遍历节点的数据域，找到第一个小于等于x的节点的前一个节点，记为p。

2) 将p的指针域指向p的下一个节点，删除p的后继节点。

3) 重复执行步骤2，直到遍历结束。

线性表

线性表的ADT定义为：
ADT List {
数据对象：D={ ai | ai∈ElemSet, i=1,2,…,n, n≥0}
数据关系：R={< ai-1, ai >| ai-1, ai ∈ElemSet,i=1,2,…,n} 基本操作： InitList( & L) //建立（初始化）线性表
DestroyList( &L ) //销毁线形表L
张三
李四王五赵六 ……..
男
女男男 …….
18
20 21 17 …….
端州
四会广州端州 …….
线性表的逻辑特征是：
①在非空的线性表，有且仅有一个开始元素a1，它没有直接前趋，而仅有一个直接后继a2 ②有且仅有一个终端元素an，它没有直接后继，而仅有一个直接前趋an-1； ③其余的内部元素ai(2<=i<=n-1)都有且仅有一个直接前趋 ai-1 和一个直接后继 ai+1。
算法2.1
例2. 巳知线性表LA和线性表LB中的数据元
素按值非递减有序排列，现要求将LA和LB归并为一个新的线性表LC，且LC中的元素仍按值非递减有序排列。如： LA={ 3，5，8，11 }， LB={2，6，8，9，11，15 ，20}，则结果 LC={2，3，5，6，8，8，9，11，11，15，20}
#define List_Increment 30 //追加分配长度
在顺序表存储结构中，很容易实现线性表的操作，
如：线性表的构造、第i个元素的访问、求表长等操作。
要访问某个元素也很方便，这是顺序存储的最大优
点——随机访问注意：在C语言中的数组下标从“0”开始，因此，若L 是Sqlist类型的顺序表，则表中第i个元素是L.data[i-1]。

线性表

void disp(sqlist L) //增加的测试函数，显示线性表中的元素 { int i; printf("线性表中的元素为："); for (i=0; i<L.length; i++) printf("%5d",L.data[i]); printf("\n"); } int locate(sqlist L,int e) //在L中查找值为e的元素，如果存在返回1，否则返回0 { int i; for (i=0; i<L.length; i++) if (L.data[i]==e) return 1; return 0; }
算法描述（P24算法2.4）
算法分析：
① 问题的规模：表的长度L-＞length（设值为n） ② 移动结点的次数由表长n和插入位置i决定算法的时间主要花费在for循环中的结点后移语句上，该语句的执行次数是n-i+1。当i=n+1：移动结点次数为0，即算法在最好时间复杂度是0(1)。当i=1：移动结点次数为n，即算法在最坏情况下时间复杂度是0(n)
③ 移动结点的平均次数为n/2 ，即在顺序表上进行插入运算，平均要移动一半结点。
结论：顺序表上做插入运算，平均要移动表中约一半的结点，平均时间复杂度也是O(n)。
顺序表完整操作举例1：
#include <stdio.h> #define MAXSIZE 100 typedef int elemtype; typedef struct /* 定义结点元素结构 */ { elemtype elem[MAXSIZE]; int len; }SEQLIST; void SQ_init(SEQLIST *L) { (*L).len=0; } int SQ_length( SEQLIST L ) { return L.len; } /* 顺序表初始化 */ /* 求顺序表的长度 */

第2章线性表

【例2】巳知有两个按元素值递增有序的顺序表La和 Lb，设计一个算法将表La和表Lb的全部元素归并为一个按元素值递增有序的顺序表Lc。

算法思路：用i扫描顺序表La，用j扫描顺序表Lb。当表La和表Lb都未扫描完时，比较两者的当前元素，将较小者插入表Lc的表尾，若两者的当前元素相等，则将这两个元素依次插入表Lc的表尾。最后，将尚为扫描完的顺序表的余下部分元素依次插入表Lc的表尾。算法如下： void MergeList_Sq(SqList La, SqList Lb, SqList &Lc)

表中ai-1领先于ai，称ai-1是ai的直接前驱，ai+1是 ai的直接后继。

线性表的抽象数据类型定义（参见教材）
返回本章目录
2.2 线性表的顺序存储结构

线性表的顺序存储是指在内存中用地址连续的一块存储空间依次存放线性表的数据元素，用这种存储形式存储的线性表称其为顺序表。假设每个数据元素占d个存储单元，且将ai的存储地址表示为 Loc(ai)，则有如下关系： Loc(ai)=Loc(a1)+(i-1)*d Loc(a1)是线性表的第一个数据元素a1的存储地址，通常称作线性表的基地址。

【例1】编写一算法，从顺序表中删除自第i个元素开始的k个元素。算法思路：为保持顺序表的逻辑特性，需将i+k ~ n位置的所有元素依次前移k个位置。算法如下：

int deleteK(Sqlist &sq,int i,int k)
{ if (i<1||k<1||i+k-1>sq.len) return 0; for (j=i+k-1;j<=sq.len-1;j++) sq.data[j-k]=sq.data[j]; sq.len-=k; return 1; }// deleteK

第02章线性表(I)

{ int i;
if(slt->size==MAXSIZE)
{printf("\n顺序表是满的!没法插入!");exit(1);}
if(position<0||position>slt->size)
{printf("\n指定的插入位置不存在!");exit(1);}
for(i=slt->size;i>position;i--) slt->a[i]=slt->a[i−1];
将有序顺序表L1分裂成两个线性表L2与L3，L2由表中所奇数组成，L3由所有偶数组成。
（3）void merge(sequence_lsit *l1,sequence_list *l2, sequence_list *l3)
将有序顺序表L1与L2合并成有序顺序表L3。
退出
2.3.1栈
2.3 栈
栈是一种特殊的线性表，对于这种线性表规定它
n 1 2
这表明，在一个长为n的顺序表中删除一个元素平均需要移动表中大约一半的元素。该算法的时间复杂度为O（n）。
退出
顺序表上的一些其它常见算法
（1）void verge(sequence_list l) 将顺序表L就地转置，即借助于O（1）的辅助空间
。（2）void sprit(sequence_lsit *l1,sequence_list *l2, sequence_list *l3) [略]
退出
要删除顺序表中的第i个结点，则需要称动（n-i-1 ）个元素，设删除表中第i个结点的概率为qi，且在表中每一个位置删除的概率相等，即：
q0=q1=…=qn-1=1/n
则在一个长度为n的顺序表中删除一个结点的平均移动次数为：

【数据结构】线性表顺序表详解和代码实例

【数据结构】线性表顺序表详解和代码实例线性表(List)是零个或者多个数据元素的有限序列.⾸先它是⼀个序列.⾥⾯的元素是有顺序的,如果有多个元素,除开头和结尾以外的元素都有⼀个前驱和⼀个后继.⽽开头元素只有后继,结尾元素只有前驱.其次线性表是有限的，也就是⾥⾯的元素个数是有限的。

1ADT 线性表（List）2Data3线性表的数据对象集合为{a1, a2, a3, ......, an},每个元素类型为DataType。

4Operation5InitList(L); //初始化线性表6 IsEmptyList(L); //判断线性表是否为空7 ClearList(L); //清空线性表8 GetElemList(L, i, *e); //获取第i个位置的数据9 SearchList(L, e); //查找与数据e相等的元素10 InsertNodeList(L, i, e);//在第i个位置插⼊元素11 DeleteNodeList(L, i, *e);//删除第i个位置的元素，e获取删除元素12 GetLengthList(L); //获取线性表的长度13endADT关于线性表的基本操作就上⾯⼏种，还有⼏个例如线性表的排序，合并，逆序等等操作。

为了⽂章篇幅，就下次再介绍了。

线性表的顺序存储结构，就是指⽤⼀段地址连续的存储单元⼀次存储线性表的数据元素。

学过⾼级语⾔的朋友，相信对数组这玩意⼉都不会陌⽣吧。

数组就是⼀种顺序存储结构。

链式存储结构就是可以⽤⼀组任意的内存单元存储线性表中的元素。

与顺序存储不同的是，这组内存单元可以是连续的，也可以是不连续的。

这就意味着，元素可以存储在内存的任意位置。

正因为如此，在链式结构中，每个元素不仅要存它的信息，还需要存储它后继元素的存储地址。

我们把存储元素信息的域称为数据域，⽽把存储后继元素地址的域称为指针域。

由这两部分共同组成的数据元素ai，则可以称之为节点(Node)。

数据结构导论第2章线性表

线性表(linear list) 第二章线性表
线性表是一种线性结构，线性结构的特点是数据元素之间是一种线性关系，数据元素“一个接一个的排列”。线性结构是n（n>=0）个结点的有穷序列。对于 n>0的线性结构表示成： (a1，a2，… ai-1，ai，ai+1，…an) a1称为起始结点 an称为终端结点起始结点，终端结点; 起始结点终端结点 ai-1 称为 ai 的直接前趋 i+1 称为 ai 的直接后继直接前趋，a 直接后继。直接前趋直接后继
4．查找（定位） locate(L,x)：．查找（定位）：
依次将顺序表L中的每个元素与给定的值x进行比较。若找到则返回其序号（下标+1），否则返回0。 int locate (sqlist L, datatype x) { int i; for ( i=0; i<st; i++) if (L.data[i]==x) return (i+1); return(0); }
void insert (sqlist *L, datatype x, int i ) { if (i<1 || i>L->last+1) error (“插入位置错误”); else if (L->last==maxsize) error (“溢出”); else { for (j=L->last-1; j>=i-1; j--) //往后移动元素 //往后移动元素 L->data[j+1]=L->data[j]; L->data[i-1]=x; //插入x L->last++; //修改表长 } }
常见的线性表的基本运算有以下几个：常见的线性表的基本运算有以下几个：

数据结构——线性表(选择题)

1.线性表是()。

简单，线性表的概念与性质，02702001 [单选题]A、一个有限序列，可以为空(正确答案)B、一个无限序列，不可以为空C、一个无限序列，可以为空D、一个无限序列，不可以为空2.在一个长度为n 的顺序表中删除第i 个元素(0<=i<=n)时，需向前挪移()个元素。

简单，线性表顺序存储实现，02702003 [单选题]A 、n-i(正确答案)B 、n-i+1C 、n-i-1D 、i3.线性表采用链式存储时，其地址()。

简单，线性表的链式存储原理，02702004 [单选题]A、必须是连续的B、一定是不连续的C、部份地址必须是连续的D、连续与否均可以(正确答案)4.从一个具有n 个结点的单链表中查找其值等于x 的结点时，在查找成功的情况下，需平均比较()个元素结点。

普通，链式存储的实现，02702005 [单选题]A 、n/2B 、nC 、(n+1)/2(正确答案)D 、(n-1)/25.在双向循环链表中p 所指的结点之后插入s 指针所指向的结点，其操作是()。

普通，循环链表实现，02702022 [单选题]A 、p->next=s; s->prior=p; p->next->prior=s; s->next=p->next;B 、s->prior=p; s->next=p->next; p->next=s; p->next->prior=s;C 、p->next=s; p->next->prior=s; s->prior=p; s->next=p->next;D 、s->prior=p; s->next=p->next; p->next->prior=s; p->next=s; (正确答案)6.设单链表中指针p 指向结点m，若要删除m 之后的结点(若存在)，则需修改指针的操作为()。

数据结构学习心得（二）-----线性表

数据结构学习⼼得（⼆）-----线性表线性表是由n个数据元素（结点）a1，a2,a3……an组成的有限序列。

线性表的数据元素ai所代表的具体含义随具体应⽤的不同⽽不同，在线性表的定义中，只不过是⼀个抽象的符号。

1.线性表的结点可以是单值元素（每个元素只有⼀个数据项）例如：26个英⽂字母表（A,B,C……Z）扑克的点数（2,3,4,5……J,Q,K）2.线性表中的结点可以是记录型元素，每个元素含有多个数据项，每个项称为结点的⼀个域，每个元素有⼀个可以唯⼀标识每个结点的数据项组，称为关键字。

例⼦：某校2001级同学的基本情况{（‘201112’，‘张三’，‘男’，‘1983/2/4’）,('201113','章华寺‘，’男‘1984/2/8)……}顺序线性表：数组表⽰粗出线性表的元素，顺序表还需要长度的属性，所以⽤结构类型来定义顺序表类型。

typedef struct sqlist{ElemType Elem_array[MAX_SIZE];int length;}Sqlist;链式线性表：为了正确表⽰节点间的逻辑关系，在存储每个结点值的同时，还必须存储指⽰其直接后继结点的地址（或位置），称为指针或链链表是通过每个节点的指针域将线性表的n个节点按其逻辑次序链接在⼀起的。

每⼀个结点只包含⼀个指针域的链表，称为单链表。

为操作⽅便，总是在链表的第⼀个节点之前附设⼀个头结点（头指针）head指向第⼀个结点。

头结点的数据域可以不存储任何信息（或链表长度等信息）。

结点的描述与实现typedef struct Lnode{ElemType data;struct Lnode *next;}LNode;结点的实现：结点是通过动态分配和释放来实现的，即需要时分配，不需要时释放。

实现时分别使⽤的c语⾔标准函数为：malloc(),realloc(),sizeof(),free();p=(LNode*)malloc(sizeof(LNode));函数malloc分配了⼀个类型为LNode的节点变量的空间，并将其⾸地址放⼊指针变量p中。

数据结构——线性表（顺序实现）

数据结构——线性表（顺序实现）好好学习基础知识，出⼈头地就靠它了，内外兼修。

（好吧，我现在内外都不⾏）写这篇⽂章的⽬的就是为了，巩固刚学完的线性表，个⼈能⼒有限，若有不当之处，望指出。

线性表好了，扯完了，说正事： 1、定义线性表是⼀种及其常⽤的并且最简单的⼀种数据结构。

简单来说，线性表就是集合⾥的元素的有限排列。

（在这⾥我把集合定义为具有相同属性的元素，会有些狭义）在线性表中数据元素之间的关系是⼀对⼀的关系，即除了第⼀个和最后⼀个数据元素之外，其它数据元素都是⾸尾相接的（注意，这句话只适⽤⼤部分线性表，⽽不是全部。

⽐如，循环链表逻辑层次上也是⼀种线性表（存储层次上属于链式存储），但是把最后⼀个数据元素的尾指针指向了⾸位结点）[] 怎么说呢，毕竟数据结构毕竟是逻辑结构，逻辑上符合线性结构的特征即可，存储结构能实现就⾏。

线性表的很重要！很重要！很重要！后⾯的栈，队列，串等都是基于线性表的基础上实现的，所以说⼀定要学好线性表 2、线性表的特点：对于任意的的⾮空线性表或者线性结构有： 1、存在唯⼀⼀个被称为 ”第⼀个“的元素 2、存在唯⼀⼀个被称为 ”最后⼀个“的元素 3、出第⼀个元素之外，每⼀个元素都存在⼀个后继 4、除最后⼀个元素之外，每⼀个元素都存在⼀个前驱 3、基本操作 1、Create（*L）创建空表 2、InitEmpty（*L）初始化 3、getLength（*L）获取长度 4、Insert（*L）插⼊元素 5、Remove（*L）移除元素 6、IsEmpty（*L）空表检测 7、IsFulled（*L）表满检测（顺序表常⽤，链式表基本不⽤） 8、Delete（*L）删除表 9、getElemt（*L）获取元素 10、Traverse（*L）遍历输出所有元素 11、Clear（*L）清除所有元素 4 、实现好了最⿇烦的事情开始了，数据结构在计算机上的的映射。

众所周知，线性表有两种实现⽅法，⼀种是顺序表，另⼀种是链式表，这两种结构实现最⼤的不同在于前者逻辑关系⽆需存储空间，⽽后者则需要⽤额外的空间（顺便记录⼀下，指针⼤⼩只由环境有关（严格意义上说和CPU的位数有关）本篇只实现顺序结构）。

第12章-线性表

第12章线性表数据结构: 是相互之间存在一种或多种特定关系的数据元素的集合。

在任何问题中, 数据元素都不是独立存在的, 而是在它们之间存在着某种关系, 这种数据元素相互之间的关系称为结构。

通常有4种结构:（1）集合：结构中的数据元素之间除了“同属于一个集合”的关系外, 别无其它的关系；一个大学同学之间的关系就是“集合”；（2）线性结构: 结构中的数据元素之间存在着一个对一个的关系；一个班级同学之间的学号有先后关系（一对一的关系）；（3）树形结构: 结构中的数据元素之间存在一个对多个的关系；一个班主任对该班上的学生之间的关系；（4）图状结构或网状结构: 结构中的数据元素之间存在多个对多个的关系；一个班上的同学之间的关系。

线性结构的特点是：在数据元素的非空有限集中, 存在着以下：（1）存在唯一的一个被称做“第一个”的数据元素（2）存在唯一的一个被称做“最后一个”的数据元素（3）除第一个之外, 集合中的每个数据元素均只有一个前驱（4）除最后一个之外, 集合中的每个数据元素均只有一个后继满足这种关系的数据集合就是“线性表”。

12.1 线性表的定义线性表（Linear List）是最常用且最简单的一种数据结构。

简言之, 一个线性表是n个数据元素的有限序列。

每个数据元素的具体含义可以不同。

在稍复杂的线性表中, 一个数据元素可以由若干个数据项组成（如一个结构体就是一个数据元素, 而结构中的每个成员就是一个数据项）。

在这种情况下, 常把数据元素称为记录, 含有大量记录的线性表又称为文件。

线性表可以有两种实现方式: 顺序方式、链式方式。

顺序方式实现的称为“顺序表”, 链式方式实现的称为“链表”。

12.2 线性表的顺序表示和实现一般表示顺序表的结构为:#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量typedef int ElemType; //使用typedef定义一种新类型ElemType, 此处它其实就是inttypedef struct{ElemType *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储空间（个）}SqList;需要实现的操作有:（1）初始化（2）销毁（3）清空（4）判空（5）求长度（6）获取第i个元素（7）对第i个元素设值（8）在第i个位置上插入一个元素（9）删除第i个元素（10）求某个元素的前驱（11）求某个元素的后继（12）查找某个指定值的元素的位置（13）遍历实现如下:1.初始化/*函数: 初始化一个线性表*/Status InitList_Sq(SqList &L){L.elem=(ElemType*)malloc(sizeof(SqList)*LIST_INIT_SIZE);if(L.elem==NULL) //申请空间失败, 程序直接退出exit(OVERFLOW);L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}其中exit(代码)是直接退出程序。