顺序表笔记

线性表

线性表的定义

线性表简称表，是零个或多个元素的有穷序列，通常可以表示成 a0，a1，…，an-1（n ≥ 1）。
表项或结点：线性表中的元素ai（可包含多个数据项）。
索引（下标）：i 称为表目 ai 的“索引”或“下标”。
表的长度：线性表中所含元素的个数n。
空表：长度为零的线性表（n = 0 ）。
表头：线性表中的第一个元素。
表尾：线性表中的最后一个元素。

线性结构

线性结构可以定义为二元组B=(K,R) , 其中K = {a0, a1,…, an-1},R= {前驱/后继关系}
有一个唯一的开始结点，它没有前驱，有一个唯一的直接后继。
一个唯一的终止结点，它有一个唯一的直接前驱，而没有后继。
其它的结点皆称为内部结点，每一个内部结点都有且仅有一个唯一的直接有前驱，也有一个唯一的直接后继，如：<ai, ai+1>，ai是ai+1的前驱，ai+1是ai的后继。
前驱/后继关系r，具有 反对称性 和 传递性

线性结构的特点

1. 均匀性：虽然不同线性表的数据元素可以是各种各样的，但对于同一线性表的各数据元素必定具有相同的数据类型和长度

2. 有序性：各数据元素在线性表中都有自己的位置，且数据元素之间的相对位置是线性的

Notes:

线性表是一种逻辑结构，表示元素之间一对一的相邻关系，顺序表和链表是存储结构。

线性表的顺序存储——顺序表

顺序表的特点

它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻

顺序表的特点是逻辑上相邻的元素在物理位置上也相邻

顺序表的存储结构

假设线性表L存储的起始位置是LOC(A),sizeof(ElemType)是每个数据元素所占用存储空间的大小，L对应的顺序存储如图

线性表是一种随机存取的顺序存储结构，通常用数组表示

顺序存储类型描述为

#define MaxSize 255
typedef struct{
    ElemType data[MaxSize];
    int length;
}SeqList;

动态分配的数组可以描述为

#define MaxSize 255
typedef struct{
    ElemType * data;
    int length;

}SeqList;

顺序表上存储操作实现

InitList(SeqList & L):初始化表，构造一个空的线性表

bool InitList(SeqList& L) {
    L.data = new ElemType[MaxSize];
    if (L.data == NULL) {
        return false;
    }
    int length;
    cin >> length;
    L.length = length;
    L.data[0] = 0;
    for (int i = 1; i <= L.length; i++)
    {
        L.data[i] = 0;
    }
    return true;
}

Length(SeqList & L):求表长

int Length(SeqList& L) {
    return L.length;
}

LocateElem(SeqList& L, ElemType e):按值查找操作。在表中查找具有指定给定关键字值的元素

int LocateElem(SeqList& L, ElemType e) {
    int i = 1;
    for (; i <= L.length; i++)
    {
        if (L.data[i] == e)
        {
            return i;
        }
    }
    return -1;
}

GetElem(SeqList& L, int i):按位查找操作。获取表中第i个元素的值

int GetElem(SeqList& L, int i)
{
    if (i > L.length || i <= 0)
    {
        cout << "i 不合法" << endl;
        return -1;
    }

    return L.data[i];
    
}

ListInsert(SeqList& L, int i, ElemType e):插入操作。在表中第i个位置上插入指定的元素e。

bool ListInsert(SeqList& L, int i, ElemType e)
{
    if (i <= 0 || i > L.length)
    {
        cout << "i的值不合法" << endl;
        return false;
    }

    if (L.length >= MaxSize)
    {
        cout << "L.length已经达到MaxSize" << endl;
        return false;
    }
    /*L.length++;
    for (int  j = L.length ; j >= i; j--)
    {
        L.data[j] = L.data[j-1];
    }
    L.data[i-1] = e;
    */
  
    for (int j = L.length; j >= i; j--)
    {
        L.data[j+1] = L.data[j];
    }
    L.data[i] = e;
    L.length++;
    return true;
}

ListDelete(SeqList &L,int i,ElemType &e) 删除顺序表L中第i(1 ≤ i ≤ L.length)个位置的元素,用元素e返回。

bool ListDelete(SeqList& L, int i, ElemType &e) {
    if (i <= 0 || i > L.length){
        cout << "i的值不合法" << endl;
        return false;
    }
    e = L.data[i];

    for (int j = i; j < L.length; j++)
    {
        L.data[j] = L.data[j + 1];
    }
    L.length--;
    return true;
}

最后给出所有代码

#include <iostream>

#define MaxSize 65535
typedef int ElemType;

using namespace std;


typedef struct {
    ElemType *data;
    int length;
}SeqList;

bool InitList(SeqList& L);
int Length(SeqList& L);
int LocateElem(SeqList& L, ElemType e);
int GetElem(SeqList& L, int i);
bool ListInsert(SeqList& L, int i, ElemType e);
bool ListDelete(SeqList& L, int i, ElemType &e);
void PrintList(SeqList& L);

int main()
{
    SeqList ListTest;
    InitList(ListTest);

    for (int i = 1; i <= ListTest.length; i++)
    {
        ListTest.data[i] = i * i;

    }
    for (int i = 1; i <= ListTest.length; i++)
    {
        cout << ListTest.data[i] << " ";
    }
    ListInsert(ListTest, 3, 234);
    cout << endl;
    for (int i = 1; i <= ListTest.length; i++)
    {
        cout << ListTest.data[i] << " ";
    }
    cout << endl;
    cout << "121在第" << LocateElem(ListTest, 121) <<"个"<< endl;
    cout << endl;
    cout << "第6个元素是" << GetElem(ListTest, 6) << endl;
    int data;
    ListDelete(ListTest, 4, data);
    cout << "被删除的元素是："<< data << endl;
    PrintList(ListTest);

}

bool InitList(SeqList& L) {
    L.data = new ElemType[MaxSize];
    if (L.data == NULL) {
        return false;
    }
    
    int length;
    cin >> length;

    L.length = length;


    L.data[0] = 0;

    for (int i = 1; i <= L.length; i++)
    {
        L.data[i] = 0;
    }

    return true;
}
int Length(SeqList& L) {
    return L.length;
}

int LocateElem(SeqList& L, ElemType e) {
    int i = 1;
    for (; i <= L.length; i++)
    {
        if (L.data[i] == e)
        {
            return i;
        }
    }
    return -1;
}

int GetElem(SeqList& L, int i)
{
    if (i > L.length || i <= 0)
    {
        cout << "i 不合法" << endl;
        return -1;
    }

    return L.data[i];
    
}
bool ListInsert(SeqList& L, int i, ElemType e)
{
    if (i <= 0 || i > L.length)
    {
        cout << "i的值不合法" << endl;
        return false;
    }

    if (L.length >= MaxSize)
    {
        cout << "L.length已经达到MaxSize" << endl;
        return false;
    }
    /*L.length++;
    for (int  j = L.length ; j >= i; j--)
    {
        L.data[j] = L.data[j-1];
    }
    L.data[i-1] = e;
    */
  
     for (int j = L.length; j >= i; j--)
    {
        L.data[j+1] = L.data[j];
    }
    L.data[i] = e;
    L.length++;
    return true;
}
 
bool ListDelete(SeqList& L, int i, ElemType &e) {
    if (i <= 0 || i > L.length){
        cout << "i的值不合法" << endl;
        return false;
    }
    e = L.data[i];

    for (int j = i; j < L.length; j++)
    {
        L.data[j] = L.data[j + 1];
    }
    L.length--;
    return true;
}
void PrintList(SeqList& L) {
    int i = 1;
    for (; i < L.length; i++)
    {
        cout << L.data[i] << " ";
    }
    cout << L.data[L.length] << endl;
}