动态顺序表的代码实现以及与静态代码的区别



//动态顺序表
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>

#define MAX 1
typedef int DataType;
typedef struct SeqList
{
 DataType *data;
 int sz;
 int Capacity;
}SeqList, *pSeqList;

void InitSeqList(pSeqList ps)//初始化
{
 ps->sz = 0;
 ps->data= (DataType*)malloc(MAX*sizeof(DataType));
 ps->Capacity = MAX;
}
void PushBack(pSeqList ps, DataType d)//在后面添加数据
{
 assert(ps);
 if (ps->sz == ps->Capacity)
 {
  DataType *ptr = (DataType *)realloc(ps->data, (ps->Capacity + MAX)*sizeof(DataType));
  if (ptr != NULL)
  {
   ps->data = ptr;
   ps->Capacity += MAX;
  }
  else
  {
   perror("relloc");
   exit(EXIT_FAILURE);
  }
 }
 ps->data[ps->sz] = d;
 ps->sz++;
}
void PopBack(pSeqList ps)//删除后面的数据
{
 assert(ps);
 if (ps->sz == 0)
 {
  return;
 }
 ps->sz--;
}
void Display(const pSeqList ps)//打印顺序表
{
 assert(ps);
 int i;
 for (i = 0; i < ps->sz; i++)
 {
  printf("%d  ", *(ps->data+i));
 }
 printf("\n");
}
void PushFront(pSeqList ps, DataType d)//在前面添加数据
{
 assert(ps);
 if (ps->sz == ps->Capacity)
 {
  DataType *ptr = (DataType *)realloc(ps->data,(ps->Capacity+ MAX)*sizeof(DataType));
  if (ptr!=NULL)
  {
   ps->data = ptr;
   ps->Capacity += MAX;
  }
  else
  {
   perror("relloc");
   exit(EXIT_FAILURE);
  }
 }
 memmove(ps->data + 1, ps->data, ps->sz*sizeof(DataType));
 ps->data[0] = d;
 ps->sz++;
}
void PopFront(pSeqList ps)//删除前面的数据
{
 assert(ps);
 if (ps->sz == 0)
 {
  return;
 }
 memmove(ps->data, ps->data + 1, ps->sz*sizeof(DataType));
 ps->sz--;
}
int Find(pSeqList ps, DataType d)//查找
{
 assert(ps);
 int i;
 for (i = 0; i < ps->sz; i++)
 {
  if (d == *(ps->data + i))
   return i;
 }
 return -1;
}
void Insert(pSeqList ps, DataType d, int pos)//插入
{
 assert(ps);
 if (ps->sz == ps->Capacity)
 {
  DataType *ptr = (DataType *)realloc(ps->data, (ps->Capacity + MAX)*sizeof(DataType));
  if (ptr != NULL)
  {
   ps->data = ptr;
   ps->Capacity += MAX;
  }
  else
  {
   perror("relloc");
   exit(EXIT_FAILURE);
  }
 }
 if (pos >= ps->sz)
 {
  return;
 }
 memmove(ps->data + pos + 1, ps->data + pos, (ps->sz - pos)*sizeof(DataType));
 ps->data[pos] = d;
 ps->sz++;
}
void Remove(pSeqList ps, DataType d)//删除一个数据
{
 assert(ps);
 int i;
 if (ps->sz == 0)
 {
  return;
 }
 for (i = 0; i < ps->sz; i++)
 {
  if (ps->data[i] == d)
  {
   if (i >= ps->sz - 1)
   {
    PopBack(ps);
   }
   else
   {
    memmove(ps->data + i, ps->data + i + 1, (ps->sz - i)*sizeof(DataType));
    ps->sz--;
   }
   return;
  }
 }
}
void RemoveAll(pSeqList ps, DataType d)//删除所有的
{
 assert(ps);
 int i = 0;
 if (ps->sz == 0)
 {
  return;
 }
 while (i < ps->sz)
 {
  if (ps->data[i] == d)
  {
   if (i >= ps->sz - 1)
   {
    PopBack(ps);
   }
   else
   {
    memmove(ps->data + i, ps->data + i + 1, (ps->sz - i)*sizeof(DataType));
    ps->sz--;
   }
   i--;
  }
  i++;
 }
}
void Reverse(pSeqList ps)//反转
{
 assert(ps);
 DataType tmp;
 int i;
 for (i = 0; i <= ps->sz - i - 1; i++)
 {
  tmp = ps->data[i];
  ps->data[i] = ps->data[ps->sz - i - 1];
  ps->data[ps->sz - i - 1] = tmp;
 }
}
void Sort(pSeqList ps)//排序  从小到大
{
 assert(ps);
 int i, j;
 DataType tmp, ret;
 for (i = 0; i < ps->sz; i++)
 {
  tmp = i;
  for (j = 1; j < ps->sz - i; j++)
  {
   if (ps->data[i + j] < ps->data[i])
    tmp = i + j;
  }
  ret = ps->data[i];
  ps->data[i] = ps->data[tmp];
  ps->data[tmp] = ret;
 }
}
void shifang(pSeqList ps)//释放空间
{
 free(ps->data);
 ps->data = NULL;
 ps->Capacity = 0;
 ps->sz = 0;
}

int main()
{
 SeqList head;
 InitSeqList(&head);
 PushBack(&head, 1);
 PushBack(&head, 4);
 PushBack(&head, 6);
 PushBack(&head, 1);
 PushBack(&head, 4);
 PushBack(&head, 2);
 PushBack(&head, 7);
 PushBack(&head, 1);
 PushBack(&head, 6);
 PushBack(&head, 8);
 Display(&head);
 PopBack(&head);
 PopBack(&head);
 PopBack(&head);
 Display(&head);
 Sort(&head);
 Display(&head);
 Reverse(&head);
 Display(&head);
 Remove(&head, 1);
 Display(&head);
 RemoveAll(&head, 1);
 Display(&head);
 printf("%d\n", Find(&head, 3));
 Insert(&head, 7, 3);
 Display(&head);
 shifang(&head);
 system("pause");
 return 0;
}

注：在实现动态顺序表时要注意几点要求：

1、在程序结束的时候记得要释放开辟出来的动态内存，否则容易造成内存泄漏。

2、在扩增顺序表使用realloc时，要注意他的第二个参数是扩增后的容量大小，而不是你想要扩增的大小，否则容易造成程序崩溃。

3、每次开辟完空间要记得判断是否为空指针。

希望以上代码可以给你一定的启发，谢谢。