顺序表的实现以及力扣练习题

目录

线性表

顺序表

顺序表的实现

顺序表的初始化

顺序表的销毁

顺序表的打印

顺序表检查是否要扩容

顺序表的尾插

顺序表的头插

顺序表的尾删

顺序表的头删

顺序表的查找

顺序表在pos位置插入x

顺序表删除pos位置的值

顺序表修改pos位置的值

顺序表的缺陷

力扣练习题

Leetcode27.移除元素

Leetcode26.删除有序数组中的重复项

Leetcode88.合并两个有序数组

Leetcode189.旋转数组

---

线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串等等

线性表在逻辑上是线性结构的，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

顺序表

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

顺序表一般分为：

1.静态顺序表：使用定长数组存储元素

2.动态顺序表：使用动态开辟的数组存储

了解了线性表与顺序表之后，下面我们就来实现以下动态顺序表吧。 

顺序表的实现

函数接口的声明

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;

//动态顺序表
typedef struct Seqlist
{
	SLDataType *a;
	int  sz;//表示数组中存储了多少个数据
	int  capacity;//表示数组实际能存储的空间容量
}SL;

//初始化
void SeqlistInit(SL* ps);

//顺序表的打印
void SeqlistPrint(SL* ps);

//顺序表的销毁
void SeqlistDestory(SL* ps);

//尾插
void SeqlistPushBack(SL*ps, SLDataType x);

//头插
void SeqlistPushFront(SL*ps, SLDataType x);

//尾删
void SeqlistPopBack(SL*ps);

//头删
void SeqlistPopFront(SL*ps);

//顺序表查找
int SeqlistFind(SL*ps, SLDataType x);

//顺序表检查是否要扩容
void SeqlistCheck(SL*ps);

//顺序表在pos位置插入x
void SeqlisInsert(SL*ps, int pos, SLDataType x);

//顺序表删除pos位置的值
void SeqlistErase(SL*ps, int pos);

//顺序表修改pos位置的值
void SeqlistModify(SL*ps, int pos, SLDataType x);

函数接口的实现:

#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"

//顺序表检查是否要扩容
void SeqlistCheck(SL*ps)
{
	if (ps->sz == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
		//当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
		if (temp == NULL)
		{
			printf("realloc failed\n");
			exit(-1);
		}
		//扩容成功
		else
		{
			ps->a = temp;
			ps->capacity = newcapacity;
		}
	}
}

//初始化的实现
void SeqlistInit(SL* ps)
{
	ps->a = NULL;
	ps->sz = ps->capacity = 0;
}

//顺序表的打印
void SeqlistPrint(SL* ps)
{
	int i = 0;
	for (i = 0; i < ps->sz; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

//顺序表的销毁
void SeqlistDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->a = 0;
	ps->capacity = 0;
}

//尾插的实现
void SeqlistPushBack(SL*ps, SLDataType x)
{
	assert(ps);
	//如果空间不够或者空间为0时，就得扩容
	SeqlistCheck(ps);
	//if (ps->sz == ps->capacity)
	//{
	//	int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	//	SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
	//	//当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
	//	if (temp == NULL)
	//	{
	//		printf("realloc failed\n");
	//		exit(-1);
	//	}
	//	//扩容成功
	//	else
	//	{
	//		ps->a = temp;
	//		ps->capacity = newcapacity;
	//	}
	//}
	//假如空间足够，那么我们直接往后插入
	ps->a[ps->sz] = x;
	ps->sz++;//顺序表有效元素个数+1
}

//头插的实现
void SeqlistPushFront(SL*ps, SLDataType x)
{
	assert(ps);
	//当空间不够的时候就扩容
	SeqlistCheck(ps);
	//if (ps->sz == ps->capacity)
	//{
	//	int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	//	SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
	//	//当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
	//	if (temp == NULL)
	//	{
	//		printf("realloc failed\n");
	//		exit(-1);
	//	}
	//	//扩容成功
	//	else
	//	{
	//		ps->a = temp;
	//		ps->capacity = newcapacity;
	//	}
	//}
	//当空间足够的时候，头插的话得向后挪并且是从后往前挪，从前往后会造成覆盖达不到效果
	int end = ps->sz-1;
	while (end>=0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->sz++;//顺序表有效元素个数+1

}

//尾删的实现
void SeqlistPopBack(SL*ps)
{
	assert(ps);
    assert(ps->sz > 0);
	ps->sz--;//顺序表有效元素个数-1
}

//头删的实现
void SeqlistPopFront(SL*ps)
{
	assert(ps);
    assert