C语言顺序表及其基本功能实现

顺序表

采用顺序存储结构的线性表通常称为顺序表。
顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
即逻辑上相邻，物理上也相邻。

顺序表的结点建立

typedef int SLDataType;
//将数据类型设置为SLDataType;如果要该类型为double那么只要在这里将int 改为double即可。
typedef struct SeqList
{
	SLDataType* array;  // 指向动态开辟的数组
	size_t size ;       // 有效数据个数 
	size_t capicity ;   // 容量空间的大小
}SeqList;

要实现的基本功能有：

void SeqListInit(SeqList* ps, size_t capacity); //初始化
void SeqListDestory(SeqList* ps);//销毁

void CheckCapacity(SeqList* ps); //检查容量
void SeqListPushBack(SeqList* ps, SLDataType x);//尾插
void SeqListPopBack(SeqList* ps); 
void SeqListPushFront(SeqList* ps, SLDataType x);//头插
void SeqListPopFront(SeqList* ps);

int SeqListFind(SeqList* ps, SLDataType x);//查找
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x);//位置插入
void SeqListErase(SeqList* ps, size_t pos);//位置删除
void SeqListRemove(SeqList* ps, SLDataType x);//数据删除
void SeqListRemoveAll(SeqList* ps, SLDataType x);//数据全部删除
void SeqListModify(SeqList* ps, size_t pos, SLDataType x);//数据修改
void SeqListPrint(SeqList* ps);//输出

void SeqListBubbleSort(SeqList* psl);//冒泡排序
int SeqListBinaryFind(SeqList* ps, SLDataType x);//二分查找

下面开始实现

顺序表的建立

SeqList psL;

然后调用初始化函数

SeqListInit(&psL, 4);

即可申请出一个有4个容量的顺序表

void SeqListInit(SeqList* ps, size_t capacity)//初始化
{
	assert(ps && capacity > 0);

	ps->array = (SLDataType*)malloc(capacity * sizeof(SLDataType));
	if (ps->array != NULL)
	{
		for (size_t i = 0; i < capacity; i++)
		{
			ps->array[i] = 0;
		}
		ps->size = 0;
		ps->capicity = capacity;
	}
	
}
void SeqListDestory(SeqList* ps)//销毁
{
	assert(ps);

	free(ps->array);
	ps->size = 0;
	ps->capicity = 0;
}

void CheckCapacity(SeqList* ps)//检查当前容量
{
	assert(ps);
	if (ps->size == ps->capicity)//如果当前存储个数和总容量相同，那么就是满了，要扩容
	{
		SeqList p;
		//(&p)->array等于p.array
		p.array = (SLDataType*)realloc(ps->array, 2 * ps->capicity * sizeof(SLDataType));
		if ((&p)->array != NULL)//这里是防止扩容失败返回空指针而破坏原来的内存数据；
		{
			ps->array = (&p)->array;
			ps->capicity *= 2;
		}
	}
}

头插法和尾插法

void SeqListPushBack(SeqList* ps, SLDataType x)//尾插
{
	assert(ps);
	CheckCapacity(ps);
	ps->array[ps->size] = x;
	ps->size++;
}
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	ps->size--;
}
void SeqListPushFront(SeqList* ps, SLDataType x)//头插
{
	assert(ps);
	CheckCapacity(ps);
	for (size_t i = ps->size; i >0; i--)
	{
		ps->array[i] = ps->array[i - 1];
	}
	ps->array[0] = x;
	ps->size++;
}
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	for (size_t i = 0; i < ps->size-1; i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}

找

int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps);
	for (size_t i = 0; i <= ps->size; i++)
	{
		if (ps->array[i]==x)
		{
			return i;
		}
	}
	return -1;
}

改

void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	for (size_t i = ps->size; i > pos; i--)
	{
		ps->array[i] = ps->array[i - 1];
	}
	ps->array[pos] = x;
	ps->size++;
}
void SeqListModify(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	
	ps->array[pos] = x;

}

删

void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	for (size_t i = pos; i <ps->size; i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}
void SeqListRemove(SeqList* ps, SLDataType x)
{
	assert(ps);
	int pos = (int)SeqListFind(ps, x);;
	SeqListErase(ps, pos);
}
void SeqListRemoveAll(SeqList* ps, SLDataType x)
{
	assert(ps);

	int pos = SeqListFind(ps, x);
	while (pos>=0)
	{
		SeqListErase(ps, (size_t)pos);
		pos = SeqListFind(ps, x);
	}
}

void SeqListPrint(SeqList* ps)//输出
{
	for (size_t i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->array[i]);
	}
	printf("\n");
}

排序（冒泡法）和查找

void SeqListBubbleSort(SeqList* ps)
{
	int true = 0;
	for (size_t i = ps->size-1; i > 0; i--)
	{
		for (size_t j = 0; j < i; j++)
		{
			if (ps->array[j] > ps->array[j + 1])
			{
				SLDataType tmp = ps->array[j];
				ps->array[j] = ps->array[j + 1];
				ps->array[j + 1] = tmp;
				true = 1;
			}
		}
		if (true == 0)
		{
			break;
		}
	}
}

/*二分法查找*/
int SeqListBinaryFind(SeqList * ps,SLDataType x)
{
	size_t begin = 0, end = ps->size - 1;
	while (begin <= end)
	{
		size_t pos = (begin + end) / 2;
		if (x < ps->array[pos])
		{
			end = pos-1;
		}
		else if (x > ps->array[pos])
		{
			begin = pos+1;
		}
		else
		{
			return pos;
		}
	}
	return -1;
}