[数据结构基础]顺序表以及顺序表的尾删尾增，头删头增

顺序表的尾插尾删 头插头删

typedef struct SeqLIst

{

    SLDataType* a;

    int size;

    int capacity;

}SL，SeqList;

结构体初始化

void SeqListInit(SL* ps)

{

    ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);

    if(ps->a == NULL)

    {

        printf("申请内存失败\n");

        exit(-1);//直接结束

    }

    ps->size = 0;

    ps->capacity = 4;

}

//尾增的实现

void SeqListPushBack(SL* ps, SLDataType x)

{

    assert(ps);

    //

    if (ps->size >= ps->capacity)

    {

        ps->capacity *= 2;

        ps->a = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity);

if(ps->a == NULL)

    {

        printf("申请内存失败\n");

        exit(-1);

    }

    }

    ps->a[ps->size] = x;

    ps->size++;

   

}

首先函数确定函数参数为一个结构体和要插入的内容

如果写void SeqListPushBack(SL, SLDataType x)

只会把结构体的值传过来，也就是形参和实参的区别。

所以我们要用实参，用指针指向结构体

void SeqListPushBack(SL* ps, SLDataType x)

接着用断言函数判断ps指针是否为空

如何实现尾增呢？

直接将数组的后一位插入这个数，同时记录数组大小（size）

ps->a[ps->size]当时我基础不好，一直在想这个a[ps->size]是什么意思

后来在博客找malloc的返回值寻找到了答案：http://t.csdn.cn/07Hl9

malloc()函数其实就在内存中找一片指定大小的空间，然后将这个空间的首地址范围给一个指针变量，这里的指针变量可以是一个单独的指针，也可以是一个数组的首地址

原来malloc函数返回的是一个指针记录这个空间的首地址，可以作为一个数组

a[ps->size]意为a[4]

当我们插入一个数，数组大小会增加，如果size超过了数组容量（capacity），则需要扩容

先判断是否超过

if (ps->size >= ps->capacity)

然后用realloc在原来的空间扩容

realloc(要调整的地址，调整后该空间的大小)   返回空间首地址

那么应该扩多少空间

假设两种情况：原空间+10或原空间的平方

1. 原空间+10：如果我们要输入1w个数据那么我们可能要申请增容1k次
2. 原空间的平方：容易浪费空间或开辟新地址

所以折中，为原空间*系数（假定为2）

尾删：没什么好说的，将最后一位删除

void SeqListPopBack(SL* ps)

{

    assert(ps);

    ps->size--;

}

头插

void SeqListPushFront(SL* ps, SLDataType x)

{

    SeqListCheckCapacity(ps);

    int end = ps->size-1;

    while (end>=0)

    {

        ps->a[end + 1] = ps->a[end];

        end--;

    }

    ps->a[end] = x;

    ps->size++;

}写一个下标end，将数组从前向后移留出第一位，判断循环什么时候结束，

                                                                                                                

End减4次为0，循环结束。

Size增大要判断是否需要扩容，为了方便，把上面的扩容写一个函数

SeqListCheckCapacity(ps);

头删

思路和上面一样

void SeqListPopFront(SL* ps)

{

    SeqListCheckCapacity(ps);

    int stare = 0;

    while (stare<ps->size-1)

    {

        ps->a[stare] = ps->a[stare + 1];

        stare++;

    }

    ps->size--;

}

SeqList.h

#pragma once

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
//顺序表，有效数组在数组中必须是连续的
//静态顺序表设计（固定大小）
typedef int SLDataType;
#define N 10

typedef struct SeqLIst
{
	SLDataType* a;
	int size;
	int capacity;
}SL, SeqList;

void SeqListInit(SL* ps);
void SeqListCheckCapacity(SL* ps);

//尾插尾删 头插头删
void SeqListPushBack(SL* ps, SLDataType x);
void SeqListPopBack(SL* ps);
void SeqListPushFront(SL* ps, SLDataType x);
void SeqListPopFront(SL* ps);

SeqList.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
void SeqListCheckCapacity(SL* ps)
{
	if (ps->size >= ps->capacity)
	{
		ps->capacity *= 2;
		ps->a = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity);
		if (ps->a == NULL)
		{
			printf("申请内存失败\n");
			exit(-1);
		}
	}
}
void SeqListInit(SL* ps)
{
	/*s.size = 0;
	s.a = NULL;
	s.capacity = 0;*/

	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);
	if(ps->a == NULL)
	{
		printf("申请内存失败\n");
		exit(-1);
	}
	ps->size = 0;
	ps->capacity = 4;
}

void SeqListPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	//判断是否要扩容
	SeqListCheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;
	
}
void SeqListPopBack(SL* ps)
{
	assert(ps);
	ps->size--;
}
void SeqListPushFront(SL* ps, SLDataType x)
{
	SeqListCheckCapacity(ps);

	int end = ps->size-1;
	while (end>=0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[end] = x;
	ps->size++;

}
void SeqListPopFront(SL* ps)
{
	SeqListCheckCapacity(ps);

	int stare = 0;
	while (stare<ps->size-1)
	{
		ps->a[stare] = ps->a[stare + 1];
		stare++;
	}
	ps->size--;
}

万事开头难，相信我能坚持做下去！