增序顺序储存线性表的基本操作

本文实现了顺序储存结构线性表的基本操作，可能存在一些bug。

算法分析

顺序表的初始化

算法步骤

1、将长度初始化为零
2、设置一个默认的大小，用于实现动态扩充
3、动态分配一块内存

顺序表的取值

算法步骤

1、判断位置是否正确
2、若正确返回RIGHT，注意，数组的下标是从0开始的

时间复杂度

由于是直接取值，所以是时间复杂度为O(1)。

顺序表的查找

遍历数组，若找到返回位置，否则为ERROR

时间复杂度

时间主要耗费在元素的比较上，设pi为查找第i个元素的概率，Ci为找到第i个数据元素时已经比较过的次数，则平均查找长度为pi*Ci
假设每个元素的查找概率相等，则pi=1/n
则平均查找长度为∑PiCi (i=1,2,3,…,n)=(n+1)/2
所以平均复杂度为O(2)

顺序表的插入

1、判断位置是否合法
2、将长度加一
3、若长度大于该顺序表的大小，则重新申请一块内存，大小为原顺序表的两倍，将原顺序表拷贝到新的顺序表中
4、将插入位置的元素依次向后移动一位
5、在插入位置插入元素

时间复杂度

E=∑pi*(n-i+1)(i=1->n+1)
pi为在第i个元素之前插入的概率，n-i+1为需要移动的元素个数
假设在任何位置插入元素的概率相等，则pi=1/(n+1)
则E=1/(n+1)*∑(n-i+1)(i=1->n+1)=n/2
所以平均复杂度为O(n)

顺序表的删除

1、判断位置是否合法
2、将删除位置的元素以此向前移动
3、长度减一

时间复杂度

E=∑pi*(n-i)
pi为在第i个元素之前插入的概率，n-i为需要移动的元素个数
假设在任何位置插入元素的概率相等，则pi=1/n
则E=1/n*∑(n-i)(i=1->n+1)=(n-1)/2
所以平均复杂度为O(n)

顺序表的追加

1、长度加一
2、若长度大于该顺序表的大小，则重新申请一块内存，大小为原顺序表的两倍，将原顺序表拷贝到新的顺序表中
3、在尾部添加一个元素

C++实现

#include <iostream>
#include <cstdlib>
#define FSIZE 5

using namespace std;
class MyList
{
private:
    int *a;
    int size;
    int length;
public:
    MyList();
    MyList(int);
    ~MyList();
    //添加一个元素进入顺序表并以升序进行排列
    bool Add(int e);
    //删除某一个元素
    bool Delete(int p);
    //查找某一个元素，若成功返回true，并将值储存到p中，否则返回false
    bool Find(int e,int &p);
    //判断是否为空
    bool isEmpty();
    //获取长度
    int GetLength();
    //获取下标为e-1的元素并放到p中
    bool GetItem(int e, int &p);

};

void Show(MyList &l)
{
    for(int i=0;i<l.GetLength();i++)
    {
        int p;
        if(l.GetItem(i,p))
            cout << p << endl;
    }
}

int main()
{
    MyList l;
    for(int i=0;i<99;i++)
    {
        l.Add(rand()%100);
    }
    cout << "=====输出测试1======" << endl;
    Show(l);
    cout << endl;
    for(int i=0;i<12;i++)
    {
        int p;
        if(l.GetItem(i,p))
            cout << p << endl;
    }

    return 0;
}


//===========================================
MyList::MyList()
{
    size=FSIZE;
    a=new int[size];
    length=0;
}
MyList::MyList(int l)
{
    length=l;
    size=l*2;
    a=new int[size];
}

MyList::~MyList()
{
    delete []a;
}

bool MyList::Add(int e)
{
    int *temp;
    length++;
    if(length>=size)
    {
        size=length*2;
        temp=new int[size];
        for(int i=0;i<length-1;i++)
            temp[i]=a[i];
        delete []a;
        a=temp;
    }
    a[length-1]=e;
    for(int i=length-1;i>0&&a[i]<a[i-1];i--)
    {
        int t=a[i];
        a[i]=a[i-1];
        a[i-1]=t;
    }
    return true;
}

bool MyList::Delete(int p)
{
    if(isEmpty())
    {
        cout << "The List is empty" << endl;
        return false;
    }
    else
    {
        for(int i=p;i<length-1;i++)
        {
            a[i]=a[i+1];
        }
        --length;
        return true;
    }
}

bool MyList::isEmpty()
{
    return length==0;
}

bool MyList::Find(int e,int &p)
{
    for(int i=0;i<length;i++)
    {
        if(a[i]==e)
        {
            p=i+1;
            return true;
        }
    }
    return false;
}

bool MyList::GetItem(int e,int &p)
{
    if(e<0||e>length-1)
    {
        cout << "Wrong Input" << endl;
        return false;
    }
    else
    {
        p=a[e];
        return true;
    }
}

int MyList::GetLength()
{
    return length;
}

申请内存与释放内存的正确打开方式

int *a;
a=new int[10];//a=new int(10)错误
delete []a;