[数据结构笔记]顺序表

最新推荐文章于 2024-04-27 18:58:47 发布

OliverNeko

最新推荐文章于 2024-04-27 18:58:47 发布

阅读量263

点赞数

分类专栏：数据结构

本文链接：https://blog.youkuaiyun.com/zzl2275/article/details/102786134

版权

数据结构专栏收录该内容

12 篇文章

订阅专栏

本文详细介绍了顺序表的概念，包括如何构造空和非空的顺序表，以及顺序表的常见操作如判空、求长度、遍历、查找、插入和删除。顺序表采用静态存储分配，内存管理在变量作用域结束时自动完成。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线性表的顺序存储结构称作顺序表，其基本思想是用一段地址连续的存储单元依次存储线性表中的数据元素。其中数组下标与数据元素的序号是一一对应的。一般需要分配固定长度的数组空间存储顺序表。

一、顺序表的构造

template <typename T>
class Seqlist{
    public:
        Seqlist();
        Seqlist(T a[], int n);
        int Length();
        T Get(int i);
        int Location(T x);
        void Insert(int i, T x);
        T Delete(int i);
        int Empty();
        void PrintList();

    private:
        T data[Maxn];
        int length;
};

构造空顺序表

template<typename T>
void Seqline<T>::SeqLine(){
    T data[MAXN];
    length=0;
}

构造非空顺序表

template <typename T>
Seqlist<T>::Seqlist(T a[], int n){
    if (n > Maxn)
        throw "参数非法";
    for (int i = 0; i < n; ++i){
        data[i] = a[i];
    }
    length = n;
}

析构函数

顺序表为静态存储分配，在顺序表变量退出作用域时自动释放该变量所占内存单元，因此，顺序表无须销毁，析构函数为空。

判空操作

判断length==0即可。

template <typename T>
int Seqlist<T>::Empty()
{
    if (length == 0)
        return 1;
    else
        return 0;
}

求顺序表长度

返回length值即可。

遍历顺序表

template <typename T>
void Seqlist<T>::PrintList()
{
    for (int i = 0; i < length; ++i)
        cout << data[i] << " ";
    cout << endl;
}

该操作时间复杂度为O(n)。

按位查找

template <typename T>
T Seqlist<T>::Get(int b)
{
    if (length == 0 || b > length)
        throw "参数非法！";
    return data[b - 1];
}

时间复杂度为O(1)。

按值查找

template <typename T>
int Seqlist<T>::Location(T x)
{
    for (int i = 0; i < length; ++i)
    {
        if (data[i] == x)
            return i + 1;
    }
    return 0;
}

时间复杂度O(n)。

插入操作

template <typename T>
void Seqlist<T>::Insert(int i, T x)
{
    if (i < 1 || i > length + 1)
        throw "上溢";
    for (int j = length; j >= i; j--)
    {
        data[j] = data[j - 1];
    }
    data[i - 1] = x;
    length++;
}

时间复杂度为O(n)。

删除操作

template <typename T>
T Seqlist<T>::Delete(int i)
{
    if (i < 1 || i > length)
        throw "删除位置错误！";
    if (length == 0)
        throw "下溢";
    int x = data[i - 1];
    for (int j = i; j < length; j++)
    {
        data[j - 1] = data[j];
    }
    length--;

    return x;
}

时间复杂度为O(n)。

以下为完整的顺序表使用代码：

#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;

const int Maxn = 100;
template <typename T>
class Seqlist
{
public:
    Seqlist();
    Seqlist(T a[], int n);
    int Length();
    T Get(int i);
    int Location(T x);
    void Insert(int i, T x);
    T Delete(int i);
    int Empty();
    void PrintList();

private:
    T data[Maxn];
    int length;
};

template <typename T>
Seqlist<T>::Seqlist(T a[], int n)
{
    if (n > Maxn)
        throw "参数非法";
    for (int i = 0; i < n; ++i)
    {
        data[i] = a[i];
    }
    length = n;
}

template <typename T>
int Seqlist<T>::Empty()
{
    if (length == 0)
        return 1;
    else
        return 0;
}

template <typename T>
int Seqlist<T>::Length()
{
    return length;
}

template <typename T>
T Seqlist<T>::Get(int b)
{
    if (length == 0 || b > length)
        throw "参数非法！";
    return data[b - 1];
}

template <typename T>
int Seqlist<T>::Location(T x)
{
    for (int i = 0; i < length; ++i)
    {
        if (data[i] == x)
            return i + 1;
    }
    return 0;
}

template <typename T>
void Seqlist<T>::Insert(int i, T x)
{
    if (i < 1 || i > length + 1)
        throw "上溢";
    for (int j = length; j >= i; j--)
    {
        data[j] = data[j - 1];
    }
    data[i - 1] = x;
    length++;
}

template <typename T>
T Seqlist<T>::Delete(int i)
{
    if (i < 1 || i > length)
        throw "删除位置错误！";
    if (length == 0)
        throw "下溢";
    int x = data[i - 1];
    for (int j = i; j < length; j++)
    {
        data[j - 1] = data[j];
    }
    length--;

    return x;
}

template <typename T>
void Seqlist<T>::PrintList()
{
    for (int i = 0; i < length; ++i)
        cout << data[i] << " ";
    cout << endl;
}

int main()
{
    int r[5] = {1, 2, 3, 4, 5}, i, x;
    Seqlist<int> L(r, 5);
    cout << "当前线性表的数据为：";
    L.PrintList();
    try
    {
        L.Insert(2, 8);
        cout << "执行插入操作后数据为：";
        L.PrintList();
    }
    catch (char *str)
    {
        cout << str << endl;
    }
    cout << "当前线性表的长度为：" << L.Length() << endl;
    cout << "请输入查找的元素值：";
    cin >> x;
    i = L.Location(x);
    if (i == 0)
        cout << "查找失败" << endl;
    else
        cout << "元素" << x << "的位置为：" << i << endl;
    try
    {
        cout << "请输入查找第几个元素值：";
        cin >> i;
        cout << "第" << i << "个元素值是" << L.Get(i) << endl;
    }
    catch (char *str)
    {
        cout << str << endl;
    }
    try
    {
        cout << "请输入要删除第几个元素：";
        cin >> i;
        x = L.Delete(i);
        cout << "删除的元素是" << x << "删除后的数据为：";
        L.PrintList();
    }
    catch (char *str)
    {
        cout << str << endl;
    }
    return 0;
}