数据结构【顺序表】

目录

1、线性表定义
2、线性表基本操作
3、线性表的顺序存储及运算—顺序表
4、顺序表的实现（C语言）

1、线性表定义

线性表是一种线性结构。线性结构的特点是数据元素之间是一种线性关系，数据元素“一个接一个的排列”。在一个线性表中数据元素的类型是相同的，或者说线性表是由同一类型的数据元素构成的线性结构。在实际问题中线性表的例子是很多的，如学生情况信息表是一个线性表：表中数据元素的类型为学生类型; 一个字符串也是一个线性表：表中数据元素的类型为字符型，等等。
综上所述，线性表定义如下：线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，通常记为：(a1，a2，… ai-1，ai，ai+1，…an)
其中n为表长， n＝0 时称为空表。表中相邻元素之间存在着顺序关系。

• 存在唯一的被称为 第一个的 数据元素
• 存在唯一的一个被称为 最后一个的 数据元素
• 除第一个之外，集合中的每一个数据元素均只有一个前驱
• 除最后一个之外，集合中的每个数据元素均只有一个后继

2、线性表基本操作

数据结构的运算是定义在逻辑结构层次上的，而运算的具体实现是建立在存储结构上的，因此下面定义的线性表的基本运算作为逻辑结构的一部分，每一个操作的具体实现只有在确定了线性表的存储结构之后才能完成。

线性表上的基本操作有：

⑴ 线性表初始化：Init_List(L)
初始条件：表L不存在操作结果：构造一个空的线性表

⑵ 求线性表的长度：Length_List(L)
初始条件：表L存在
操作结果：返回线性表中的所含元素的个数

⑶ 取表元：Get_List(L,i)
初始条件：表L存在且1<=i<=Length_List(L)
操作结果：返回线性表L中的第ｉ个元素的值或地址

⑷ 按值查找：Locate_List(L,x)，ｘ是给定的一个数据元素。
初始条件：线性表L存在
操作结果：在表L中查找值为ｘ的数据元素，其结果返回在L中首次出现的值为ｘ的那个元素的序号或地址，称为查找成功; 否则，在L中未找到值为ｘ的数据元素，返回一特殊值表示查找失败。

⑸ 插入操作：Insert_List(L,i,x)
初始条件：线性表L存在，插入位置正确(1<=i<=n+1,ｎ为插入前的表长)。
操作结果：在线性表L的第i 个位置上插入一个值为x 的新元素，这样使原序号为i , i+1, ... , n 的数据元素的序号变为i+1,i+2, ... , n+1，插入后表长=原表长+1。

⑹ 删除操作：Delete_List(L,i)
初始条件：线性表L存在，1<=i<=n。
操作结果：在线性表L中删除序号为i的数据元素，删除后使序号为i+1, i+2,..., n的元素变为序号为i, i+1,...,n-1，新表长＝原表长－１。

需要说明的是：
1.某数据结构上的基本运算，不是它的全部运算，而是一些常用的基本的运算，而每一个基本运算在实现时也可能根据不同的存储结构派生出一系列相关的运算来。比如线性表的查找在链式存储结构中还会有按序号查找; 再如插入运算，也可能是将新元素ｘ插入到适当位置上等等，不可能也没有必要全部定义出它的运算集，读者掌握了某一数据结构上的基本运算后，其它的运算可以通过基本运算来实现，也可以直接去实现。
2.在上面各操作中定义的线性表Ｌ仅仅是一个抽象在逻辑结构层次的线性表，尚未涉及到它的存储结构，因此每个操作在逻辑结构层次上尚不能用具体的某种程序语言写出具体的算法，而算法的实现只有在存储结构确立之后。

3、线性表的顺序存储及运算—顺序表

线性表的顺序存储是指在内存中用地址连续的一块存储空间顺序存放线性表的各元素，用这种存储形式存储的线性表称其为顺序表。因为内存中的地址空间是线性的，因此，用物理上的相邻实现数据元素之间的逻辑相邻关系是既简单，又自然的。如图2.1 所示。
设a１的存储地址为Loc(a１)，每个数据元素占d个存储地址，则第i个数据元素的地址为：

Loc(ai)=Loc(a１)+(i-1)*d 1<=i<=n

这就是说只要知道顺序表首地址和每个数据元素所占地址单元的个数就可求出第i个数据元素的地址来，这也是顺序表具有按数据元素的序号随机存取的特点。

在程序设计语言中，一维数组在内存中占用的存储空间就是一组连续的存储区域，因此，用一维数组来表示顺序表的数据存储区域是再合适不过的。考虑到线性表的运算有插入、删除等运算，即表长是可变的，因此，数组的容量需设计的足够大，设用：data[MAXSIZE]来表示，其中MAXSIZE是一个根据实际问题定义的足够大的整数，线性表中的数据从data[0] 开始依次顺序存放，但当前线性表中的实际元素个数可能未达到MAXSIZE多个，因此需用一个变量last 记录当前线性表中最后一个元素在数组中的位置，即last 起一个指针的作用，始终指向线性表中最后一个元素，因此，表空时last=-1。这种存储思想的具体描述可以是多样的。如可以是：

datatype data[MAXSIZE];
int last;

这样表示的顺序表如图2.1 所示。表长为last+1，数据元素分别存放在data[0]到data[last]中。这样使用简单方便，但有时不便管理。

总结:

顺序表的特征是，在内存中占用连续的存储单元，可以简单的理解为顺序表就是数组的扩展。

只是根据需要，在实际应用中动态分配顺序表占用的内存单元。

而数组是在编译的时候，预分配了指定大小的内存单元，因此如下代码段会在编译的时候报错。

int len = 10;
char arr[len];

但是顺序表又会有数据全部的特点：可以根据下标直接访问、不方便插入和删除元素（因为需要移动后续的元素）。

 4、顺序表的实现（C语言）

定义结构

typedef int SeqType; //存储单元类型

typedef struct{
SeqType *elem; //存储空间基地址
int length; //当前长度
int listsize; //当前分配的存储容量（以sizeof(ElemType)为单位）
} SqList;

//结构体内，有三个元素：存储空间基地址，类似于数组首地址；当前长度，记录顺序表中有效存储单元个数；当前分配的存储容量，顺序表中，最多容纳的存储单元个数。当顺序表中所有存储单元已经被使用，在下次插入元素之前，需要新增存储单元。这点是数组所不具有的特性。

*注：定义一个存储单元类型SeqType是为了使顺序表适和更多数据类型，使用的时候修改SeqType类型即可。

创建顺序表

/**
 * 创建顺序表
 */
SqList createList_sq() {
    //SqList list;
    //return list;

    SqList* list = (SqList*)malloc(sizeof(SqList));
    return *list;
}

//这里提供两种创建顺序表的代码，一种是由系统分配list占用的内存，一种是自己动态分配的内存，需要在程序运行之前手动释放占用的内存空间。

初始化顺序表

/**
 * 初始化顺序表
 * 返回1 表示初始化成功
 * 返回0 表示初始化失败
 */
int initList_sq(SqList &L) { //只有在C++中才会有引用的存在
    L.elem = (SeqType *) malloc(sizeof(SeqType) * LIST_INIT_SIZE);
    if (!L.elem)
        return 0; //内存分配失败，存储空间不够
    L.length = 0; //表示顺序表为空
    L.listsize = LIST_INIT_SIZE; //表示顺序表里，最大存储单元个数
    return 1;
}

//分配顺序表的存储单元，初始化顺序表属性的值。

插入元素

/**
 * 插入顺序表
 * 下标是负数就插入到结尾
 */
int insertList_sq(SqList &L, int index, SeqType val) {
    if (index > L.length) { //存储的下表超出顺序表实际的长度
        printf("插入的下标超出顺序表的实际长度");
        return 0;
    }
    if (index < 0) //下标是负数，插入到结尾
        index = L.length;
    if (L.length == L.listsize) { //顺序表的存储单元已经存满
        printf("顺序表的存储单元已满，继续分配新的存储单元。");
        SeqType* newBase = (SeqType*) realloc(L.elem,
                (L.listsize + LISTINCREMENT) * sizeof(SeqType)); //继续分配存储单元
        if (!newBase) {
            printf("分配内存单元失败");
            return 0;
        }
        L.elem = newBase;
        L.listsize += LISTINCREMENT;
    }
    //寻找合适的插入位置，index后面的元素向后移动
    for (int i = L.length; i > index; i--) {
        L.elem[i] = L.elem[i - 1]; //向后移动
    }
    L.elem[index] = val; //插入元素
    L.length++;
    return 1;
}

//将元素插入到指定的位置。插入之前，需要先判断顺序表中是否已经存满，再根据需要新增存储单元，最后插入元素。

删除元素

/**
 * 删除指定的元素
 * 返回0 找不到指定的元素，删除失败。
 * 返回1 找到待删除的元素，删除成功。
 */
int removeList_sq(SqList &L, SeqType val) {
    int index = -1; //记录匹配到的下标
    for (int i = 0; i < L.length; i++) {
        if (L.elem[i] == val) {
            //找到匹配的val，结束循环
            index = i;
            break;
        }
    }
    if (index < 0)
        return 0;
    for (; index < L.length - 1; index++) {
        L.elem[index] = L.elem[index + 1];
    }
    L.length--;
    return 1;
}

//删除指定元素，需要先找到下标。依次移动下标后面的结点，修改length值。

/**
 * 根据下标删除是指定的结点，并返回元素的值
 * 返回0 下标超出顺序表长度，删除失败。
 * 返回1 下标正确，删除元素，并且将已删除元素值转给elem
 */
int removeList_sq(SqList &L, int index, SeqType &elem) {
    if (index >= L.length) //下标超出顺序表的长度
        return 0;
    index = index < 0 ? L.length : index; //下标负数表示删除最后一个节点
    elem = L.elem[index];
    for (int i = index; i < L.length - 1; i++) {
        L.elem[i] = L.elem[i + 1];
    }
    L.length--;
    return 1;
}

//先取到指定下标的元素，赋值给elem，然后依次移动下标后面的结点。最后修改length值。

销毁顺序表

/**
 * 销毁顺序表
 */
void destoryList_sq(SqList &L) {
    free(L.elem); //释放存储空间
    L.length = 0;
    L.listsize = 0;
//  free(&L);
}

//重点释放顺序表的存储单元。如果顺序表自身的内存也是动态分配的，需要手动释放。

头文件定义

/*
 * sqlist.h
 * 线性表的顺序存储
 */

#ifndef SQLIST_H_
#define SQLIST_H_

#define LIST_INIT_SIZE 50
#define LISTINCREMENT 10

typedef int SeqType; //存储单元类型

typedef struct{
    SeqType *elem; //存储空间基地址
    int length; //当前长度
    int listsize; //当前分配的存储容量（以sizeof(ElemType)为单位）
} SqList;

/**
 * 创建顺序表
 */
SqList createList_sq();

/**
 * 初始化顺序表
 */
int initList_sq(SqList &);

/**
 * 插入顺序表
 */
int insertList_sq(SqList &,int index,SeqType);

/**
 * 插入顺序表（结尾的位置）
 */
int insertList_sq(SqList &,SeqType);

/**
 * 在顺序表中移除指定位置元素，下标从0开始
 */
int removeList_sq(SqList &,int,SeqType &);

/**
 * 在顺序表中删除指定元素
 */
int removeList_sq(SqList &,SeqType);
/**
 * 销毁顺序表
 */
void destoryList_sq(SqList &);

#endif /* SQLIST_H_ */