动态顺序表+OJ

顺序表本质上就是数组，本文简易实现了动态顺序表的增，删，查，改 。

关键要学会顺序表实现的思想，顺序表非常的细，要多方面考虑。

 

//顺序表头文件
#pragma once

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
//要求：存储的数据从0开始，依次连续存储
//顺序表的本质就是数组，可以扩容的数组

//#define N 100
//typedef struct SeqList
//{
//	int a[N];
//	int size;//记录存储的数据个数
//}SeqList;
//静态的顺序表，存在缺陷


//动态顺序表
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* a;
	int size;    //存储的个数
	int capacity;//存储的容量
}SeqList;

//顺序表初始化
void SeqListInit(SeqList* psl);

//顺序表销毁
void SeqListDestroy(SeqList* psl);

//尾插
void SeqListPushBack(SeqList* psl, SLDataType x);

//尾删
void SeqListPopBack(SeqList* psl);

//头插
void SeqListPushFront(SeqList* psl, SLDataType x);

//头删
void SeqListPopFront(SeqList* psl);

//头插
void SeqListPopFront(SeqList* psl);

//打印
void SeqListPrint(SeqList* psl);

//检查是否需要扩容
void SeqListCheckCapacity(SeqList* psl);

//在pos位置插入x
void SeqListInsert(SeqList* psl, int pos, SLDataType x);

//在pos位置删除数据
void SeqListErase(SeqList* psl, int pos);

//查找
int SeqListFind(SeqList* psl, SLDataType x);

 

#include "SeqList.h"

//初始化
void SeqListInit(SeqList* psl)
{
	assert(psl);
	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}

//销毁
void SeqListDestroy(SeqList* psl)
{
	assert(psl);
	free(psl->a);
	psl->a = NULL;
	psl->capacity = psl->size = 0;
}

//检查是否需要扩容
void SeqListCheckCapacity(SeqList* psl)
{
	assert(psl);
	//如果空间不够则需要扩容
	if (psl->size == psl->capacity)
	{
		size_t newcapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		SLDataType* tmp = realloc(psl->a, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			psl->a = tmp;
			psl->capacity = (int)newcapacity;
		}
	}
}

//尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	assert(psl);
	SeqListCheckCapacity(psl);
	//空间够的情况下
	psl->a[psl->size] = x;
	psl->size++;
}

//尾删
void SeqListPopBack(SeqList* psl)
{
	assert(psl);
	//一些细节，size大于0才删，否则删到负数
	if (psl->size > 0)
	{
		psl->size--;
	}
}

//头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	assert(psl);
	SeqListCheckCapacity(psl);
	//思路：把所有元素向后移动覆盖
	size_t end = psl->size - 1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end];
		end--;
	}
	psl->a[0] = x;
	psl->size++;
}

//头删
void SeqListPopFront(SeqList* psl)
{
	assert(psl);
	if (psl->size > 0)
	{
		size_t begin = 1;
		while (begin < psl->size)
		{
			psl->a[begin - 1] = psl->a[begin];
			begin++;
		}
		psl->size--;
	}
}

//打印
void SeqListPrint(SeqList* psl)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

//在pos位置插入元素
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
	assert(psl);
	SeqListCheckCapacity(psl);
	int end = psl->size;
	while (end > pos)
	{
		psl->a[end] = psl->a[end - 1];
		end--;
	}
	psl->a[pos] = x;
	psl->size++;
}

//在pos位置删除元素
void SeqListErase(SeqList* psl, size_t pos)
{
	//把下标位置为pos的元素删除
	assert(psl);
	if (psl->size > 0)
	{
		int begin = (int)pos;
		while (begin < psl->size)
		{
			psl->a[begin] = psl->a[begin + 1];
			begin++;
		}
		psl->size--;
	}
}

//查找,找到返回下标，找不到返回-1
int SeqListFind(SeqList* psl, SLDataType x)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

 顺序表注意以下几点：

1.在写每个接口时，都要加上断言，方便查找错误

2.在增加数据（头插，尾插）时，一定要先检查是否有足够的空间，调用SeqListCheckCapacity函数

3.在删除数据（头删，尾删）时，一定要保证数组大小不能为负值

4.SeqListInsert可以取代头插，尾插；SeqListErase可以取代头删，尾删。不过要检查是否可行

 

顺序表OJ 

 

 

 方法：双指针

空间复杂度O（1）

时间复杂度O（N）

 实现：

1.src位置不是val，就放到dst位置，然后src++，dst++

2.src位置是val，src++