数据结构整理 —— 顺序表

线性表——顺序表

2.1 线性表的基本概念

2.1.1 线性表的基本定义

线性表是一个由N个相同元素组成的有序序列。
一般来说，线性表主要分为顺序表、单链表、循环单链表、双链表和循环双链表。
线性表主要可以解决一系列数据的线性存储，而它的存储方式又分为顺序储存和链式储存，以此可以实现数据的输入输出、插入、查找等操作。

2.1.2 线性表的基础操作

1. 初始化    ~~    InitList()
2. 销毁单链表    ~~    DestoryList()
3. 求线性表的长度    ~~    GetLength()
4. 求线性表中的第i个元素    ~~    GetElem()
5. 按值查找    ~~    Locate()
6. 插入元素    ~~    InsElem()
7. 删除元素    ~~    DelElem()
8. 输出元素    ~~    DisList()

现在，我们把这八种基本操作细分到不同的结构中进行讨论

2.2 顺序表

2.2.1 顺序表的定义

顺序表是线性表采用顺序储存结构在计算机内存中的储存方式，它由多个储存单元组成，每个储存单元存放一个元素，逻辑上相邻的元素在线性表中表示也是相邻的。所以顺序表又称为线性表的直接映射
我们假定线性表的数据元素的类型为ElemType（这样写主要是为了方便我们之后定义变量）

顺序表的存储是通过结构体来实现的：

#define MaxSize 100000
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];   //存放顺序表的元素
    int length  //顺序表的实际长度
}SqList;

我们在顺序表结构体中用一个数组data来存放顺序表的数据，存储方式和一般数组存储方式无异。MaxSize表示这个顺序表可以存放的最大数据量（注意：一般做题的时候MaxSize的值最好开大一点）length表示这个顺序表的实际长度（一般不等于MaxSize）。

2.2.2 利用顺序表实现线性表的基本运算

在之前的内容中已经指出，线性表的基本运算大概有8类，下面给出基于顺序表实现的线性表功能算法
1. 顺序表的基本算法
初始化顺序表的length为0，并且data数据清空

void InitList(SqList & L)
{
    L.length = 0;
    memset(data,0,sizeof(data));
}

本算法的时间复杂度为$O(1)$

2. 销毁顺序表算法
可以发现，顺序表变量L是一个自动变量，其内存空间是系统自己分配的，程序结束后系统会自动释放空间，所以销毁函数不含任何语句

void DesList(SqList L)
{

}

补充问题：复习一下内存空间的问题

给变量分配内存空间分为静态内存分配和动态内存分配。静态内存分配属于编译时给变量分配的空间，动态内存分配属于在程序运行时给变量分配的空间。静态分配属于栈分配(stack)，动态分配属于堆分配(heap)。

静态内存分配是在程序编译或者运行过程中，按事先规定的大小分配内存空间的分配方式，他的前提的必须事先知道所需内存空间的大小，它的内存分配在栈区和全局变量区。

动态内存分配是按输入信息的大小分配所需要的内存单元，他的特点是按需分配，内存分配在堆区。
int a[10] 属于静态分配
int a[n]; int *a; a = (int *)malloc(sizeof(a))属于动态分配
一般情况下我们使用malloc和free组合进行动态分配和释放空间。

栈存储：

堆存储

3. 求线性表的长度算法
其实就是返回顺序表的length

int GetLength(SqList L)
{
    return L.length;
}

本算法的时间复杂度为$O(1)$
4. 求线性表中的第i个元素算法
为了避免我们的逻辑序号i是一个无效值，我们在函数开头加一个判断语句（注意：很重要！不能忽略）

int GetElem(SqList L,int i,ElemType &e)
{
    if(i < 1 || i > L.length) return 0; //不能丢掉！
    else{
        e = L.data[i - 1];
        return 1;
    }
}

本算法的时间复杂度为$O(1)$
5. 按值查找算法
我们要求在顺序表中查找第一个值为x的函数，找到后返回其序号，否则返回0。

int Locate(SqList L,ElemType x)
{
    int i = 0;
    while(i < L.length && L.data[i] != x) i++;
    if(i >= L.length) return 0;
    else return (i + 1);   //这里注意我们的下标是0~n-1
}

本算法的时间复杂度$O(n)$
6. 插入元素算法
要求实现将新元素x插入到顺序表中编号为i的位置，如果i无效则返回0。

这个算法的操作分两种情况：

• 如果i有效：原数据中i - 1~n - 1的数据元素后移一位，length++
• 如果i无效：返回0。

int InsElem(SqList & L,ElemType x,int i)
{
    int j;
    if(i < 1 || i > L.length + 1) return 0;
    for(j = L.length;j < i;j--) //从length位置开始后移
        L.data[j] = L.data[j - 1];
    L.data[i - 1] = x;
    L.length++;
    return 1;
}

本算法的时间复杂度分析，我们考虑最坏的情况，当i = 0时，移动次数为n次，所以算法时间复杂度为$O(n)$
7. 删除元素算法
要求实现将序号为i的元素从顺序表中删除，从如果i无效则返回0。

这个算法的操作分两种情况：

• 如果i有效：原数据中i~n - 1的数据元素前移一位，length--
• 如果i无效：返回0。

int DelElem(SqList & L,int i)
{
    int j;
    if(i < 1 || i > L.length) return 0;
    for(j = i;j < L.length;j++) L.data[j - 1] = data[j];
    L.length--;
    return 1;
}

算法复杂度分析：
对于一般情况，删除位置为i的元素$a_i$，需要将$a_{i+1}$ ~ $a_i$的元素均向前移动一次，移动次数为$n-(i+1)+1=n-i$。假设$p_i$在是删除在第i个位置上的元素的概率(等概率下$p_i=\frac{1}{n}$)则在长度为n的线性表中删除元素的平均时间复杂度为：

${\sum }_1^n{p}_i(n-1)={\sum }_1^n\frac{1}{n}(n-i)=\frac{1}{n}\ast \frac{n(n-1)}{2}=\frac{(n-1)}{2}$

这里用到了一点期望的算法，得出算法时间复杂度为$O(n)$
8. 输出元素值算法
从头到尾扫描(或称遍历)顺序表L,输出各个元素值。

void DisList(SqList L)
{
    int i;
    for(i = 0;i < L.length;i++) printf("%d",L.data[i]);
    printf("\n");
}

算法时间复杂度$O(n)$

2.2.3 算法实现顺序表的整体创建

我们的基本思路是：用一个数组存储顺序表中的基本元素，然后调用函数将数据存入data中

void CreatList(SqList & L,ElemType a[],int n)
{
    int i,k = 0;
    for(i = 0;i < n;i++) {
        L.data[k] = a[i];
        k ++;
    }
    L.length = k;
}

算法的时间复杂度为$O(n)$

现在，我们已经完成了对顺序表的一些基本操作，现在给出一些实例：

2.2.4 基于顺序表的基本操作的算法设计

这一类的算法设计中包括顺序表元素的查找、插入、删除等操作。

例题1：
设计一个顺序表L，删除从第i个元素开始的连续的k个元素。
题解：
我们可以这样想，删除k个元素相当于第i + k ~ length个元素向前移动k个位置，那也就是说我们只需要做一次移动操作即可，而不需要进行k次删除。
代码

int Deletk(SqList & L,int i,int k)
{
    int j;
    if(i < 1 || k < 1 || i + k - 1 > L.length) return 0;
    for(j = i + k - 1;j < L.length;j++) L.data[j - k] = L.data[j];
    L.length -= k;
    return 1;
}

例题2：
假设有一个顺序表L，其中元素为整数且所有元素值均不相同。设计一个尽可能高效的算法将所有奇数移到所有偶数的前面。
题解：
我们按照前后元素交换的思路，在顺序表的头和尾设置两个哨兵。在顺序表中从后往前找奇数，从前往后找偶数，找到后进行交换，如果两个哨兵相遇则停止查找，这样就可以实现L的前面都是奇数，而后面全是偶数。(注意：这一思想在后面的快速排序中也会有所应用)
代码：

void swap(ElemType & x,ElemType & y)
{
    ElemType temp = x;
    x = y;
    y = temp;
}

void Move(SqList &L)
{
    int i = 0,j = L.length; //哨兵
    while(i < j){
        while(L.data[i] % 2 == 1) i ++;
        while(L.data[j] % 2 == 0) j --;
        if(i < j) swap(L.data[i],L.data[j]);
    }
}

2.2.5 基于整体建表的算法设计

这一类算法中需要根据条件产生新的结果顺序表。
例题3：
已知一个顺序表L，现在要求设计一个算法删除其中所有值为x的元素（假设L中的值为x的元素有多个）。
题解：
不断删除更新L显然是很不方便的，如果我们对这个顺序表每删除一个元素我们都采用移动的方式更新L，那么这个算法的时间复杂度会达到$O(n^2)$，这个显然不是一个最优化的解法。我们也可以这样操作：遍历L，对于每一个不为x的元素我们都把他放进另一个新的顺序表L中，这样可以实现$O(n)$的时间复杂度，但是空间复杂度却提升到了$O(n)$。显然这并不是一种最理想的方案。
基于前面的思考，我们考虑这样一种情况：对于这个顺序表中的元素，不为x的元素个数一定小于等于L中总元素的个数，所以我们只需要在这个L中操作就可以，而不需要在新建一个L。
代码：

void Deletex(SqList & L,ElemType x)
{
    int i,k = 0;
    for(i = 0;i < L.length;i++){
        if(L.data[i] != x){
            L.data[k] = L.data[i];
            k ++;
        }
    }
    L.length = k;
}

2.2.6 有序顺序表的二路归并算法

这里我们针对有序顺序表来讨论。
例题4：
有两个元素递增有序的顺序表A和B，设计一个算法将顺序表A和B的全部元素归并到一个按元素值递增有序的顺序表C中。
题解：
我们分别扫描A和B的元素，每一次都比较当前两个元素的大小，我们总是将比较小的哪一个放入C中，最后我们把未扫描完的元素再放入C中，最后得到的就是一个元素值递增有序的顺序表。这一思路就是我们归并排序实现的基础。
上图：

代码：

void Merge(SqList A,SqList B,SqList & C)
{
    int i = 0,j = 0,k = 0;
    while(i < A.length && j < B.length){
        if(A.data[i] < B.data[j]){
            C.data[k] = A.data[i];
            i ++;
            k ++;
        }
        else{
            C.data[k] = B.data[j];
            k ++;
            j ++;
        }
    }
    while(i < A.length){
        C.data[k] = A.data[i];
        i ++;
        k ++;
    }
    while(j < B.length){
        C.data[k] = B.data[j];
        j ++;
        k ++;
    }
}

本算法的时间复杂度为$O(n+m)$
下面给出这个问题的一个变型问题：

例题5：
给出两个有序表A和B，分别含有n个m个元素（我们规定最大的元素不超过32767），假设这n + m个元素互不相同。设计一个算法找出这m + n个数中第k小的元素。

题解：
我们还是采取二路归并的思路，我们先扫描A和B，如果两个顺序表都没有扫完，那就不断去比较A的元素和B的元素的值，每比较依次k--，如果k = 0则证明找到了这个第k小的值，否则我们知道，一定有一个顺序表没有扫描完，那么我们就去找A.data[i + k - 1]和B.data[j + k - 1]。
代码：

void Merge(SqList A,SqList B,ElemType & e)
{
    int i = 0,j = 0;
    if(k < 1 || k > A.length + B.length) return 0; //k的值非法
    while(i < A.length && j < B.length) {
        k --; //每次比较减一
        if(A.data[i] < B.data[j]){
            if(k == 0){
                e = A.data[i];
                return 1;
            }
            i ++;
        }
        else{
            if(k == 0){
                e = B.data[j];
                return 1;                
            }
            j ++;
        }
    }
    if(i < A.length) e = A.data[i + k - 1]; //二路归并之后A非空
    else if(j < B.length) e = B.data[j + k - 1]; //B非空
    return 1;
}