线性表:零个或多个数据元素的有限序列
线性表是一个序列,即元素之间是由顺序的,若元素存在多个,则第一个元素无前驱,最后一个元素无后继,其他每个元素有且只有一个前驱和后继(不能跳着进行存储)。其次线性表的元素个数是有限的。
线性表的顺序存储结构
线性表的顺序存储结构,指的是用一段地址连续的存储单元依此存储线性表的数据元素。
代码实现动态线性表的顺序存储
环境:VS2013
语言:c
//sqList.h文件
#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct
{
ElemType* data;
int length;
int capacity;
}sqList;
//初始化顺序表
void initList(sqList* sl);
//增加容量
void addListCapacity(sqList* sl);
//判断顺序表是否为空
bool listEmpty(const sqList* sl);
//清空链表
void clearList(sqList* sl);
//定位“值”位置
int locateElem(const sqList* sl, ElemType value);
//插入
bool listInsert(sqList* sl, int loca, ElemType value);
//删除
bool listDetele(sqList* sl, int loca);
//计算链表长度
int lengthList(const sqList* sl);
//计算链表的容量
int getCapacity(const sqList* sl);
//展示链表的内容
void showList(const sqList* sl);
//并集
void listUnion(sqList* sl1, const sqList* sl2);
//交集
void listInList(sqList* sl1, const sqList* sl2);
//销毁空间
void freeList(sqList* sl);
//sqList.cpp文件
#include"sqList.h"
void initList(sqList* sl)
{
sl->capacity = 0;
sl->length = 0;
sl->data = NULL;
addListCapacity(sl);
}
void addListCapacity(sqList* sl)
{
int newCapacity;
if (0 == sl->capacity)
{
newCapacity = 1;
}
else
{
newCapacity = 2 * sl->capacity;
}
sl->data = (ElemType*)realloc(sl->data, newCapacity*sizeof(ElemType));
if (NULL != sl->data)
{
sl->capacity = newCapacity;
}
}
bool listEmpty(const sqList* sl)
{
return (0==sl->length) ? true : false;
}
void clearList(sqList* sl)
{
sl->length = 0;
}
int locateList(const sqList* sl, ElemType value)
{
int len = sl->length, loca = -1;
for (int i = 0; i < len; ++i)
{
if (value == sl->data[i])
{
loca = i;
}
}
return loca;
}
int lengthList(const sqList* sl)
{
return sl->length;
}
bool listInsert(sqList* sl, int loca, ElemType value)
{
bool bRef = true;
if (loca<0 || loca>sl->length)
{
bRef = false;
}
else
{
if (sl->capacity == sl->length)
{
addListCapacity(sl);
}
for (int j = sl->length-1; j >= loca; --j)
{
sl->data[j + 1] = sl->data[j];
}
sl->data[loca] = value;
++sl->length;
}
return bRef;
}
bool listDetele(sqList* sl, int loca)
{
bool bRef = true;
if (loca < 0 || loca >= sl->length)
{
bRef = false;
}
else
{
int len = sl->length - 1;
for (int j = loca; j < len; ++j)
{
sl->data[j] = sl->data[j + 1];
}
--sl->length;
}
return bRef;
}
int getCapacity(const sqList* sl)
{
return sl->capacity;
}
void showList(const sqList* sl)
{
int len = sl->length;
for (int i = 0; i < len; ++i)
{
printf("%d,", sl->data[i]);
}
printf("\n");
}
void listUnion(sqList* sl1, const sqList* sl2)
{
printf("并集:");
int len = sl2->length;
for (int i = 0; i < len; ++i)
{
if (locateList(sl1, sl2->data[i]) == -1)
{
listInsert(sl1, sl1->length, sl2->data[i]);
}
}
}
void listInList(sqList* sl1, const sqList* sl2)
{
printf("交集:");
//在这里需要注意sl1的长度是变化的
for (int i = 0; i < sl1->length; ++i)
{
if (locateList(sl2, sl1->data[i]) == -1)
{
listDetele(sl1, i);
//如果有元素被删除,它后面的元素就会向前移动一位
--i;
}
}
}
void freeList(sqList* sl)
{
if (NULL != sl->data)
{
free(sl->data);
sl->data = NULL;
sl->capacity = 0;
sl->length = 0;
}
}
//Main.cpp文件
#include "sqList.h"
int main()
{
sqList list1,list2;
initList(&list1);
initList(&list2);
for (int i = 0; i < 5; ++i)
{
listInsert(&list1, i, i);
listInsert(&list2, i, i+4);
}
showList(&list1);
showList(&list2);
listUnion(&list1, &list2);
//listInList(&list1, &list2);
showList(&list1);
showList(&list2);
freeList(&list1);
freeList(&list2);
return 0;
}
线性表顺序存储结构的优缺点:
优点:
(1)无须为表示中元素之间的逻辑关系而增加额外的存储空间。
(2)可以快速的存储表中的任一位置的元素
缺点:
(1)插入和删除操作需要移动大量元素。
(2)当线性表长度变化较大时,难以确定存储空间的容量。
(3)造成存储空间的“碎片”。
要解决这些不足就需要使用另一种线性表的存储结构——线性表的链式存储结构。