数据结构--顺序表

2.2.3 顺序表

#include<stdio.h>
#include<stdlib.h>
#define MaxSize 50


typedef int ElemType;

typedef struct SqList{
   
//    ElemType data[MaxSize];
    ElemType *data;
    int length;
    int maxSize=MaxSize;
}SqList;
typedef int DataType;


//初始化
bool InitList( SqList &L){
   
    L.data = (ElemType*)malloc(sizeof(ElemType)*MaxSize);
//    L = new ElemType(MaxSize);
    if(!L.data)
        exit(0);
    L.length = 0;
    L.maxSize = MaxSize;
    return true;
}

//在顺序表的第i个位置插入元素e
bool ListInsert(SqList &L,int i,ElemType e){
   
    if(i<1 || i>L.length+1)
        return false;
    if(i>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;
}
//尾插法
bool ListInsertLast(SqList L,ElemType e){
   
    if(L.length>MaxSize)
        return false;
    L.data[L.length] = e;
    L.length++;
    return true;
}
//顺序表L删除第i个位置的元素,所成功则返回true,并将删除元素用e返回
bool ListDelete(SqList &L,int i,ElemType &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,ElemType e){
   
    if(L.length<1)
        return 0;
    for(int i=0;i<L.length;i++){
   
        if(L.data[i]==e)
            return i+1;
    }
    return 0;
}

/*
1、从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值，
空出的位置由最后一个元素填补，若顺序表为空则返回并显示出错信息
*/
bool ListDelMin(SqList &L,ElemType &e){
   
//    如果顺序表为空,返回false
    if(L.length<1)
        return false;
//    如果顺序表长度为1，则直接删除且返回这个元素
    e = L.data[0];
    if(L.length==1){
   
        return true;
    }
//    取到顺序表最后一个元素和最小元素(假设唯一)作比较,
//    若最后一个元素是最小元素，直接返回该元素，不必删除
    int j = 0;
//    寻找最小元素并记录最小元素的所在位置
    for(int i=1;i<L.length;i++){
   
        if(L.data[i]<e){
   
            j = i;
            e = L.data[i];
        }
    }
    if(L.data[L.length-1]==e){
   
        return true;
    }
//    若最后一个元素不是最小元素,把最后一个元素值赋给最小元素所在的位置
    L.data[j] = L.data[L.length-1];
    L.length--;
    return true;
}

/*
2、设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)。
*/
bool ReserveListElem(SqList &L){
   
    if(L.length<1)
        return false;
    printf("L.length/2 = %d\n",L.length/2);
    for(int i=0;i<L.length/2;i++){
   
        int tmp;
        tmp = L.data[i];
//        试了下这种方式交换数据 ，实际不可行！！！
//        L.data[i],L.data[L.length-1-i] = L.data[L.length-1-i],L.data[i];
        L.data[i] = L.data[L.length-1-i];
        L.data[L.length-1-i] = tmp;
    }
    return true;
}
/*
3、对于长度为n的顺序表L，编写一个时间复杂度为O(n)、空间复杂度为O(1)的算法，
该算法删除线性表中所有值为x的数据元素
*/
//方法一：用j记录顺序表L中不等于e的元素个数，边扫描边统计j,并将不等于e的元素向前移动i-j个位置，最后修改L的长度
bool ElemDel(SqList &L,ElemType e){
   
    if(L.length<1)
        return false;
    int j=0;
//    假设L=[10,20,30,40,40,50,40],e=40
//    当i=3时（此时j=3）,continue；当i=4时（此时j=3），continue;
//    当i=5时（此时j=3）,L.data[3] = L.data[5],也就是L.data[5]向前移动了i-j(5-3=2)个位置，最后修改L的长度
    for(int i=0;i<L.length;i++){
   
        if(L.data[i]!=e){
   
            L.data[j] = L.data[i];
            j++;
        }
    }
    printf("j = %d\n",j);
    L.length=j;
    return true;
}
//方法二：用j来记录等于元素e的个数，边扫描L边统计j，并将不等于e的元素向前移动j个位置
bool ElemDel_1(SqList &L,ElemType e){
   
    if(L.length<1)
        return false;
    int j=0;
    for(int i=0;i<L.length;i++){
   
        if(L.data[i]==e)
            j++;
        else
            L.data[i-j] = L.data[i];
//        printf("i = %d\t",i);
//        printf("j = %d\n",j);
//        printf("L.data[%d] = %d\t",i,L.data[i]);
//        printf("e = %d\n",e);
//        printf("######################\n");
    }
    L.length=L.length-j;
    return true;
}

/*
4、从有序顺序表中删除其值在给定值s和t之间（要求s<t）的所有元素，
如果s、t给的不合理或者顺序表为空，则显示出错信息并退出运行
*/
//方法一：用j记录小于等于s或者大于等于t的元素个数
bool SectionDel(SqList &L,El