数据结构-顺序表接口实现及OJ详解

顺序表

顺序表介绍

：顺序表是一段物理地址连续的存储单元存储数据元素的顺序结构，一般采用数组存储数据，在数组上实现增删查改。

：顺序表分为1：静态顺序表和2：动态顺序表。

：在实际应用中数据数量是未知的，静态顺序表不够方便，在实际应用中我们需要动态内存分配，故此下面我们实现的是动态顺序表的各个接口。

结构体定义

typedef int SLDataType;
#include<stdio.h>
typedef struct SeqList
{
	SLDataType* a;
	int size;
	int capacity;
}SL;

：typedef将int替换为SLDataType,方便顺序表中元素类型的替换，比如在顺序表存储的数据类型从int转为char或者转化为long。

：定义SLDataType* a的指针是为了在对数组内容更改或者对数组扩容的时候，如果只是传参数组名，再者形参是实参的一份临时拷贝，因此无法对数组中的数据进行修改。

：定义capacity是为了检查数组数据元素是否足够，从而进行增容。

接口实现

接口集合

void SLInit(SL* psl);//初始化
void SLDestroy(SL* psl); //销毁
void SLPushBack(SL* psl, SLDataType x);//尾插
void SLPushFront(SL* psl, SLDataType x);//头插
void SLPopBack(SL* psl);//尾删
void SLPopFront(SL* psl);//头删	
void SLPrint(SL* psl);//打印
int SLFind(SL* psl,SLDataType x);//查找
void SLInsert(SL* psl, size_t pos, SLDataType x);//pos位置插入x
void SLErase(SL* psl, size_t pos, SLDataType x);//pos位置删除x
void SLModify(SL* psl, size_t pos, SLDataType x);//pos位置修改x

初始化

void SLInit(SL* psl)
{
	assert(psl);
	psl->a  = NULL;
	psl->capacity = psl->size = 0;
}

：使用指针的时候断言。

：初始化将指针置空就行，不必内容全部初始化为0。

：要保证size和capacity为0。

销毁

void SLDestroy(SL* psl)
{
	assert(psl);

	if (psl->a)
	{
		free(psl->a);
		psl->a = NULL;
		psl->capacity = psl->size = 0;

	}
}

：这里if语句可以不需要，free自身可以检查指针a是否为空指针。

检查容量

void SLCheckCapacity(SL* psl)
{
	if (psl->size == psl->capacity)
	{
		int newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(psl->a, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		psl->a = tmp;
		psl->capacity = newCapacity;
	}
}

：在开始没有数据的时候，数组数据个数可以初始化为4，当有数据且容量不够的时候，就扩2倍，扩容几倍是任意的，2倍是避免扩少了不够用，扩多了嫌多。同样的动态内存分配需要使用临时指针检查是否开辟成功，成功再给给指针a，最后把newcapacity给给capacity。

头插

void SLPushFront(SL* psl, SLDataType x)
{
	assert(psl);
	SLCheckCapacity(psl);
	int end = psl->size - 1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end];
		--end;
	}
	psl->a[0] = x;
	psl->size++;
}

：设定一个下标end

：1：所有数据往后挪动一个单位

：2：头部插入数据

因此end如果是从头开始，往后挪动数据会把后面一个数据覆盖，因此end从size-1的位置开始。

：如果开始存储了4个数据，那么将6往后挪动的时候，发生了越界行为，因此我们需要在挪动数据之前进行一次容量检查

尾插

void SLPushBack(SL* psl, SLDataType x)
{
	assert(psl);
	//检查容量
	SLCheckCapacity(psl);
	psl->a[psl->size] = x;
	psl->size++;
}

：尾插就是在已有数据末尾再添加一个数据，就是下标为size的地方添加数据即可。

头删

void SLPopFront(SL* psl)
{
	assert(psl);
	assert(psl->size > 0);
	int begin = 0;
	while (begin < psl->size - 1)
	{
		psl->a[begin] = psl->a[begin + 1];
		++begin;
	}
	--psl->size;
}

：定义一个下标begin从0的位置开始

：所有数据往前挪动一个单位

：当begin到了下标为size-2的时候，就终止循环，因此控制beginsize-1。

尾删

void SLPopBack(SL* psl)
{
	//尾删
	assert(psl);
	assert(psl->size > 0);
	psl->size--;
}

：尾删十分容易，size–即可。

查找

int SLFind(SL* psl,SLDataType x)
{
	assert(psl);	
	for (int i = 0; i < psl->size; i++)
	{

		if (psl->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

：查找只需要遍历一次数组，返回值是待查找元素的下标，为查找到返回-1。

pos位置插入

void SLInsert(SL* psl, size_t pos, SLDataType x)
{
	assert(psl);
	assert(pos <= psl->size);
	SLCheckCapacity(psl);
	size_t end = psl->size - 1;
	while (end >=pos)
	{
		psl->a[end+1] = psl->a[end];
		--end;
	}
	psl->a[pos] = x;
	++psl->size;	
}

：pos表示插入位置的下标

：pos断言<=psl->size，等于的时候表示尾插

：在pos位置插入和头插一样需要先检查容量

：定义一个下标end

：将pos以及pos之后的数据全部往后挪动一个单位

：上面的代码存在问题，规定pos是size_t，无符号整形，必定>0，因此定义end也用size_t，当pos为0的时候，end最终循环到-1跳出循环，-1对应的无符号整形是巨大的数字，因此程序陷入死循环。可以改良为下面的代码。

void SLInsert(SL* psl, size_t pos, SLDataType x)
{
	assert(psl);
	assert(pos <= psl->size);
	SLCheckCapacity(psl);
	size_t end = psl->size - 1;
	while (end >pos)
	{
		psl->a[end] = psl->a[end-1];
		--end;
	}
	psl->a[pos] = x;
	++psl->size;	
}

：这个时候while中的条件end不需要=pos。

pos位置删除

void SLErase(SL* psl, size_t pos, SLDataType x)
{
	assert(psl);	
	assert(pos < psl->size);
	size_t begin = pos;
	while (begin < psl->size - 1)
	{
		psl->a[begin] = psl->a[begin + 1];
		++begin;
	}
	--psl->size;
}

：所有pos以后的数据往前挪动一个单位

pos位置修改

void SLModify(SL* psl, size_t pos, SLDataType x)
{
	assert(psl);
	assert(pos < psl->size);
	psl->a[pos] = x;
}

顺序表OJ题

1：移除元素

思路如下：

：设定一个下标src和dest，从第一个元素开始，与val比较，不同则存储到数组中下标为dest的位置，++dest。

：src位置3!=5，3存储到dest位置，++src,++dest

：src位置4!=5，4存储到dest位置，++src,++dest

：src位置5==5，那么5不用存储，dest也不需要++，++src即可

：因此思路就是元素等于val，src位置的数据存储到dest位置，然后src和dest++，如果不等于val，src++即可。

int removeElement(int* nums, int numsSize, int val){
int src = 0,dest = 0;
while(src<numsSize)
{
    if(nums[src]!=val)
    {
        nums[dest] = nums[src];
        ++dest;
        ++src;
    }
    else
    {
        ++src;
    }
}
return dest;
}

2：删除重复项

​

：思路依然和第一题一样，使用下标src和dest，并且同时初始化为1。

：从第二个数据开始判断，设置while循环让src小于numsSize，是否与前面一个数字相等，如果不相等就把src的数据存储给dest，src和dest++，如果相等了，那就++src即可，最后返回src的值。

int removeDuplicates(int* nums, int numsSize){
int src = 1,dest = 1;
while(src<numsSize)
{
    if(nums[src] != nums[src-1])
    {
        nums[dest] = nums[src];
        ++src;
        ++dest;
    }
    else
    {
        ++src;              
    }
}
return dest;
}

3：合并2个非降序数组

：运用归并排序的思想。

：题目中说了，nums1空间足够大，那么我们可以假定为nums1的元素个数是m+n个，这一题如果从开头使用归并会将nums1中开头的数据替换掉，因此变通一下从末尾比较

：设定下标end1为m-1，end2为n-1，i为m+n-1。

：比较end1和end2的数据，大的放在i位置，–i，哪个end的大，就–哪个end

：会出现某个数组提前结束，如果是nums2，那么就没有后续操作，如果是nums1提前结束，则需要将nums2剩下的元素继续替换到nums1中i的位置。

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
int end1 = m-1,end2 = n-1;
int i = m+n-1;
while(end1>=0 && end2>=0)
{
    if(nums1[end1]> nums2[end2])
    {
        nums1[i] = nums1[end1];
        --i;
        --end1;
    }
    else if(nums1[end1] == nums2[end2])
    {
        nums1[i] = nums1[end1];
        --end1;
        --i;
    }
    else
    {
        nums1[i] = nums2[end2];
        --end2;
        --i;
    }
   
}
 while(end2>=0)
    {
        nums1[i] = nums2[end2];
        --end2;
        --i;
    }
    return nums1;
}

结尾：恢复完毕，继续日更博客！