顺序表的实现

顺序表是线性表的实现方式之一，其特点是逻辑上相邻的元素在物理上也相邻。顺序表一般使用数组实现。因此顺序表可以随机访问，时

间复杂度为O(1)。但插入和删除元素时，由于线性表的有序性，要移动大量元素，时间复杂度为O(n).

本代码拟使用动态分配空间的方式存储顺序表元素。

一个顺序表结构类型如下：

struct SqList {
    Elem* data;
    int length;
    int MaxSize;
};

其中length标记表中目前的元素个数；MaxSize标记这个顺序表可容纳的最大元素个数，data为顺序表首元素的地址。顺序表中第i个元素

为data[i-1].  可以使用如下代码初始化一个顺序表：

SqList L;
L.data = new ElemType;
L.length = 0;
L.MaxSize = MaxSize;    //MaxSize可以指定

 

 

/*      顺序表
    实现操作：
     *1 按位插入
     *2 按位删除
     *3 按值查找
     *4 增加表长
                */
#include <iostream>
#include <cstdio>
using namespace std;

typedef int Elem;

struct SqList {
    Elem* data;
    int length;
    int MaxSize;
};

//初始化传入的SqList 类型的变量L
bool InitList(SqList& L,int MaxSize)
{
    L.data = new ElemType;
    L.length = 0;
    L.MaxSize = MaxSize;
    return true;
}

//按位插入:在位序i插入元素e  插入后元素e的位序为i
bool InsertList( SqList &L, int i,Elem e )
{
    if( i < 1 || i > L.length + 1 )
        return false;
    if( L.length >= L.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;
}

//按位删除:删除位序为i的元素并用e将其值带回
bool deleteList( SqList& L, int i, Elem& 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;
}

//按值查找:返回表中第一个等于e的元素的位序
int locateElem( SqList& L, Elem e )
{
    for( int i=0; i<L.length; i++ ) {
        if( L.data[i] == e ) {
            return i+1;
        }
    }
    return -1;
}

//增加长度:将顺序表的最大长度增加len
void increaseSize( SqList& L,int len )
{
    Elem* p = L.data;
    Elem* np = new Elem[L.length+len];
    for( int i=0; i<L.length; i++ ) {
        np[i] = p[i];
    }
    L.MaxSize += len;
    delete p;
}

int main()
{
    SqList L;
    InitList(L,100);
    for( int i=1; i<100; i++ ) {
        InsertList(L,i,i);
    }
    return 0;
}

 下一篇【单链表的实现C/C++】：https://www.cnblogs.com/pkuqcy/p/14946297.html