C语言动态顺序表的实现

目录

（一）静态顺序表

（二）动态顺序表

顺序表是数据结构的入门，本篇文章将详细介绍动态顺序表的增删改补。我们先了解一下静态顺序表。

（一）静态顺序表

• 静态顺序表是顺序表的一种，由于静态顺序表的大小固定，很容易溢出或浪费空间，所以我们一般不用静态顺序表。
• 所有顺序表的实现都是基于数组实现的，其实顺序表是顺序表的pro版，可以装更多的数据。

  #define Typedata int //这里定义的顺序表是int类型的
  //define N 100       //这里定义顺序表的大小
  type struct SeqList
  {
      Typedata arr[N];//存储的元素
      int size;//顺序表有效元素的个数
  }SL;//重命名为SL
  

  （二）动态顺序表

• 动态顺序表相比于静态顺序表更具优势。动态顺序表的优点在于其动态，它的大小可以随时更改，不用担心溢出。
• 我们先定义一下顺序表，这里定义了一个顺序表并把顺序表的类型重命名为SL。

#define TypeData int //这里定义顺序表的类型是int类型
type struct SeqList
{
  TypeData arr;//存储顺序表
  int size;//顺序表的实际元素个数
  int capacity;//顺序表的大小
}SL;

•  顺序表的的初始化

void InitSeqList(SL* S1)
{
    assert(S1);
    S1->arr = NULL;
    S1->size = 0;
    S2->capacity = 0;
}

• 这里我们可以写一个函数，专门用来判断顺序表是否内存满了。如果满了，则内存扩大两倍，否则则进行下面的代码。我们这里还需要考虑，顺序表可能是初始化，这个时候内存也等于元素个数。以后我们每次执行可能会溢出内存的操作时都先用这个函数检测一下当前顺序表是否溢出。 

void CheakCapacity(SL* S1)
{
    assert(S1);
    if (S1->size == S1->capacity)
    {    
        int NewCapacity = S1->capacity ==0?4:2*s1->capacity;
        S1->arr = (TypeData*)malloc(sizeof(TypeData) * NewCapacity);     
    }
    
}

•  顺序表的尾插

  void SLPushBack(SL* S1, TypeData x)
  {
      assert(S1);
      CheakCapacity(S1);
      S1->arr[S1->size] = x;
      S1->size++;
  }

•  顺序表的头插

  void SLPushFront(SL* S1, TypeData x)
  {
      assert(S1);
      CheakCapacity(S1);
      for (int i = S1->size-1; i >=0; i--)
      {
          S1->arr[i+1] = S1->arr[i];
      }
      S1->arr[0] = x;
      S1->size++;
  }

•  顺序表的尾删

  void SLPopBack(SL* S1)
  {
      assert(S1 && S1->size);
      S1->size--;
  }

•  顺序表的头删

• void SqPopFront(SL* S1)
  {
  	assert(S1 && S1->size);
  	for (int i = 0; i < S1->size - 1; i++)
  	{
  		S1->arr[i] = S1->arr[i + 1];
  	}
  	S1->size--;
  }

• 顺序表的指定位置之前插入数据

  void S1Insert(SL* S1, int pos, Datatype a)
  {
  	assert(S1);
  	assert(pos >= 0 && pos <= S1->size);
  	//查看内存是否足够
  	Cheakmemory(S1);
  	for (int i = S1->size; i > pos; i--)
  	{
  		S1->arr[i] = S1->arr[i - 1];
  	}
  	S1->arr[pos] = a;
  	S1->size++;
  }

•  顺序表的指定位置之前删去数据

  void S1Erase(SL* S1, int pos)
  {
  	assert(S1);
  	assert(pos >= 0 && pos < S1->size);
  	for (int i = pos; i < S1->size - 1; i++)
  	{
  		S1->arr[i] = S1->arr[i+1];
  	}
  	S1->size--;
  }

•  顺序表的销毁

  void DestroySeqList(SL* S1)
  {
  	assert(S1);
  	free(S1->arr);
  	S1->arr = NULL;
  	S1->memory = 0;
  	S1->size = 0;
  }

•  顺序表查找指定数据

  int S1Find(SL* S1, Datatype a)
  {
  	for (int i = 0; i < S1->size; i++)
  	{
  		if (S1->arr[i] == a)
  			return i;
  	}
  	return -1;
  }

•  顺序表的指定位置之后插入数据

  void S1InsertBack(SL* S1, int pos, Datatype x)
  {
  	assert(S1);
  	assert(pos >= 0 && pos < S1->size);
  	Cheakmemory(S1);
  	for (int i = S1->size; i > pos + 1; i--)
  	{
  		S1->arr[i] = S1->arr[i - 1];
  	}
  	S1->arr[pos + 1] = x;
  	S1->size++;
  }