【数据结构2】顺序表

1.顺序表概念

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

2.顺序表结构

顺序表一般可以分为：
1.静态顺序表：使用定长度存储
2.动态顺序表：使用动态开辟的数组存储
因为静态顺序表比较简单所以在此不叙述，
动态顺序表结构：

typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SL;

定义一个结构体，存指针的大小是为了后面可以动态开辟内存空间，不会造成浪费，并记录空间的大小和已经存储的个数。

3.顺序表初始化

void SeqListIint(SL* ps)
{
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}

4.顺序表插入和删除

4.1头插

void SeqListPushFront(SL* ps, SLDateType x)
{
	CheckCapacity(ps);
	int count = ps->size;
	while (count>=0)
	{
		ps->a[count + 1] = ps->a[count];
		count--;
	}
	ps->a[0] = x;
	ps->size++;
}

步骤
1.先检查容量
2.再把原有数组往后移
3.然后把数据存进头部
4.最后size++

4.2尾插

void SeqListPushBack(SL* ps, SLDateType x)
{
	CheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

步骤
1.先检查容量
2.再把数据存进头部
3.最后size++

4.3头删

void SeqListPopFront(SL* ps)
{
	assert(ps->size > 0);
	int count = 0;
	while (count < ps->size)
	{
		ps->a[count] = ps->a[count + 1];
		count++;
	}
	ps->size--;
}

步骤
1.先判断数组是否为空
2.再把除了头部的数据往前移
3.最后size–

4.4尾删

void SeqListPopBack(SL* ps)
{
	assert(ps->size > 0);
	ps->a[ps->size] = 0;
	ps->size--;
}

步骤
1.先判断数据是否为空
2.再把数组最后一个数据置为0
3.最后size–

4.5指定位置插入

void SqeListInsert(SL* ps, int pos, SLDateType x)
{
	CheckCapacity(ps);
	int count = ps->size;
	while (count >= pos)
	{
		ps->a[count] = ps->a[count-1];
		count--;
	}
	ps->a[pos-1] = x;
	ps->size++;

}

步骤
1.先检查容量
2.再把从指定位置后的数组往后移
3.然后把数据存进指定位置
4.最后size++

4.6指定位置删除

void SeqListErase(SL* ps, int pos)
{
	assert(ps->size > 0);
	int count = pos-1;
	while (count < ps->size)
	{
		ps->a[count] = ps->a[count + 1];
		count++;
	}
	ps->size--;
}

步骤
1.先判断数组是否为空
2.再把从指定位置后的数组往前移
3.最后size–

5.顺序表打印和增容

5.1打印

void SeqListPrint(SL* ps,int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

5.2增容

void CheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDateType* pf = (SLDateType*)realloc(ps->a, newcapacity * sizeof(SLDateType));
		if (pf == NULL)
		{
			printf("realloc faile");
			exit(-1);
		}
		ps->capacity = newcapacity;
		ps->a = pf;
	}
}

步骤
1.判断空间是否已经填满
a.填满则扩容
b.没满不需要进行任何操作

6.顺序表寻找和销毁

6.1寻找

int SeqListFind(SL* ps, SLDateType x)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

步骤
1.遍历
a.如果找到返回下标
b.没有找到返回-1

6.2销毁

void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
}

完整版代码

test.c

#include "SeqList.h"
void TestSeqList1()
{
	SL s1;
	SeqListIint(&s1);
	SeqListPushBack(&s1, 1);
	SeqListPushBack(&s1, 2);
	SeqListPushBack(&s1, 3);
	SeqListPushBack(&s1, 4);
	SeqListPushBack(&s1, 5);
	SeqListPrint(&s1,s1.size);

	SeqListPopBack(&s1);
	/*SeqListPopBack(&s1);
	SeqListPopBack(&s1);
	SeqListPopBack(&s1);
	SeqListPopBack(&s1);
	SeqListPopBack(&s1);
	SeqListPopBack(&s1);
	SeqListPopBack(&s1);*/
	SeqListPrint(&s1, s1.size);

	SeqListPushFront(&s1, 40);
	SeqListPushFront(&s1, 30);
	SeqListPrint(&s1, s1.size);

	SeqListPopFront(&s1);
	SeqListPrint(&s1, s1.size);

	SqeListInsert(&s1, 1, 10);
	SeqListPrint(&s1, s1.size);

	SeqListErase(&s1, 1);
	SeqListPrint(&s1, s1.size);

	int pos = SeqListFind(&s1, 2);
	if (pos == -1)
	{
		printf("ûҵ");
	}
	else
	{
		printf("ҵ±:%d\n", pos);
	}
	
	SeqListDestory(&s1);
}
int main()
{
	TestSeqList1();
	return 0;
}

SeqList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLDateType;

typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SL;

void SeqListIint(SL* ps);
void SeqListPrint(SL* ps,int size);
void CheckCapacity(SL* ps);
void SeqListPushBack(SL* ps, SLDateType x);
void SeqListPopBack(SL* ps);
void SeqListPushFront(SL* ps, SLDateType x);
void SeqListPopFront(SL* ps);
void SeqListDestory(SL* ps);
void SqeListInsert(SL* ps, int pos, SLDateType x);
void SeqListErase(SL* ps, int pos);
int SeqListFind(SL* ps, SLDateType x);

SeqList.c

#include "SeqList.h"
void SeqListIint(SL* ps)
{
	ps->a = NULL;
	ps->capacity = 0;
	ps->size = 0;
}
void SeqListPrint(SL* ps,int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
void CheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDateType* pf = (SLDateType*)realloc(ps->a, newcapacity * sizeof(SLDateType));
		if (pf == NULL)
		{
			printf("realloc faile");
			exit(-1);
		}
		ps->capacity = newcapacity;
		ps->a = pf;
	}
}
void SeqListPushBack(SL* ps, SLDateType x)
{
	CheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}
void SeqListPopBack(SL* ps)
{
	assert(ps->size > 0);
	ps->a[ps->size] = 0;
	ps->size--;
}
void SeqListPushFront(SL* ps, SLDateType x)
{
	CheckCapacity(ps);
	int count = ps->size;
	while (count>=0)
	{
		ps->a[count + 1] = ps->a[count];
		count--;
	}
	ps->a[0] = x;
	ps->size++;
}
void SeqListPopFront(SL* ps)
{
	assert(ps->size > 0);
	int count = 0;
	while (count < ps->size)
	{
		ps->a[count] = ps->a[count + 1];
		count++;
	}
	ps->size--;
}
void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
}
void SqeListInsert(SL* ps, int pos, SLDateType x)
{
	CheckCapacity(ps);
	int count = ps->size;
	while (count >= pos)
	{
		ps->a[count] = ps->a[count-1];
		count--;
	}
	ps->a[pos-1] = x;
	ps->size++;

}
void SeqListErase(SL* ps, int pos)
{
	assert(ps->size > 0);
	int count = pos-1;
	while (count < ps->size)
	{
		ps->a[count] = ps->a[count + 1];
		count++;
	}
	ps->size--;
}
int SeqListFind(SL* ps, SLDateType x)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}