数据结构-线性表（顺序表）（c++版）

目录

1，顺序表的基本概念及特点：

1.1静态存储：

1.2动态存储表示

2，顺序表的基本操作（动态）

3，顺序表的应用演示：

3.1 集合的并运算，合并集合LA与LB，结果存于LA中，重复元素只留一个。

3.2 求顺序表LA与LB中公共的元素，结果存于LA中

---

1，顺序表的基本概念及特点：

1，把线性表中元素按照其逻辑顺序依次存储在一块连续的存储空间中，就得到了顺序表，它是用一维数组作为其存储结构的，其中一维数组的分配可以是静态的也可以是动态的，表中元素的逻辑顺序与物理顺序相同。

2，对于顺序表中的元素，既可以顺序访问也可以随机访问，顺序表中第i个元素存储在数组下标尾i-1的位置

3，假设顺序表A的起始存储位置是Loc(1）,第i个元素的存储位置为Loc(i),则有：

Loc(i)=Loc(1）+（i-1）*sizeof(DataType).,其中Loc(1）是首元的存储位置。

1.1静态存储：

1，在静态存储中，由于数组的大小是事先分配好的，所以说数组的空间已经固定，空间一旦占满，再向数组里面添加数据会导致数组元素溢出，程序崩溃。

#include<stdio.h>
#define MaxSize 50          //预定义顺序表最大长度
#define DataType int        //预定义顺序表元素类型
typedef struct {
	DataType data[MaxSize]; //顺序表的元素
	int length;             //顺序表的当前长度
}SeqList;                    //顺序表的类型定义

1.2动态存储表示

1，顺序表的存储空间是程序在执行过程中通过动态存储分配函数malloc动态分配的，一旦空间占满，还可以另外在分配更大的存储空间从而达到扩充数组的目的。

#pragma once
#include<stdio.h>
typedef int DataType;
#define initSize 30
typedef struct {
	DataType *data;
	int maxSize, n;
}SeqList;

2，顺序表的基本操作（动态）

void initList(SeqList &L)//初始化操作
{
	L.data = (DataType*)malloc(initSize * sizeof(DataType));
	if (!L.data) {
		printf(" is error!\n");
		exit(1);
	}
	L.maxSize = initSize;
	L.n = 0;
}
void clearList(SeqList &L)//清除顺序表操作
{
	L.n = 0;
}
int getLength(SeqList &L)//获取顺序表长度操作
{
	return L.n;
}
bool isEmpty(SeqList &L)//判断顺序表是否为空操作
{
	return L.n == 0;
}
int Search(SeqList &L, DataType x)//在顺序表中查询某个元素，成功返回元素下表，否则返回-1
{
	for (int i = 0; i <L.n; i++)
	{
		if (L.data[i] == x)
			return i;
	}
	return -1;
}
int Locate(SeqList &L, int i)//定位某个元素在顺序表中的位置，成功返回下表，否则返回-1
{
	if (i > 0 && i < L.n)
		return i - 1;
	else
		return -1;
}
bool Insert(SeqList &L, int i, DataType &x)//在顺序表的某个位置插入一个元素
{
	if (L.n == L.maxSize)//判断顺序表是否满，满的话扩大存储空间
		L.data = (DataType *)realloc(L.data, (2*initSize) * sizeof(DataType));
	if (!L.data)
		return false;
	if (i <= 0 || i>L.n + 1)//判断插入位置是否合理
		return false;
	for (int j = L.n - 1; j >= i - 1; j--)
		L.data[j + 1] = L.data[j];
	L.data[i - 1] = x;
	L.n++;
	return true;
}
bool remove(SeqList &L, int i, DataType &x)//在顺序表中删除某个元素操作
{
	if (!L.n)
		return false;
	if (i<0 || i>L.n - 1)//判断删除位置是否合理
		return false;
	x = L.data[i - 1];
	for (int j = i; j < L.n; j++)
		L.data[j - 1] = L.data[j];
	L.n--;
	return true;
}
void printList(SeqList &L)//输出顺序表中元素操作
{
	for (int j = 0; j < L.n; j++)
		printf("%d\n", L.data[j]);
}

顺序表的静态存储操作和动态存储类似，在这里就不在演示了。

3，顺序表的应用演示：

3.1 集合的并运算，合并集合LA与LB，结果存于LA中，重复元素只留一个。

void Merge(SeqList &LA, SeqList  &LB)
{
	DataType x;
	int n = getLength(LA), m = getLength(LB), i, k;
	for (i = 0; i < m; i++)//检查LB中所有元素
	{
		x = LB.data[i];//在LB中取第i个值
		k = Search(LA, x);//在LA中查找它
		if (k = -1)
		{
			Insert(LA, n, x);
			n++;
		}
	}
}

3.2 求顺序表LA与LB中公共的元素，结果存于LA中

void Intersection(SeqList &LA, SeqList &LB)
{
	int n = getLength(LA), m = getLength(LB), i, k;
	DataType x;
	while (i <= n) {
		x = LA.data[i];
		k = Search(LB, x);
		if (k = -1) {
			remove(LA, i, x);
			n--;
		}
		else
			i++;
	}
}

谢谢大家支持，欢迎各位评论指出有哪里不足！我会更加有动力坚持写下去！

分享给大家一片内容相关的博文：https://blog.csdn.net/u014134180/article/details/53907607#12-%E5%8A%A8%E6%80%81%E5%AD%98%E5%82%A8