线性表之顺序表操作（未完待续）

考研408数据结构线性表复习

#include<iostream>
#include<algorithm>

const int initlength = 100;     ///顺序表的初始长度

using namespace std;

typedef struct
{
    int *data;
    int MaxSize, length;        ///顺序表的最大存储空间，长度；
}SeqList;


///*****顺序表基本操作

void initList(SeqList &L, int n = initlength)       ///初始化顺序表
{
    L.data = new int [n];
    L.length = 0;
    L.MaxSize = n;
    for(int i=0;i<L.MaxSize;++i)
    {
        cin>>L.data[i];
        L.length++;
    }
}

int Length(SeqList L)           ///返回顺序表的长度
{
    return L.length;
}

bool EmptyList(SeqList L)          ///判断顺序表是否为空
{
    if(L.length == 0)
        return true;
    return false;
}

bool ListInsert(SeqList &L, int i, int value)           ///插入元素， i为元素的位置， value为元素的值
{
    if(i<1 || i>L.length+1)
        return false;
    if(i >= L.MaxSize)
        return false;
    for(int j=L.length; j>=i; --j)
        L.data[j] = L.data[j-1];
    L.data[i-1] = value;
    L.length++;
    return true;
}

bool ListDelete(SeqList &L, int i, int &e)          ///删除元素， i为删除元素的位置， e为删除位置元素的值
{
    if(i<1 || i>L.length)
        return false;
    e = L.data[i-1];
    for(int j=i-1; j<L.length-1; ++j)
        L.data[j] = L.data[j+1];
    L.length--;
    return true;
}

int LocateElem(SeqList L, int e)                ///按值查找第一个元素值为e的位序
{
    for(int i=0; i<L.length; ++i)
    {
        if(e == L.data[i])
            return i+1;
    }
    return 0;
}


void PrintList(SeqList L)           ///打印输出整个顺序表
{
    for(int i=0;i<L.length;++i)
        cout<<L.data[i]<<" ";
    cout<<endl;
}


///***顺序表进阶操作，带题目描述

///1.在顺序表中删除具有最小值的元素（假设唯一）， 并由函数返回被删元素的值
///         空出的位置由最后一个元素填补。若顺序表为空，显示错误信息并退出

bool DeleteMinList(SeqList &L, int &e)
{
    if(EmptyList(L))    //if (L.length == 0)
    {
        cout<<"The List is empty, can't delete the min value!"<<endl;
        return false;
    }
    int ListMin = L.data[0];
    int LocalMin = 0;
    for(int i=0;i<L.length;++i)
    {
        if(ListMin > L.data[i])
        {
            ListMin = L.data[i];
            LocalMin = i;
        }
    }
    e = ListMin;
    L.data[LocalMin] = L.data[L.length-1];
    L.length--;
    return true;
}

///设计一个高效算法，将顺序表的所有元素逆置，要求算法的空间复杂度为O(1)
void ReverseList(SeqList &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;
    }
}

///长度为n的顺序表L， 编写一个时间复杂度为O(n)， 空间复杂度为O(1), 该算法删除线性表中所有值为x的数据元素。
///可为该顺序表重新构造

void DeleteEqualElement(SeqList &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 DeleteEqualElement(SeqList &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 -= k;
}
*/

int main()
{
    ios::sync_with_stdio(false);
    SeqList L;
    int n;
    cin>>n;
    initList(L, n);
    ListInsert(L, 5, 8);
    PrintList(L);
    cout<<"The List Length is "<<Length(L)<<endl;
    int e;
    ListDelete(L, 5, e);
    PrintList(L);
    cout<<"e's value is "<<e<<endl;
    cout<<"The List Length is "<<Length(L)<<endl;
    int order = LocateElem(L, 6);
    if(order != 0)
        cout<<"The element's order is "<<order<<endl;
    else
        cout<<"sorry, we can't find the value's order!!!"<<endl;
    DeleteMinList(L, e);
    PrintList(L);
    cout<<"e's value is "<<e<<endl;
    ReverseList(L);
    PrintList(L);
    return 0;
}