1.初始化线性表L,即进行动态存储空间分配并置L为一个空表
2.清除线性表L中的所有元素,释放存储空间,使之成为一个空表
3.返回线性表L当前的长度,若L为空则返回0
4.判断线性表L是否为空,若为空则返回1, 否则返回0
5.返回线性表L中第pos个元素的值,若pos超出范围,则停止程序运行
6.顺序扫描(即遍历)输出线性表L中的每个元素
7.从线性表L中查找值与x相等的元素,若查找成功则返回其位置,否则返回-1
8.把线性表L中第pos个元素的值修改为x的值,若修改成功返回1,否则返回0
9.向线性表L的表头插入元素x
10.向线性表L的表尾插入元素x
11.向线性表L中第pos个元素位置插入元素x,若插入成功返回1,否则返回0
12.向有序线性表L中插入元素x, 使得插入后仍然有序
13.从线性表L中删除表头元素并返回它,若删除失败则停止程序运行
14.从线性表L中删除表尾元素并返回它,若删除失败则停止程序运行
15.从线性表L中删除第pos个元素并返回它,若删除失败则停止程序运行
16.从线性表L中删除值为x的第一个元素,若成功返回1,失败返回0 */
/*
#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;
typedef int elemType;
struct List
{
elemType *list;
int size;
int maxsize;
};
//进行内存的重新分配!
void againMalloc(struct List *L)
{
elemType *p = (elemType *)realloc(L->list, 2 * L->maxsize * sizeof(elemType));
if (!p){
cout << "内存分配失败!" << endl;
exit(1);
}
L->list = p;
L->maxsize = 2 * L->maxsize;
}
//1.初始化线性表L,即进行动态存储空间分配并置L为一个空表
void initList(struct List *L, int ms)
{
if (ms < 0){
cout << "非法分配内存!" << endl;
exit(1);
}
L->list = (elemType *)malloc(ms * sizeof(elemType));
L->size = 0;
L->maxsize = ms;
return ;
}
//2.清除线性表L中的所有元素,释放存储空间,使之成为一个空表
void clearList(struct List *L)
{
if (L->list){
free(L->list);
L->list = NULL;
L->size = 0;
}
return ;
}
//3.返回线性表L当前的长度,若L为空则返回0
int sizeList(struct List *L)
{
return L->size;
}
//4.判断线性表L是否为空,若为空则返回1, 否则返回0
int emptyList(struct List *L)
{
if (L->size == 0)
return 1;
else
return 0;
}
//5.返回线性表L中第pos个元素的值,若pos超出范围,则停止程序运行
elemType getElem(struct List *L, int pos)
{
if (pos < 1 || pos > L->size){
cout << "数组越界!" << endl;
exit(1);
}
return L->list[pos-1];
}
//6.顺序扫描(即遍历)输出线性表L中的每个元素
void traverseList(struct List *L)
{
int i;
for (i = 0; i < L->size; i++){
cout << L->list[i] << " ";
}
cout << endl;
return ;
}
//7.从线性表L中查找值与x相等的元素,若查找成功则返回其位置,否则返回-1
int findList(struct List *L, elemType x)
{
int i;
for (i = 0; i < L->size; i++){
if (x == L->list[i])
return i;
}
return -1;
}
//8.把线性表L中第pos个元素的值修改为x的值,若修改成功返回1,否则返回0
int updatePosList(struct List *L, int pos, elemType x)
{
if (pos < 1 || pos > L->size){
cout << "元素号越界!" << endl;
return 0;
}
L->list[pos-1] = x;
return 1;
}
//9.向线性表L的表头插入元素x
void insertFirstList(struct List *L, elemType x)
{
int i;
if (L->size == L->maxsize)
againMalloc(L);
for (i = L->size-1; i >= 0; i--)
L->list[i+1] = L->list[i];
L->list[0] = x;
L->size++;
return ;
}
//10.向线性表L的表尾插入元素x
void insertLastList(struct List *L, elemType x)
{
if (L->size == L->maxsize)
againMalloc(L);
L->list[L->size] = x;
L->size++;
return ;
}
//11.向线性表L中第pos个元素位置插入元素x,若插入成功返回1,否则返回0
int insertPosList(struct List *L, int pos, elemType x)
{
int i;
if (pos < 1 || pos > L->size){
cout << "元素号越界!" << endl;
return 0;
}
if (L->size == L->maxsize)
againMalloc(L);
for (i = L->size - 1; i >= pos - 1; i--){
L->list[i+1] = L->list[i];
}
L->list[pos-1] = x;
L->size++;
return 1;
}
//12.向有序线性表L中插入元素x, 使得插入后仍然有序
void insertOrderList(struct List *L, elemType x)
{
if (L->size == L->maxsize)
againMalloc(L);
int i, j;
for (i = 0; i < L->size; i++){
if (x > L->list[i])
break;
}
for (j = L->size - 1; j >= i; j--)
L->list[j+1] = L->list[j];
L->list[i] = x;
L->size++;
return ;
}
//13.从线性表L中删除表头元素并返回它,若删除失败则停止程序运行
void deleteFirstList(struct List *L)
{
elemType temp;
if (L->size == 0){
cout << "线性表为空,不能进行删除操作!" << endl;
exit(1);
}
temp = L->list[0];
for (int i = 1; i < L->size; i++){
L->list[i-1] = L->list[i];
}
L->size--;
return ;
}
//14.从线性表L中删除表尾元素并返回它,若删除失败则停止程序运行
void deleteLastList(struct List *L)
{
elemType temp;
if (L->size == 0){
cout << "线性表为空,不能进行删除操作!" << endl;
exit(1);
}
temp = L->list[L->size-1];
L->size--;
return ;
}
//15.从线性表L中删除第pos个元素并返回它,若删除失败则停止程序运行
void deletePosList(struct List *L, int pos)
{
if (pos < 1 || pos > L->size){
cout << "元素号越界,不能进行删除操作!" << endl;
exit(1);
}
elemType temp;
temp = L->list[pos-1];
for (int i = pos; i < L->size; i++){
L->list[i-1] = L->list[i];
}
L->size--;
return ;
}
//16.从线性表L中删除值为x的第一个元素,若成功返回1,失败返回0
int deleteValueList(struct List *L, elemType x)
{
int i, j;
for (i = 0; i < L->size; i++){
if (L->list[i] == x)
break;
}
if (i == L->size)
return 0;
for (j = i + 1; j < L->size; j++)
L->list[j-1] = L->list[j];
L->size--;
return 1;
}
int main()
{
int a[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
int i;
struct List L;
initList(&L, 5);
for (i = 0; i < 10; i++){
insertFirstList(&L, a[i]);
}
insertOrderList(&L, 17);
traverseList(&L);
clearList(&L);
initList(&L, 5);
for (i = 0; i < 10; i++){
insertLastList(&L, a[i]);
}
updatePosList(&L, 3, 100);
traverseList(&L);
int pos = findList(&L, 20);
cout << pos << endl;
insertPosList(&L, 5, -1);
deleteFirstList(&L);
deleteLastList(&L);
deletePosList(&L, 2);
deleteValueList(&L, 16);
traverseList(&L);
system("pause");
}
线性表的顺序存储结构的实现
最新推荐文章于 2022-09-25 20:04:54 发布