程序员成长之旅——顺序表

简介

静态顺序表是只适用于我们已经了解到需要存多少数据，而一般我们都是用动态顺序表，下面我给大家展示一下我所实现的动态顺序表的代码。

代码实现

Seqlist.h

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<memory.h>
#include<malloc.h>
//顺序表的静态存储
//#define N 100
typedef int SLDataType;
//
//typedef struct Seqlist
//{
//	SLDataType array[N];//定长数组
//	size_t size;  //有效数据的个数
//}Seqlist;
//顺序表的动态存储
typedef struct Seqlist
{
	SLDataType* array;//指向动态开辟的数组
	size_t size;//有效数据的个数
	size_t capicity;//容量空间的大小
}Seqlist;

void SeqlistInit(Seqlist* psl);
void SeqlistDestory(Seqlist* psl);
void CheckCapicity(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);
void SeqlistRemoveAll(Seqlist* psl, SLDataType x);

Seqlist.c

#include"Seqlist.h"
//顺序表的初始化
void SeqlistInit(Seqlist* psl)
{
	assert(psl);
	psl->array = (SLDataType*)malloc(sizeof(SLDataType)*10);
	if (NULL == psl->array)
	{
		assert(0);
		return;
	}
	psl->capicity = 10;
	psl->size = 0;
}
//释放顺序表
void SeqlistDestory(Seqlist* psl)
{
	assert(psl);
	if (psl->array)
	{
		free(psl->array);
			psl->array = NULL;
			psl->capicity = 0;
			psl->size = 0;
	}
}
//检查顺序表，看是否需要扩容
void CheckCapicity(Seqlist* psl)
{
	assert(psl);
	if (psl->capicity == psl->size)
	{
		int newCapicity = psl->capicity * 2;
		SLDataType* pTmp = (SLDataType*)malloc(sizeof(SLDataType)*newCapicity);
		if (NULL == pTmp)
		{
			assert(0);
			return;
		}
		memcpy(pTmp, psl->array, psl->size * sizeof(SLDataType));
		free(psl->array);
		psl->array = pTmp;
		psl->capicity = newCapicity;	
	}
}
//尾插
void SeqlistPushBack(Seqlist* psl, SLDataType x)
{
	assert(psl);
	CheckCapicity(psl);
	psl->array[psl->size] = x;
	psl->size++;
}
//尾删
void SeqlistPopBack(Seqlist* psl)
{
	assert(psl);
	psl->size--;
}
//头插
void SeqlistPushFront(Seqlist* psl, SLDataType x)
{
	int i = 0;
	assert(psl);
	CheckCapicity(psl);
	for (i = psl->size-1; i >= 0; i--)
	{
		psl->array[i + 1] = psl->array[i];
	}
	psl->array[0] = x;
	psl->size++;
}
//头删
void SeqlistPopFront(Seqlist* psl)
{
	int i = 0;
	assert(psl);
	for (i = 0; i < psl->size; i++)
	{
		psl->array[i] = psl->array[i+1];
	}
	psl->size--;
}
//查找某个元素
int SeqlistFind(Seqlist* psl, SLDataType x)
{
	int i = 0;
	assert(psl);
	for ( i = 0; i < psl->size; i++)
	{
		if (x == psl->array[i])
		{
			return i;
		}
	}
	return -1;
}
//在某个位置插入一个元素
void SeqlistInsert(Seqlist* psl, size_t pos, SLDataType x)
{
	int i = 0;
	assert(psl);
	CheckCapicity(psl);
	for (i = pos; i < psl->size; i++)
	{
		psl->array[i + 1] = psl->array[i];
	}
	psl->array[pos] = x;
	psl->size++;
}
//在某个位置删除一个元素
void SeqlistErase(Seqlist* psl, size_t pos)
{
	int i = 0;
	assert(psl);
	for (i = pos; i < psl->size; i++)
	{
		psl->array[i] = psl->array[i + 1];
	}
	psl->size--;
}
//移除一个数
void SeqlistRemove(Seqlist* psl, SLDataType x)
{
	assert(psl);
	SeqlistErase(psl, SeqlistFind(psl, x));
}
//在某个位置更改一个数
void SeqlistModify(Seqlist* psl, size_t pos, SLDataType x)
{
	assert(psl);
	psl->array[pos] = x;
}
//展示顺序表
void Seqlistprint(Seqlist* psl)
{
	int i = 0;
	assert(psl);
	if (psl->size == 0)
	{
		printf("NULL\n");
		return;
	}
	for (i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->array[i]);
	}
	printf("\n");
}
//冒泡排序
void SeqlistBubbleSort(Seqlist* psl)
{
	int i = 0;
	int j = 0;
	int count = 0;
	assert(psl);
	for (i = 0; i < psl->size-1; i++)
	{
		count = 0;
		for (j = 0; j < psl->size - i - 1; j++)
		{
			if (psl->array[j] > psl->array[j + 1])
			{
				int tmp = psl->array[j];
				psl->array[j] = psl->array[j + 1];
				psl->array[j + 1] = tmp;
				count = 1;
			}
			if (count == 0)
			{
				break;
			}
		}
	}
}
//二分查找(时间复杂度：O(N) 空间复杂度 O(1))(只能是非递归)
int SeqlistBinaryFind(Seqlist* psl,SLDataType x)
{
	int mid = 0;
	int left = 0;
	int right = psl->size-1;
	while (left<=right)
	{
		mid = left + (right - left) / 2;
		if (psl->array[mid] < x)
		{
			left = mid + 1;
		}
		else if (psl->array[mid] > x)
		{
			right = mid - 1;
		}
		else if(psl->array[mid] == x)
		{
			return mid;
		}
	}
	return -1;
}
//移除相同的一个数字
void SeqlistRemoveAll(Seqlist* psl, SLDataType x)
{
	assert(psl);
	int count = 0;
	for (int i = 0; i < psl->size; i++)
	{
		if (psl->array[i] == x)
		{
			count++;
		}
		else
		{
			psl->array[i - count] = psl->array[i];
		}
	}
	psl->size -= count;

test.c

#include"Seqlist.h"
void menu()
{
	printf("****************************************************\n");
	printf("*****1. 尾插       *********2.   尾删        *******\n");
	printf("*****3. 头插       *********4.   头删        *******\n");
	printf("*****5. 查找       *********6.   插入        *******\n");
	printf("*****7. 删除       *********8.   移除        *******\n");
	printf("*****9. 替换       *********10.  释放        *******\n");
	printf("*****11.冒泡排序   *********12.  二分查找    *******\n");
	printf("*****13.移除相同   ********* 0.   exit       *******\n");
	printf("****************************************************\n");

}
void test()
{
	int input = 0;
	size_t ret = 0;
	size_t pos = 0;
	SLDataType x = 0;
	Seqlist psl;
	SeqlistInit(&psl);
	Seqlistprint(&psl);
	do
	{
		menu();
		printf("请选择:> ");
		scanf_s("%d", &input);
		switch (input)
		{
		case 1:
			{
				printf("请选择要插入的数:> ");
				scanf_s("%d", &x);
				SeqlistPushBack(&psl, x);
				Seqlistprint(&psl);
				break;
			}
		case 2:
			{
				SeqlistPopBack(&psl);
				Seqlistprint(&psl);
				break;
			}
		case 3:
			{
				printf("请选择要插入的数:> ");
				scanf_s("%d", &x);
				SeqlistPushFront(&psl, x);
				Seqlistprint(&psl);
				break;
			}
		case 4:
			{
				SeqlistPopFront(&psl);
				Seqlistprint(&psl);
				break;
			}
		case 5:
			{
				printf("请输入要查找的数:>");
				scanf_s("%d", &x);
				ret = SeqlistFind(&psl,x);
				printf("%d\n", ret);
				break;
			}
		case 6:
			{
				printf("请输入插入的位置和插入的数:>");
				scanf_s("%d %d", &pos, &x);
				SeqlistInsert(&psl, pos, x);
				Seqlistprint(&psl);
				break;
			}
		case 7:
			{
				printf("请输入删除的位置:>");
				scanf_s("%d", &pos);
				SeqlistErase(&psl, pos);
				Seqlistprint(&psl);
				break;
			}
		case 8:
			{
				printf("请输入要移除的数:>");
				scanf_s("%d", &x);
				SeqlistRemove(&psl, x);
				Seqlistprint(&psl);
				break;
			}
		case 9:
			{
				printf("请输入更改的位置和更改的数:>");
				scanf_s("%d %d", &pos, &x);
				SeqlistModify(&psl, pos, x);
				Seqlistprint(&psl);
				break;
			}
		case 10:
			{
				SeqlistDestory(&psl);
				Seqlistprint(&psl);
				break;
			}
		case 11:
		{
			Seqlistprint(&psl);
			SeqlistBubbleSort(&psl);
			Seqlistprint(&psl);
			break;
		}
		case 12:
		{
			printf("请输入要查找的数:>");
			scanf_s("%d", &x);
			ret = SeqlistBinaryFind(&psl,x);
			printf("%d\n", ret);
			break;
		}
		case 13:
		{
			printf("请输入要移除的数:>");
			scanf_s("%d", &x);
			SeqlistRemoveAll(&psl, x);
			Seqlistprint(&psl);
			break;
		}
		case 0:
		{
			return 0;
		}
		default:
			printf("选择有误！请重新选择！\n");
			break;
		}
	} while (input);
}
int main()
{
	test();
	system("pause");
	return 0;
}

运行效果