2.2顺序表的静态和动态实现

顺序表

优点：支持随机存取、存储密度高
缺点：大片连续空间分配不方便，改变容量不方便

静态顺序表

#include <stdio.h>
#define MaxSize 10
typedef struct {
    int data[MaxSize];
    int length;
}Sqlist;

/**
 * 初始化静态表
 * @param L
 */
void InitList(Sqlist &L) {
    for (int i = 0; i < MaxSize; i++) {
        L.data[i] = 0;
        L.length = 0;
    }
}

/**
 * 向列表增加元素
 * @param L 表的引用
 * @param i 位序
 * @param e 元素
 * @return
 */
bool ListInsert(Sqlist &L,int i,int e){
    if(i<1||i>L.length+1){
        return false;
    }
    if(L.length>=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;
}

/**
 * 删除表的一个元素
 * @param L 表的引用
 * @param i 位序
 * @param e 返回删除的元素
 * @return
 */
bool ListDelete(Sqlist &L,int i,int &e){
    if(i<1||i>L.length+1){
        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;
}

/**
 * 根据位序来获取元素
 * @param L 表的引用
 * @param i 位序
 * @return
 */
int GetElem(Sqlist &L,int i){
    if(i<1||i>L.length+1){
        return -1;
    }
    return L.data[i-1];
}

/**
 * 根据元素来查找最靠前的位序
 * @param L
 * @param e
 * @return
 */
int LocationElem(Sqlist &L,int e){
    for (int i = 0; i < L.length; i++) {
        if(L.data[i] == e)
            return i+1;
    }
    return 0;
}

int main()
{
    Sqlist L;
    int e;
    InitList(L);
    ListInsert(L,1,4);
    ListInsert(L,1,3);
    ListInsert(L,1,2);
    ListInsert(L,1,1);
    if(ListDelete(L,4,e))
        printf_s("第4个元素%d删除成功\n",e);
    else printf_s("删除失败，请检查位序\n");

    printf_s("你查找的元素2在第%d位序\n",LocationElem(L,2));

    for (int i = 1; i < L.length+1; ++i) {
        printf_s("%d",GetElem(L,i));
    }
    return 0;
}

动态顺序表

#include <stdio.h>
#include <cstdlib>

#define InitSize 10
typedef struct {
    int *data;
    int MaxSize;
    int length;
}Seqlist;

/**
 * 初始化动态顺序表
 * @param L
 */
void InitList(Seqlist &L) {
    L.data=(int *)malloc(InitSize*sizeof (int));
    L.length=0;
    L.MaxSize=InitSize;
}

/**
 * 增加表长
 * @param L
 * @param len
 */
void IncreaseSize(Seqlist &L,int len){
    int *p=L.data;
    L.data=(int *) malloc((L.MaxSize+len)*sizeof (int));
    for (int i = 0; i < L.length; ++i) {
        L.data[i]=p[i];
    }
    L.MaxSize=L.MaxSize+len;
    free(p);
}

/**
 * 向列表增加元素
 * @param L 表的引用
 * @param i 位序
 * @param e 元素
 * @return
 * 平均时间复杂度O(n)
 */
bool ListInsert(Seqlist &L,int i,int 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;
}

/**
 * 删除表的一个元素
 * @param L 表的引用
 * @param i 位序
 * @param e 返回删除的元素
 * @return
 * 平均时间复杂度O(n)
 */
bool ListDelete(Seqlist &L,int i,int &e){
    if(i<1||i>L.length+1){
        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;
}

/**
 * 根据位序来获取元素
 * @param L 表的引用
 * @param i 位序
 * @return
 * 平均时间复杂度O(1)
 */
int GetElem(Seqlist &L,int i){
    return L.data[i-1];
}

/**
 * 根据元素来查找最靠前的位序
 * @param L
 * @param e
 * @return
 * 平均时间复杂度O(n)
 */
int LocationElem(Seqlist &L,int e){
    for (int i = 0; i < L.length; ++i) {
        if(L.data[i] == e)
            return i+1;
    }
    return 0;
}

int main()
{
    Seqlist L;
    int e;
    InitList(L);
    printf_s("原表长：%d\n",L.MaxSize);
    IncreaseSize(L,5);
    printf_s("增加后表长：%d\n",L.MaxSize);

    ListInsert(L,1,4);
    ListInsert(L,1,3);
    ListInsert(L,1,2);
    ListInsert(L,1,1);
    if(ListDelete(L,4,e))
        printf_s("第4个元素%d删除成功\n",e);
    else printf_s("删除失败，请检查位序\n");

    printf_s("你查找的元素2在第%d位序\n",LocationElem(L,2));

    for (int i = 1; i < L.length+1; ++i) {
        printf_s("%d",GetElem(L,i));
    }
    return 0;
}