数据结构（C语言版）---线性表顺序存储表示

1、顺序表：线性表的顺序存储，用一组地址连续的存储单元存储线性表中的数据元素。

1） 特点：随机访问，即通过首地址和元素序号可在时间O(1)内找到指定元素。

                 表中元素的逻辑顺序与其物理顺序相同，线性表中元素的位序是从1开始的。

2）存储位置的关系：假设线性表的每个元素占用l个存储单元

      LOC(ai+1)=LOC(ai)+l、LOC(ai)=LOC(a1)+(i-1)*l，其中LOC(a1)为线性表的起始位置或基地址。

2、顺序表的空间分配方式：

1）静态分配：

#define MaxSize 50

typedef struct {
    int data[MaxSize];
    int length;
}Sqlist;

2）动态分配：

#define InitSize 100//表长度的初始定义
typedef struct {
    int *data;//指示动态分配数组的指针
    int maxsize, length;//数组的最大容量和当前个数
}SeqList;

3、插入操作：假设线性表中有n个元素，将元素e插入到顺序表L中第i个位置。

bool ListInsert(Sqlist &L, int i, int e)
{
    if (i<1 || i>L.length + 1)
    {
        return false;
    }
    if (L.length >= MaxSize)
    {
        return false;
    }
    for (int j = L.length;j>=i;j--)
    {
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = e;
    L.length++;
    return true;
}

最好情况：在表尾插入数据，元素后移语句将不执行，时间复杂度为O(1)。

最坏情况：在表头插入数据，元素后移语句将执行n次，时间复杂度为O(n)。

平均情况：元素平均移动次数为n/2，平均时间复杂度为O(n)。

4、删除操作：假设线性表中有n个元素，删除顺序表L中第i个位置的元素，并用e返回其值。

bool ListDelete(Sqlist &L, int i, int &e)
{
    if (i < 1 || i >= L.length)
    {
        return false;
    }
    e = L.data[i - 1];
    for (int j = i; j < L.length; j++)
    {
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    return true;
}
 

最好情况：删除表尾数据，元素移动语句将不执行，时间复杂度为O(1)。

最坏情况：删除表头数据，需移动除第一个元素外的所有元素，时间复杂度为O(n)。

平均情况：元素平均移动次数为(n-1)/2，平均时间复杂度为O(n)。

5、按值查找（顺序查找）：假设线性表中有n个元素，在顺序表L中查找第一个元素值等于e的元素，并返回位序。

int LocateElem(Sqlist L, int e)
{
    int i;
    for (i = 0; i < L.length; i++)
    {
        if (L.data[i] == e)
        {
            return i + 1;
        }
    }
    return 0;
}

最好情况：查找的元素在表头，仅比较一次，时间复杂度为O(1)。

最坏情况：查找的元素在表尾，需比较n次，时间复杂度为O(n)。

平均情况：元素平均移动次数为(n+1)/2，平均时间复杂度为O(n)。

6、逆置顺序表L
void Reverse(Sqlist &L)
{
    int temp;
    for (int i = 0; i < L.length / 2; i++)
    {
        temp = L.data[i];
        L.data[i] = L.data[L.length - i - 1];
        L.data[L.length - i - 1] = temp;
    }
}
7、将线性表（a1,a2,...,am,b1,b2,...,bn)换成（b1,b2,...,bn,a1,a2,...,am)
void reverse(int A[], int left, int right, int arraysize)
{
    if (left >= right || right >= arraysize)
    {
        return;
    }
    int mid = (left + right) / 2;
    for (int i = 0; i <= mid - left; i++)
    {
        int temp = A[left + i];
        A[left + i] = A[right - i];
        A[right - i] = temp;
    }
}
void exchange(int A[], int m, int n, int arraysize)
{
    reverse(A, 0, m + n - 1, arraysize);
    reverse(A, 0, n - 1, arraysize);
    reverse(A, n, m + n - 1, arraysize);
}
8、删除线性表中所有值为x的数据元素，两种方法
void delx1(Sqlist &L, int x)
{
    int k = 0;
    for (int i = 0; i < L.length; i++)
    {
        if (L.data[i] != x)
        {
            L.data[k] = L.data[i];
            k++;
        }
    }
    L.length = k;
}
void delx2(Sqlist &L, int x)
{
    int k = 0, i = 0;
    while (i<L.length)
    {
        if (L.data[i] == x)
        {
            k++;
        }
        else
        {
            L.data[i - k] = L.data[i];
        }
        i++;
    }
    L.length = L.length - k;
}
9、删除顺序表L中最小值元素结点，并通过引用型参数e返回其值
bool DelMin(Sqlist &L, int &e)
{
    if (L.length == 0)
    {
        return false;
    }
    e = L.data[0];
    int pos = 0;
    for (int i = 1; i < L.length; i++)
    {
        if (L.data[i] < e)
        {
            e = L.data[i];
            pos = i;
        }
    }
    L.data[pos] = L.data[L.length - 1];
    L.length--;
    return true;
}
10、删除顺序表L中值在s和t中的元素
bool delst(Sqlist &L,int s, int t)
{
    int i, k = 0;
    if (L.length == 0 || s >= t)
    {
        return false;
    }
    for (i = 0; i < L.length; i++)
    {
        if (L.data[i] >= s && L.data[i] <= t)
        {
            k++;
        }
        else
        {
            L.data[i - k] = L.data[i];
        }
    }
    L.length -= k;
    return true;
}
11、在有序的顺序表L中删除s和t之间的所有元素
bool delst2(Sqlist &L, int s, int t)
{
    int i, j;
    if (s >= t || L.length == 0)
    {
        return false;
    }
    for (i = 0; i < L.length&&L.data[i] < s; i++);//值大于s的第一个元素
    if (i >= L.length)
    {
        return false;
    }
    for (j = i; j < L.length&&L.data[j] <= t; j++);//值大于t的第一个元素
    for (; j < L.length; i++, j++)
    {
        L.data[i] = L.data[j];
    }
    L.length = i;
    return true;
}
12、在有序顺序表L中删除值相同的元素
bool delsame(Sqlist &L)
{
    if(L.length == 0)
    {
        return false;
    }
    int i, j;
    for (i = 0, j = 1; j < L.length; j++)
    {
        if (L.data[i] != L.data[j])
        {
            L.data[++i] = L.data[j];
        }
    }
    L.length = i + 1;
    return true;
}
13、将有序表A和B合并为新的有序表C
bool Merge(Sqlist A, Sqlist B, Sqlist &C)
{
    if (A.length + B.length > MaxSize)
    {
        return false;
    }
    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++];
        }
        else
        {
            C.data[k++] = B.data[j++];
        }
    }
    while (i < A.length)
    {
        C.data[k++] = A.data[i++];
    }
    while (j<B.length)
    {
        C.data[k++] = B.data[j++];
    }
    C.length = k;
    return true;
}