数据结构 【顺序表】 部分功能实现

目录

1.顺序表的实现--静态分配

2.初始化一个顺序表

3.顺序表的实现--动态分配

4.增加动态数组(顺序表)的长度

5.顺序表的插入

6.顺序表的删除

7.顺序表的按位查找

         8.顺序表的按值查找

         9.部分习题

1.设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)

2.从有序顺序表中删除所有其值重复的元素，使表中的所有元素的值均不相同

3.将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表

4.线性表（a1,a2,a3,...,an）中的元素递增有序且按顺序存储于计算机内。要求设计一个算法，完成用最少最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置交换，若找不到，则将其插入表中并使表中元素仍递增有序。

---

1.顺序表的实现--静态分配

#define MaxSize 10 //定义最大长度
typedef struct
{
	ElemType data[MaxSize]; //静态数组存放元素
	int length; //顺序表当前长度
}SqList;

2.初始化一个顺序表

#define MaxSize 10 //定义最大长度
typedef struct
{
	int data[MaxSize];
	int length;
}SqList;
//基本操作，初始化一个顺序表
void InitList(SqList &L)
{
	for (int i = 0;i < MaxSize;i++)
		L.data[i] = 0;
	L.length = 0;
}

3.顺序表的实现--动态分配

#define InitSize 10 //定义顺序表初始长度
typedef struct
{
	Elemtype  *data; //指示动态分配数组的指针
	int MaxSize; //顺序表的最大容量
	int length; //顺序表的当前长度
}SeqList;

4.增加动态数组(顺序表)的长度

#include<stdlib.h>
#define InitSize 10 //定义顺序表初始长度
typedef struct
{
	int  *data; //指示动态分配数组的指针
	int MaxSize; //顺序表的最大容量
	int length; //顺序表的当前长度
}SeqList;

void InitList(SeqList &L)
{
	//用malloc函数申请一片连续的的空间
	L.data = (int*)malloc(InitSize * sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
}
//增加动态数组的长度
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; //顺序表最大长度增加len
	free(p); //释放原来的内存空间
}

int main()
{
	SeqList L;
	InitList(L);
    //往顺序表里随便插入几个元素
	IncreaseSize(L, 5);
	return 0;
}

 C++初始动态分配语句为:

L.data=new ElemType[InitSize];

5.顺序表的插入

#define MaxSize 10
typedef struct
{
	int data[MaxSize];
	int length;
}SqList;
//向顺序表中插入元素
bool ListInsert(SqList &L, int i, int e)
{
	if (i<1 || i>L.length + 1) //判断i的范围是否有效
		return false;
	if (L.length >= MaxSize) //判断存储空间是否已满
		return false;
	for (int j = L.length;j >= i;j--) //将第i个元素之后的元素后移
		L.data[j] = L.data[j - 1];
	L.data[i - 1] = e; //在i位置放入元素e
	L.length++; //长度+1
	return true;
}

ListInsert函数的参数i是位序，注意和数组下标的区分。位序=数组下标+1。

6.顺序表的删除

#define MaxSize 10
typedef struct
{
	int data[MaxSize];
	int length;
}SqList;
//删除顺序表中位序为i的元素
bool ListDelete(SqList &L, int i, int &e)
{
	if (i<1 || i>L.length) //判断i是否合法
		return false;
	e = L.data[i - 1]; //将被删除元素赋值给e
	for (int j = i;j < L.length;j++)
		L.data[j - 1] = L.data[j];
	L.length--; //线性表长度-1
	return true;
}

int main()
{
	SqList L;
	//初始化顺序表，并插入几个元素
	int e = -1; //用e把删除的元素带回来
	if (ListDelete(L, 3, e))
		cout << "已删除第三个元素,其值为 " << e << endl;
	else
		cout << "位序i不合法，删除失败。\n";
	return 0;
}

注意参数e是以引用的方式传入，因为要返回被删除的元素的值。

7.顺序表的按位查找

静态顺序表

#define MaxSize 10
typedef struct
{
	ElemType data[MaxSize];
	int length;
}SqList;

ElemType GetElem(SqList L, int i)
{
	return L.data[i - 1];
}

动态顺序表

#define InitSize 10
typedef struct
{
	ElemType *data;
	int MaxSize;
	int length;
}SeqList;

ElemType GetElem(SeqList L, int i)
{
	return L.data[i - 1];
}

8.顺序表的按值查找

以int类型为例

#define InitSize 10
typedef struct
{
	int *data;
	int MaxSize;
	int length;
}SeqList;
//按值查找
int LocateElem(SeqList L, int e)
{
	for (int i = 0;i < L.length;i++)
		if (L.data[i] == e)
			return i + 1; //返回位序
	return 0;
}

9.部分习题

1.设计一个高效算法，将顺序表L的所有元素逆置，要求算法的空间复杂度为O(1)

典型的首尾交换算法

void Reverse(SqList &L)
{
	Elemtype temp;
	for (int i = 0;i < L.length / 2;i++)
	{
		temp = L.data[i];
		L.data[i] = L.data[L.length - i - 1];
		L.data[L.length - i - 1] = temp;
	}
}

2.从有序顺序表中删除所有其值重复的元素，使表中的所有元素的值均不相同

将第一个元素与后面的元素一一比较。

bool Delete_Same(SeqList &L)
{
	if (L.length == 0)
		return false;
	int i, j;
	for (int i = 0, j = 1;j < L.length;j++)
		if (L.data[++i] != L.data[j])
			L.data[++i] = L.data[j];
	L.length = i + 1;
	return true;
}

3.将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表

将两表从小的一端开始比较取小，最后哪个表还有剩余，就将剩余部分直接添加到新表

bool Merge(SeqList A, SeqList B, SeqList &C)
{
	if (A.length + B.length > C.MaxSize)
		return false;
	int i = 0, j = 0, k = 0;
	while (i, A.length&&j < B.length)
	{
		if (A.data[i] <= B.data[i])
			C.data[k++] = A.data[i++];
		else
			C.data[k++] = B.data[j++];
	}
	while (i < A.length)
		C.data[k++] = A.data[i++];
	while (j < B.length)
		C.data[k++] = B.data[j++];
	C.length = k;
	return true;
}

4.线性表（a1,a2,a3,...,an）中的元素递增有序且按顺序存储于计算机内。要求设计一个算法，完成用最少最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置交换，若找不到，则将其插入表中并使表中元素仍递增有序。

 可用顺序查找和折半查找，题中要求最少时间，所以采用折半查找

void SearchExchangeInsert(ElemType A[], ElemType x)
{
	int low = 0, high = n - 1, mid; //low和high指向顺序表下界和上界的下标,n为数组元素个数
	while (low <= high)
	{
		mid = (low + high) / 2;
		if (A[mid] == x)
			break;
		else if (A[mid] < x)
			low = mid + 1;
		else
			high = mid - 1;
	}
	if (A[mid] == x && mid != n - 1)
	{
		 int temp = A[mid];
		A[mid] = A[mid + 1];
		A[mid + 1] = temp;
	}
	if (low > high)
	{
		for (int i = n - 1;i > high;i--)
			A[i + 1] = x;
	}
}