【数据结构】顺序表各个接口的实现

 

• 概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表一般可以分为:
1.静态顺序表:使用定长数组存储
2.动态顺序表:使用动态开辟的数组存储

• 接口的实现

因为静态顺序表是定长的，不具有空间增容的功能，且静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了,空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小,所以就以动态增长的顺序表为例，实现它的各个接口：

代码如下：

• <SeqList.h>

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

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


typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* _a;//数组
	size_t _size;//有多少个数据
	size_t _capacity;//容量
}SeqList;

void CheckCapacity(SeqList* psl);//容量检测
void SeqListInit(SeqList* psl, size_t capacity);//初始化
void SeqListDestory(SeqList* psl);//销毁

void SeqListPushBack(SeqList* psl, SLDataType x);//尾上插入数据
void SeqListPopBack(SeqList* psl);//尾上删除数据
void PushFront(SeqList* psl,SLDataType x);//头部插入数据
void PopFront(SeqList* psl);//删除头部数据

int SeqListFind(SeqList* psl, SLDataType x);//O(N)//寻找某个指定的值
void SeqAt(SeqList* pSeq, size_t pos, 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 TestSeqList();

void SeqListBubbleSort(SeqList* psl);
int BinarySearch(SeqList* psl, SLDataType x);
void SeqListRemoveAll(SeqList* psl, SLDataType x);

#endif//__SEQLIST_H__

• <SeqList.c>

#include "SeqList.h"

void SeqListInit(SeqList* psl, size_t capacity)//初始化
{
	assert(psl);
	if (capacity == 0)
	{
		psl->_a = NULL;
		psl->_size = 0;
		psl->_capacity = 0;
	}
	else
	{
		psl->_a = (SLDataType*)malloc(sizeof(SLDataType)*capacity);
		psl->_size =0;
		psl->_capacity = capacity;
		assert(psl->_a);
	}
}

void SeqListDestory(SeqList* psl)//销毁
{
	assert(psl);
	free(psl->_a);
	psl->_a = NULL;
	psl->_size = 0;
	psl->_capacity = 0;
}
void CheckCapacity(SeqList* psl)//容量检测
{
	if (psl->_size == psl->_capacity)
	{
		SLDataType* tmp;
		if (psl->_capacity == 0)
		{
			psl->_capacity = 2;
		}
		else
		{
			tmp = realloc(psl->_a, psl->_capacity * 2 * sizeof(SLDataType));
			assert(tmp);
			psl->_a = tmp;
			psl->_capacity *= 2;
		}
	}
}

void SeqListPushBack(SeqList* psl, SLDataType x)//尾上插入数据
{
	//直接实现
	assert(psl);
	CheckCapacity(psl);
	psl->_a[psl->_size] = x;
	psl->_size++;
	//SeqListInsert(psl,psl->_size,x);
}

void SeqListPopBack(SeqList* psl)//尾上删除数据
{
	assert(psl);
	if (psl->_size > 0)
	{
		psl->_size--;
	}
	//SeqListErase(psl, psl->_size - 1);
}

void PushFront(SeqList* psl, SLDataType x)//头部插入数据
{
	assert(psl);
	int end;
	CheckCapacity(psl);
	end = psl->_size;
	while (end >=1)
	{
		psl->_a[end] = psl->_a[end-1];//注意条件，避免越界访问
		end--;
	}
	psl->_a[0] = x;
	psl->_size++;
	//SeqListInsert(psl,0,x);
}

void PopFront(SeqList* psl)//删除头部数据
{
	//直接删除
	assert(psl);
	if (psl->_size > 0)
	{
		size_t start;
		start = psl->_a[0];
		while (start < psl->_size-1)
		{
			psl->_a[start] = psl->_a[start + 1];
			start++;
		}
		psl->_size--;
	}
	//SeqListErase(psl, 0);
}

int SeqListFind(SeqList* psl, SLDataType x)//O(N)
{
	assert(psl);
	size_t i = 0;
	for (i = 0; i < psl->_size; i++)
	{
		if (psl->_a[i]==x)
		{
			/*printf("%3d\n",i);*/
			return i;
		}
	}
	return -1;
}

void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)//任何位置的插入数据
{
	int end;
	assert(psl);
	CheckCapacity(psl);
	end = psl->_size - 1;
	while ((int)pos <= end)
	{
		psl->_a[end + 1] = psl->_a[end];
		end--;
	}
	psl->_a[pos] = x;
	psl->_size++;
}

void SeqListErase(SeqList* psl, size_t pos)//删除任意位置(下标)的数据
{
	assert(psl);
	size_t start=pos;
	while (start<psl->_size-1)
	{
		psl->_a[start] = psl->_a[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->_a[pos] = x;
}

void SeqListPrint(SeqList* psl)
{
	size_t i = 0;
	assert(psl);
	for (i = 0; i < psl->_size; i++)
	{
		printf("%3d ", psl->_a[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->_a[j]>psl->_a[j + 1])
			{
				SLDataType tmp = psl->_a[j+1];
				psl->_a[j + 1] = psl->_a[j];
				psl->_a[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->_a[mid] < x)
		{
			left = mid+1;
		}
		else if (psl->_a[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++;
	}
}

• <test.c>

#include "SeqList.h"


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

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);

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

	PopFront(&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("%d\n",BinarySearch(&sl,2));
	
	SeqListRemoveAll(&sl, 6);
	SeqListPrint(&sl);
	
}