顺序表的定义及操作（C++）

顺序表的定义

typedef int ElemType;

const int MaxSize = 50;

typedef struct{
    ElemType data[MaxSize]; // 存储大小
    int length;				// 线性表长度
} SqList;

顺序表的基本操作

void InitList(SqList *&);                    // 初始化线性表
void DestroyList(SqList *&);                 // 销毁线性表
bool ListEmpty(SqList *);                    // 判定线性表是否为空
int ListLength(SqList *);                    // 获得线性表长度
void ShowList(SqList *);                     // 输出线性表
bool GetElem(SqList *, int, ElemType &);     // 获得第i个元素的值，存储到e中
int LocateElem(SqList *, ElemType);          // 查找元素e第一次出现的位置，不存在返回0
bool ListInsert(SqList *&, int, ElemType);   // 再第i个位置插入元素e
bool ListDelete(SqList *&, int, ElemType &); // 删除第i个元素，并存储到e中

void InitList(SqList * &L) {
    L = (SqList *)malloc(sizeof(SqList));
    L -> length = 0;
}

void DestroyList(SqList * &L) {
    free(L);
}

bool ListEmpty(SqList * L) {
    return L -> length == 0;
}

int ListLength(SqList * L) {
    return L -> length;
}

void ShowList(SqList * L) {
    printf("[L");
    for (int i = 0; i < L -> length; i++) {
        printf(" -> %d", L -> data[i]);
    }
    printf("]\n");
}

bool GetElem(SqList * L, int i, ElemType &e) {
    if (i < 1 || i > L -> length) return false;
    e = L -> data[i - 1];
    return true;
}

int LocateElem(SqList * L, ElemType e) {
    int i;
    for (i = 0; i < L -> length && L -> data[i] != e; i++) ;
    if (i == L -> length) return 0;
    return i + 1;
}

bool ListInsert(SqList * &L, int i, ElemType e) {
    if (i < 1 || i > L -> length + 1 || L -> length == MaxSize) return false;
    for (int j = L -> length; j >= i; j--) L -> data[j] = L -> data[j - 1];
    L -> data[--i] = e;
    L -> length++;
    return true;
}

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 - 1; j <= L -> length; j++) L -> data[j] = L -> data[j + 1];
    L -> length--;
    return true;
}

顺序表的基本算法

void CreateList(SqList *&, ElemType [], int); // 从数组中创建线性表，时间复杂度o(n)
void DeleteElem1(SqList *&, ElemType);        // 删除线性表中所有元素x，时间复杂度o(n)，算法1
void DeleteElem2(SqList *&, ElemType);        // 删除线性表中所有元素x，时间复杂度o(n)，算法2
void Classify1(SqList *&);                    // 将链表中所有值为奇数的元素移动到值为偶数的元素前，时间复杂度o(n)，算法1
void Classify2(SqList *&);                    // 将链表中所有值为奇数的元素移动到值为偶数的元素前，时间复杂度o(n)，算法2，区间划分法

void CreateList(SqList * &L, ElemType a[], int n) {
   L = (SqList *)malloc(sizeof(SqList));
    int i = 0;
    while (i < n && i < MaxSize) {
        L -> data[i] = a[i];
        i++;
    }
    L -> length = i;
}

void DeleteElem1(SqList * &L, ElemType x) {
	// 将所有元素前移，前移距离等于删除元素数量
    int k = 0;
    for (int i = 0; i < L -> length; i++) {
        if (L -> data[i] == x) k++;
        else L -> data[i - k] = L -> data[i];
    }
    L -> length -= k;
}

void DeleteElem2(SqList * &L, ElemType x) {
	// 重构顺序表，将所有值不等于x的元素重新构建至sqlist中
    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 Classify1(SqList * &L) {
	// 设置前后指针i，j
	// 将前指针偶数与后指针奇数进行交换
    int i = 0, j = L -> length - 1;
    while (i < j) {
        while (i < j && (L -> data[i] & 1)) i++;  // 从前向后查找偶数，奇数跳过
        while (i < j && !(L -> data[j] & 1)) j--; // 从后向前查找奇数
        if (i < j) {
        	// 交换奇偶元素
            ElemType temp = L -> data[i];
            L -> data[i] = L -> data[j];
            L -> data[j] = temp;
        }
    }
}

void Classify2(SqList * &L) {
	Classify2(SqList * &sqlist) {
	// 划分奇偶区间 奇数j[0...j]，偶数i[j + 1...]
	// 遍历查找到偶数区间的奇数后data[i]，交换data[j + 1]，a[i]
    int j = -1;
    for (int i = 0; i < L -> length; i++) {
        if (L -> data[i] & 1) {
            j++;
            if (i != j) {
                ElemType temp = L -> data[i];
                L -> data[i] = L -> data[j];
                L -> data[j] = temp;
            }
        }
    }
}