顺序表总结以及代码实现

时间:2022-07-24
本文章向大家介绍顺序表总结以及代码实现，主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

1.顺序表概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为：

  1. 静态顺序表：使用定长数组存储。
  2. 动态顺序表：使用动态开辟的数组存储。

2.接口实现：

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

3.代码实现：

<test.h>

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

// 顺序表的动态存储
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* array; // 指向动态开辟的数组 
	size_t size; // 有效数据个数 
	size_t capicity; // 容量空间的大小 
}SeqList;

// 基本增删查改接口 
void SeqListInit(SeqList* psl, size_t capacity);
void SeqListDestory(SeqList* psl);

void CheckCapacity(SeqList* psl);
void SeqListPushBack(SeqList* psl, SLDataType x);
void SeqListPopBack(SeqList* psl);
void SeqListPushFront(SeqList* psl, SLDataType x);
void SeqListPopFront(SeqList* psl);

int SeqListFind(SeqList* psl, SLDataType x);
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
void SeqListErase(SeqList* psl, size_t pos);
void SeqListRemove(SeqList* psl, SLDataType x);
void SeqListModify(SeqList* psl, size_t pos, SLDataType x);
void SeqListPrint(SeqList* psl);

// 扩展面试题实现 
void SeqListBubbleSort(SeqList* psl);
int SeqListBinaryFind(SeqList* psl, SLDataType x);
// 本题要求：时间复杂度：O(N) 空间复杂度 O(1) 
void SeqListRemoveAll(SeqList* psl, SLDataType x);

<test.c>

#include "test.h"

//初始化
void SeqListInit(SeqList* psl, size_t capacity)
{
	assert(psl);
	if (capacity == 0)
	{
		psl->array = NULL;
		psl->size = 0;
		psl->capicity = 0;
	}
	else
	{
			psl->array = (SLDataType*)malloc(sizeof(SLDataType)*capacity);
			psl->size = 0;
			psl->capicity = capacity;
			assert(psl->array);
	}
}
//销毁
void SeqListDestory(SeqList* psl)
{
	assert(psl);
	free(psl->array);
	psl->array = NULL;
	psl->capicity = 0;
	psl->size = 0;
}
//容量检测
void CheckCapacity(SeqList* psl)
{
	if (psl->size == psl->capicity)
	{
		SLDataType* tmp;
		if (psl->capicity == 0)
		{
			psl->capicity = 2;
		}
		else
		{
			tmp = realloc(psl->array, psl->capicity * 2 * sizeof(SLDataType));
			assert(tmp);
			psl->array = tmp;
			psl->capicity *= 2;
		}
	}
}
//尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	assert(psl);
	CheckCapacity(psl);
	psl->array[psl->size] = x;
	psl->size++;
}
//尾删
void SeqListPopBack(SeqList* psl)
{
	assert(psl);
	if (psl->size > 0)
	{
		psl->size--;
	}
}
//头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	assert(psl);
	int end;
	CheckCapacity(psl);
	end = psl->size;
	while (end >= 1)
	{
		psl->array[end] = psl->array[end - 1];//注意条件，避免越界访问
		end--;
	}
	psl->array[0] = x;
	psl->size++;
}
//头删
void SeqListPopFront(SeqList* psl)
{
	assert(psl);
	if (psl->size > 0)
	{
		size_t start;
		start = psl->array[0];
		while (start < psl->size - 1)
		{
			psl->array[start] = psl->array[start + 1];
			start++;
		}
		psl->size--;
	}
}
//查找
int SeqListFind(SeqList* psl, SLDataType x)
{
	assert(psl);
	size_t i = 0;
	for (i = 0; i < psl->size; i++)
	{
		if (psl->array[i] == x)
		{
			return i;
		}
	}
	return -1;
}
//任何pos位置的插入数据
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
	int end;
	assert(psl);
	CheckCapacity(psl);
	end = psl->size - 1;
	while ((int)pos <= end)
	{
		psl->array[end + 1] = psl->array[end];
		end--;
	}
	psl->array[pos] = x;
	psl->size++;
}
//删除pos位置的数据
void SeqListErase(SeqList* psl, size_t pos)
{
	assert(psl);
	size_t start = pos;
	while (start<psl->size - 1)
	{
		psl->array[start] = psl->array[start + 1];
		start++;
	}
	psl->size--;
}
//删除指定数据
void SeqListRemove(SeqList* psl, SLDataType x)
{
	assert(psl);
	size_t  pos;
	pos = SeqListFind(psl, x);
	if (pos != -1)
	{
		SeqListErase(psl, pos);
	}
}
//修改某个位置(下标)的数据
void SeqListModify(SeqList* psl, size_t pos, SLDataType x)
{
	assert(psl);
	psl->array[pos] = x;
}
//输出顺序表
void SeqListPrint(SeqList* psl)
{
	size_t i = 0;
	assert(psl);
	for (i = 0; i < psl->size; i++)
	{
		printf("%3d ", psl->array[i]);
	}
	printf("n");
}
void SeqListBubbleSort(SeqList* psl)//冒泡排序
{
	assert(psl);
	size_t i = 0;
	size_t j = 0;
	for (i = 0; i < psl->size - 1; i++)
	{
		int flag = 0;
		for (j = 0; j < psl->size - 1 - i; j++)
		{
			if (psl->array[j]>psl->array[j + 1])
			{
				SLDataType tmp = psl->array[j + 1];
				psl->array[j + 1] = psl->array[j];
				psl->array[j] = tmp;
				flag = 1;
			}
		}
		if (0 == flag)
		{
			return;
		}
	}
}

int BinarySearch(SeqList* psl, SLDataType x)//二分查找
{
	assert(psl);
	int left = 0;
	int right = psl->size - 1;
	while (left <= right)
	{
		SLDataType mid = left + (right - left);
		if (psl->array[mid] < x)
		{
			left = mid + 1;
		}
		else if (psl->array[mid] > x)
		{
			right = mid - 1;
		}
		else
		{
			return mid;
		}
	}
	return 0;
}

void SeqListRemoveAll(SeqList* psl, SLDataType x)//要求时间复杂度是O(N) 空间复杂度O(1)
{
	assert(psl);
	SLDataType ret = 0;
	size_t i = 0;
	while (i < psl->size - 1)
	{
		ret = SeqListFind(psl, x);
		if (ret != -1)
		{
			SeqListRemove(psl, x);
		}
		i++;
	}
}







void TestSeqList()
{
	SeqList sl;
	SeqListInit(&sl, 10);

	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 9);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 6);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 7);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 8);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);

	SeqListPopBack(&sl);
	SeqListPrint(&sl);

	SeqListPushFront(&sl, 0);
	SeqListPrint(&sl);

	SeqListPopFront(&sl);
	SeqListPrint(&sl);

	SeqListFind(&sl, 4);
	SeqListInsert(&sl, 2, 6);
	SeqListPrint(&sl);

	SeqListErase(&sl, 3);
	SeqListPrint(&sl);

	SeqListModify(&sl, 1, 7);
	SeqListPrint(&sl);

	SeqListRemove(&sl, 7);
	SeqListPrint(&sl);

	SeqListBubbleSort(&sl);
	SeqListPrint(&sl);

	printf("%dn", BinarySearch(&sl, 2));

	SeqListRemoveAll(&sl, 6);
	SeqListPrint(&sl);

}



int main()
{
	TestSeqList();
	system("pause");
	return 0;
}

随机文章
本站知识点必读
最近更新