顺序表

顺序表的定义为

const int MAX = 50;
typedef int ElemType;
typedef struct {
ElemType data[MAX];
int length;
} SeqList;              //data[0] 为第一个元素

顺序表元素的插入

需要注意的几个点：

• 插入元素，插入位置范围为 1 ~ length + 1，否则不合法；
• 移动时的

  for

  的首尾元素的分析 此处为 data[0] 开始的顺序表，因此第 j 个元素位置在 data[j - 1]
• 第一次移动将第 L.length 个元素移动到第 L.length + 1 处，代码为 L.data[L.length] = L.data[L.length - 1]；
• 最后一次移动将第 i 个元素移动到下一个位置，代码为 L.data[i] = L.data[i - 1]；
• L.data[j + 1] = L.data[j]： for 起始为 j = L.length - 1 最后为 j = i - 1；
• L.data[j] = L.data[j - 1]： for 起始为 j = L.length 最后为 j = i；

代码如下：

bool ListInsert(SeqList &L, int i, ElemType e) {
if(i < 1 || i > L.length + 1) {
return false;
}
if(L.length == MAX) {
return false;
}
// 1.
for(int j = L.length - 1; j >= i - 1; j--) {
L.data[j + 1] = L.data[j];
}
// 2.
for(int j = L.length; j >= i; j--) {
L.data[j] = L.data[j - 1];
}
L.data[i - 1] = e;
L.length++;
return true;
}

顺序表元素的删除

需要注意的几个点：

• 删除元素，删除位置范围为 1 ~ length，否则不合法；

• 移动时的

  for

  的首尾元素的分析

  此处为 data[0] 开始的顺序表，因此第 j 个元素位置在 data[j - 1]

• 第一次移动将第 i + 1 个(data[i])元素移动到第 i 处(data[i - 1])，代码为

  L.data[i - 1] = L.data[i]；

• 最后一次移动将第 L.length 个(data[L.length-1])元素移动到第 L.length - 1 处，

  代码为 L.data[L.length - 2] = L.data[L.length - 1]；

• L.data[j + 1] = L.data[j]： for 起始为 j = i 最后为 j = L.lenght - 1；

• L.data[j] = L.data[j - 1]： for 起始为 j = i - 1 最后为 j = L.length - 2；

代码如下：

bool ListDelete(SeqList &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 - 1; j++) {
L.data[j] = L.data[j + 1];
}
for(int j = i; j < L.length; j++) {
L.data[j - 1] = L.data[j];
}
L.length--;
return true;
}

顺序表的查找

按值查找返回位置

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

按位置查找

对于顺序表可以随机存储，直接取数即可；

ElemType GetByLocate(SqList L,int i) {
return L.data[i];
}

顺序表的测试

#include<iostream>
using namespace std;
//静态分配空间
const int MAX = 50;
typedef int ElemType;
typedef struct {
ElemType data[MAX];
int length;
} SqList;              //data[0] 为第一个元素
/*
//动态分配空间
typedef struct {
ElemType *data;
int MAX, length;
};
*/

void ListInitite(SqList &L) {
L.length = 0;
}

//插入元素，插入位置范围为 1 ~ length + 1
bool ListInsert(SqList &L, int i, ElemType e) {
if(i < 1 || i > L.length + 1) {
return false;
}
if(L.length == MAX) {
return false;
}
// for(int j = L.length - 1; j >= i - 1; j--) {
//     L.data[j + 1] = L.data[j];
// }
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 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 - 1; j++) {
//     L.data[j] = L.data[j + 1];
// }
for(int j = i; j < L.length; j++) {
L.data[j - 1] = L.data[j];
}
L.length--;
return true;
}

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

int main() {
SqList L;
ListInitite(L);
for(int i = 1; i <= 10; i++) {
if(ListInsert(L, i, 3 * i)) {
printf("插入成功\n");
}
}
cout << L.data[0] << endl;
for(int i = 1; i <= L.length; i++) {
ElemType k = GetByLocate(L, i);
printf("%d ", k);
}
printf("\n元素 9 在顺序表中的位置为:%d\n", LocateElem(L, 9));
ElemType e;
ListDelete(L, 8, e);            //删除第 8 个元素
printf("被删除的元素为%d\n", e);
printf("删除后\n");
for(int i = 1; i <= L.length; i++) {
ElemType k = GetByLocate(L, i);
printf("%d ", k);
}
return 0;
}

测试数据及结果如下

插入成功
插入成功
插入成功
插入成功
插入成功
插入成功
插入成功
插入成功
插入成功
插入成功
3
3 6 9 12 15 18 21 24 27 30
元素 9 在顺序表中的位置为:3
被删除的元素为24
删除后
3 6 9 12 15 18 21 27 30