目录
动静态顺序表结构体的定义
// 准备头文件
#include <stdio.h>
#include <stdlib.h>
// 定义静态顺序表的最大长度和动态顺序表的初始默认最大容量
#define MaxSize 10 // 静态顺序表最大长度
#define InitSize 10 // 动态顺序表的初始默认长度
// 定义C语言的bool变量
#define bool char
#define true 1
#define false 0
/* 定义数据元素的数据类型 */
typedef int ElemType; // 方便更改
// 静态顺序表结构体定义
typedef struct Sqlist
{
ElemType data[MaxSize];
int length;
}Sqlist;
// 动态顺序表的结构体定义
typedef struct Sqlist_d
{
ElemType *data;
int length;
int maxsize;
}Sqlist_d;
动静态顺序表的初始化
// 静态顺序表的初始化
bool InitSqList(Sqlist *L)
{
L->length = 0;
// 初始化元素? 可以不用
// int i;
// for(i = 0;i < MaxSize; i++)
// {
// L->data[i] = 0;
// }
}
// 动态顺序表的初始化
bool InitSqList_d(Sqlist_d *L)
{
L->length = 0;
L->maxsize = InitSize;
// 为数据开辟空间
L->data = (ElemType *)malloc(sizeof(ElemType) * InitSize);
return true;
}
动静态顺序表的元素插入
// 静态顺序表的插入
bool SqListInsert(Sqlist *L,int i,ElemType e)
{
// 判断操作是否合法
if(i < 1 || i > L->length + 1)
{
printf("插入位置不合法!\n");
return false;
}
if(L->length >= MaxSize)
{
printf("这个表已经满了。\n");
return false;
}
// 将第i位元素及其后面的元素向后移一位
int j; // length的长度刚好是当前最大下标加一
for(j = L->length;j >= i;j--)
{
L->data[j] = L->data[j-1];
}
// 将新元素放到插入的位置
L->data[i-1] = e;
// 表长加1
L->length++;
// 插入成功返回true
return true;
}
// 动态顺序表的插入
bool SqList_dInsert(Sqlist_d *L,int i,ElemType e)
{
// 判断操作是否合法
if(i < 1 || i > L->length + 1)
{
printf("插入位置不合法!\n");
return false;
}
if(L->length >= L->maxsize)
{
printf("这个表已经满了。\n");
return false;
}
// 将第i位元素及其后面的元素向后移一位
int j; // length的长度刚好是当前最大下标加一
for(j = L->length;j >= i;j--)
{
L->data[j] = L->data[j-1];
}
// 将新元素放到插入的位置
L->data[i-1] = e;
// 表长加1
L->length++;
// 插入成功返回true
return true;
}
动静态顺序表的删除操作
// 静态顺序表的元素删除
// 将顺序表中第i位元素删除并把它返回给e
bool SqListElemDelete(Sqlist *L, int i, ElemType *e)
{
// 判断合法性
if(i < 1 || i > L->length)
{
printf("删除位置不合法!\n");
return false;
}
// 判空
if(L->length == 0)
{
printf("这个表是空的!\n");
return false;
}
// 将删除元素赋值给e
*e = L->data[i-1];
// 将第i位元素之后的元素向前移动一位
int j; // 此时i若作为下标就是删除元素后一位的下标
for(j = i; j < L->length; j++)
{
L->data[j-1] = L->data[j];
}
// 表长减一
L->length--;
return true;
}
// 动态顺序表的元素删除
bool SqList_dElemDelete(Sqlist_d *L, int i, ElemType *e)
{
// 判断合法性
if(i < 1 || i > L->length)
{
printf("删除位置不合法!\n");
return false;
}
// 判空
if(L->length == 0)
{
printf("这个表是空的!\n");
return false;
}
// 将删除元素赋值给e
*e = L->data[i-1];
// 将第i位元素之后的元素向前移动一位
int j; // 此时i若作为下标就是删除元素后一位的下标
for(j = i; j < L->length; j++)
{
L->data[j-1] = L->data[j];
}
// 表长减一
L->length--;
return true;
}
动静态顺序表按值查询操作
// 静态顺序表的按值查找并返回其位序
int SqListLocElem(Sqlist L, ElemType e)
{
int i;
for(i = 0; i < L.length; i++)
{
if(L.data[i] == e)
{
return i + 1;
}
}
return 0;
}
// 动态顺序表的按值查找并返回其位序
int SqList_dLocElem(Sqlist_d L, ElemType e)
{
int i;
for(i = 0; i < L.length; i++)
{
if(L.data[i] == e)
{
return i + 1;
}
}
return 0;
}
动态顺序表的扩容
// 动态顺序表的扩容
bool IncreaseSize(Sqlist_d *L, int len)
{
// 生成一个新指针指向原来数据的空间
ElemType *p = L->data;
// 开辟更大的空间
L->data = (ElemType *)malloc(sizeof(ElemType) * (L->length + len));
// 转移数据
int i;
for(i = 0; i < L->length; i++)
{
L->data[i] = p[i]; // p[i] === *p + i
}
// 修改最大长度
L->maxsize += len;
// 释放原来的空间
free(p);
return true;
}
扩容增加新方法(realloc)
若有错误请指出
// 动态顺序表的扩容
bool IncreaseSize(Sqlist_d *L, int len)
{
// // 生成一个新指针指向原来数据的空间
// ElemType *p = L->data;
// // 开辟更大的空间
// L->data = (ElemType *)malloc(sizeof(ElemType) * (L->length + len));
// // 转移数据
// int i;
// for(i = 0; i < L->length; i++)
// {
// L->data[i] = p[i]; // p[i] === *p + i
// }
// // 修改最大长度
// L->maxsize += len;
// // 释放原来的空间
// free(p);
// realloc如果无法就地扩容会返回NULL
L->data = (ElemType *)realloc(L->data ,sizeof(ElemType) * (L->length + len));
L->maxsize += len;
return true;
}
动静态顺序表的输出
// 静态顺序表的输出
bool Sqlistprint(Sqlist L)
{
// 判空
if(L.length == 0)
{
printf("这个顺序表为空!\n");
return false;
}
// 输出
printf("Sqlist;");
int i;
for(i = 0; i < L.length; i++)
{
printf("%d-->", L.data[i]);
}
printf("end\n");
return true;
}
// 动态顺序表的输出
bool Sqlist_dprint(Sqlist_d L)
{
// 判空
if(L.length == 0)
{
printf("这个顺序表为空!\n");
return false;
}
// 输出
printf("Sqlist_d;");
int i;
for(i = 0; i < L.length; i++)
{
printf("%d-->", L.data[i]);
}
printf("end\n");
return true;
}
完整代码
// 准备头文件
#include <stdio.h>
#include <stdlib.h>
// 定义静态顺序表的最大长度和动态顺序表的初始默认最大容量
#define MaxSize 10 // 静态顺序表最大长度
#define InitSize 10 // 动态顺序表的初始默认长度
// 定义C语言的bool变量
#define bool char
#define true 1
#define false 0
/* 定义数据元素的数据类型 */
typedef int ElemType; // 方便更改
// 静态顺序表结构体定义
typedef struct Sqlist
{
ElemType data[MaxSize];
int length;
}Sqlist;
// 动态顺序表的结构体定义
typedef struct Sqlist_d
{
ElemType *data;
int length;
int maxsize;
}Sqlist_d;
// 静态顺序表的初始化
bool InitSqList(Sqlist *L)
{
L->length = 0;
// 初始化元素? 可以不用
// int i;
// for(i = 0;i < MaxSize; i++)
// {
// L->data[i] = 0;
// }
}
// 动态顺序表的初始化
bool InitSqList_d(Sqlist_d *L)
{
L->length = 0;
L->maxsize = InitSize;
// 为数据开辟空间
L->data = (ElemType *)malloc(sizeof(ElemType) * InitSize);
return true;
}
// 静态顺序表的插入
bool SqListInsert(Sqlist *L,int i,ElemType e)
{
// 判断操作是否合法
if(i < 1 || i > L->length + 1)
{
printf("插入位置不合法!\n");
return false;
}
if(L->length >= MaxSize)
{
printf("这个表已经满了。\n");
return false;
}
// 将第i位元素及其后面的元素向后移一位
int j; // length的长度刚好是当前最大下标加一
for(j = L->length;j >= i;j--)
{
L->data[j] = L->data[j-1];
}
// 将新元素放到插入的位置
L->data[i-1] = e;
// 表长加1
L->length++;
// 插入成功返回true
return true;
}
// 动态顺序表的插入
bool SqList_dInsert(Sqlist_d *L,int i,ElemType e)
{
// 判断操作是否合法
if(i < 1 || i > L->length + 1)
{
printf("插入位置不合法!\n");
return false;
}
if(L->length >= L->maxsize)
{
printf("这个表已经满了。\n");
return false;
}
// 将第i位元素及其后面的元素向后移一位
int j; // length的长度刚好是当前最大下标加一
for(j = L->length;j >= i;j--)
{
L->data[j] = L->data[j-1];
}
// 将新元素放到插入的位置
L->data[i-1] = e;
// 表长加1
L->length++;
// 插入成功返回true
return true;
}
// 静态顺序表的元素删除
// 将顺序表中第i位元素删除并把它返回给e
bool SqListElemDelete(Sqlist *L, int i, ElemType *e)
{
// 判断合法性
if(i < 1 || i > L->length)
{
printf("删除位置不合法!\n");
return false;
}
// 判空
if(L->length == 0)
{
printf("这个表是空的!\n");
return false;
}
// 将删除元素赋值给e
*e = L->data[i-1];
// 将第i位元素之后的元素向前移动一位
int j; // 此时i若作为下标就是删除元素后一位的下标
for(j = i; j < L->length; j++)
{
L->data[j-1] = L->data[j];
}
// 表长减一
L->length--;
return true;
}
// 动态顺序表的元素删除
bool SqList_dElemDelete(Sqlist_d *L, int i, ElemType *e)
{
// 判断合法性
if(i < 1 || i > L->length)
{
printf("删除位置不合法!\n");
return false;
}
// 判空
if(L->length == 0)
{
printf("这个表是空的!\n");
return false;
}
// 将删除元素赋值给e
*e = L->data[i-1];
// 将第i位元素之后的元素向前移动一位
int j; // 此时i若作为下标就是删除元素后一位的下标
for(j = i; j < L->length; j++)
{
L->data[j-1] = L->data[j];
}
// 表长减一
L->length--;
return true;
}
// 静态顺序表的按值查找并返回其位序
int SqListLocElem(Sqlist L, ElemType e)
{
int i;
for(i = 0; i < L.length; i++)
{
if(L.data[i] == e)
{
return i + 1;
}
}
return 0;
}
// 动态顺序表的按值查找并返回其位序
int SqList_dLocElem(Sqlist_d L, ElemType e)
{
int i;
for(i = 0; i < L.length; i++)
{
if(L.data[i] == e)
{
return i + 1;
}
}
return 0;
}
// 动态顺序表的扩容
bool IncreaseSize(Sqlist_d *L, int len)
{
// 生成一个新指针指向原来数据的空间
ElemType *p = L->data;
// 开辟更大的空间
L->data = (ElemType *)malloc(sizeof(ElemType) * (L->length + len));
// 转移数据
int i;
for(i = 0; i < L->length; i++)
{
L->data[i] = p[i]; // p[i] === *p + i
}
// 修改最大长度
L->maxsize += len;
// 释放原来的空间
free(p);
return true;
}
// 静态顺序表的输出
bool Sqlistprint(Sqlist L)
{
// 判空
if(L.length == 0)
{
printf("这个顺序表为空!\n");
return false;
}
// 输出
printf("Sqlist;");
int i;
for(i = 0; i < L.length; i++)
{
printf("%d-->", L.data[i]);
}
printf("end\n");
return true;
}
// 动态顺序表的输出
bool Sqlist_dprint(Sqlist_d L)
{
// 判空
if(L.length == 0)
{
printf("这个顺序表为空!\n");
return false;
}
// 输出
printf("Sqlist_d;");
int i;
for(i = 0; i < L.length; i++)
{
printf("%d-->", L.data[i]);
}
printf("end\n");
return true;
}
int main()
{
// 生成顺序表
Sqlist L1;
Sqlist_d L2;
// 初始化
InitSqList(&L1);
InitSqList_d(&L2);
//插入一些元素
SqListInsert(&L1,1,1);
SqListInsert(&L1,2,2);
SqListInsert(&L1,3,3);
SqListInsert(&L1,4,4);
SqListInsert(&L1,5,5);
SqListInsert(&L1,6,6);
SqListInsert(&L1,7,7);
SqListInsert(&L1,8,8);
SqListInsert(&L1,9,9);
SqListInsert(&L1,10,10);
SqList_dInsert(&L2,1,1);
SqList_dInsert(&L2,2,2);
SqList_dInsert(&L2,3,3);
SqList_dInsert(&L2,4,4);
SqList_dInsert(&L2,5,5);
SqList_dInsert(&L2,6,6);
SqList_dInsert(&L2,7,7);
SqList_dInsert(&L2,8,8);
SqList_dInsert(&L2,9,9);
SqList_dInsert(&L2,10,10);
SqList_dInsert(&L2,11,11);
Sqlistprint(L1);
Sqlist_dprint(L2);
// 删除操作
ElemType e1;
ElemType e2;
SqListElemDelete(&L1, 1, &e1);
SqList_dElemDelete(&L2, 4, &e2);
printf("e1 = %d\n", e1);
printf("e2 = %d\n", e2);
Sqlistprint(L1);
Sqlist_dprint(L2);
// 查询操作
printf("L1的6是:第%d位\n",SqListLocElem(L1,6));
printf("L2的4是:第%d位\n",SqList_dLocElem(L2,4));
// 动态顺序表的扩容
IncreaseSize(&L2, 20);
Sqlist_dprint(L2);
printf("L2的空间大小为:%d\n", L2.maxsize);
return 0;
}
运行结果
这个表已经满了。
Sqlist;1-->2-->3-->4-->5-->6-->7-->8-->9-->10-->end
Sqlist_d;1-->2-->3-->4-->5-->6-->7-->8-->9-->10-->end
e1 = 1
e2 = 4
Sqlist;2-->3-->4-->5-->6-->7-->8-->9-->10-->end
Sqlist_d;1-->2-->3-->5-->6-->7-->8-->9-->10-->end
L1的6是:第5位
L2的4是:第0位
Sqlist_d;1-->2-->3-->5-->6-->7-->8-->9-->10-->end
L2的空间大小为:30
若有错误,希望在评论区指出