静态存储
#include <bits/stdc++.h>
using namespace std;
#define MaxSize 10 // 定义最大长度
typedef struct SqList {
int data [MaxSize]; // 用静态的数组存放类型为整数的数据元素,本例中的ElemType是int
int length; // 数组当前长度
}SqList; // 顺序表的类型定义
void InItList(SqList &L) {
for (int i = 0; i < MaxSize; i++) {
L.data[i] = 0; // 将所有元素值初始化为0,不然可能会有“脏数据”
}
L.length = 0; // 设置顺序表初始长度为0
}
// 按位插入操作,在表L中的第i个位置上插入指定元素e。
bool ListInsert(SqList &L, int i, int e)
{
if(i< 1 || i > L.length + 1) {// 判断i的范围是否有效,即在1到L.length,如果不在返回false
return false;
}
for(int j = L.length; j >= i; j--) {// 将第i个元素及其之后的元素全部后移,从后往前依次进行
L.data[j] = L.data[j - 1];
}
L.data[i- 1] = e;
L.length++;
return true;
}
// 将顺序表L的第i个元素删除,并将第i个元素的值返回给e
bool ListDelete(SqList &L, int i, int &e)
{
// 判断位置是否合法
if(i < 1 || i > L.length) {// 被删除位置应该在1到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;
}
// 按位查找
int getElem(SqList L, int i)
{
return L.data[i - 1];
}
int LocateElem(SqList L, int e)
{
for(int i = 1; i <= L.length; ++i) {
if(L.data[i - 1] == e) {
return i;
}
}
return -1; //查找失败,返回-1;
}
void Print(SqList L)
{
for(int i = 0; i < L.length; i++) {
cout << L.data[i] << " ";
}
cout << endl;
}
int main()
{
SqList L; // 声明一个顺序表,开始在内存中分配存储顺序表的存储空间,包括数组和存储length的存储空间
InItList(L); // 初始化一个顺序表,赋初值0
ListInsert(L, 1, 3);
ListInsert(L, 2, 3);
ListInsert(L, 2, 5);
int e = 0;
ListDelete(L,1,e);
Print(L);
cout << e << " " << getElem(L, 1) << " " << LocateElem(L, 5)<< endl;
return 0;
}
// 输出
5 3
3 5 1
动态存储实现
#include <bits/stdc++.h>
using namespace std;
#define INIT_SIZE 2
typedef struct SeqList {
int* data;
int maxSize;
int length;
}SeqList;
void InItList(SeqList& L) // 用malloc申请一块连续的存储空间,用来存放数组
{
L.data = (int*)malloc(INIT_SIZE * sizeof(int));
L.maxSize = INIT_SIZE;
L.length = 0;
cout<< "L.maxSize:" <<L.maxSize << endl;
}
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;
cout<< "L.maxSize:" <<L.maxSize << endl;
delete p;
}
void DoubleSize(SeqList& L)
{
int *p = L.data;
L.data = (int*)malloc((L.maxSize * 2) * sizeof(int));
for(int i = 0; i < L.length; i++) {
L.data[i] = p[i];
}
L.maxSize = L.maxSize * 2;
cout<< "L.maxSize:" <<L.maxSize << endl;
delete p;
}
bool ListInsert(SeqList &L, int i, int e)
{
// if(i < 1 || i > L.length + 1) {
// return false;
// }
assert(i >= 1 && i <= L.length + 1);
if(L.length >= L.maxSize) {// 容量不够,扩容一倍
DoubleSize(L);
}
for(int j = L.length; j >= i; j--) {// 将最后一个元素到第i个元素依次前移
L.data[j] = L.data[j - 1];// 将下标j(原来存放的j + 1)存放前一个元素,也即把元素后移,用后一个坐标承接
}
L.data[i - 1] = e; // 将待插入的值存放入第i个位置
L.length++; // 不要忘了更新长度,插入一个元素,长度+1
return true; // 全程没有错误,返回true
}
bool ListDelete(SeqList &L, int i, int &e)
{
if (i < 1 || i > L.length) {
return false;
}
e = L.data[i -1];
for (int j = i; j < L.length; ++j) {// 把从i+1到末尾的元素都前移
L.data[j - 1] = L.data[j]; // 第j个位置放第j+1个元素
}
L.data[L.length - 1] = 0;
L.length--;
return true;
}
//在顺序表L中查找第一个元素值等于e的元素,并返回其位序
int LocateElem(SeqList L, int e)
{
for (int i = 0; i < L.length; ++i) {
if (L.data[i] == e) {
return i +1; // 如果数组下标为i的元素等于e,返回其位序i+1
}
}
return 0; // 如果退出循环,返回0,查找失败
}
void Print(SeqList L, int &e) {
for(int i = 0; i < L.length; ++i) {// 遍历数组全部元素
cout << L.data[i] << " "; // 依次输出每一个值
}
cout << "e:" << e << endl;
}
int main ()
{
SeqList L; // 声明一个顺序表,开辟了一个int指针空间,两个int空间
int e;
InItList(L); // 初始化顺序表,为顺序表分配内存空间并赋初值,开辟了INIT_SIZE个int空间
ListInsert(L, 1, 3);
ListInsert(L, 2, 5);
// IncreaseSize(L, 5); // 开辟一个新的内存空间,把数据复制过来,更新顺序表容量,最后释放原来的内存空间
ListInsert(L, 3, 4);
ListDelete(L, 2, e);
cout << "4local:" << LocateElem(L, 4) << endl;
Print(L, e);
return 0;
}
// 输出
L.maxSize:2
L.maxSize:4
4local:2
3 4 e:5