实现顺序表基础接口

顺序表

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

1. 静态顺序表：使用定长数组存储。 2. 动态顺序表：使用动态开辟的数组存储。

下面我们实现的是动态顺序表：

list.h—头文件

#include <stdio.h>
#include <malloc.h>
#include <assert.h>
#include <stdlib.h>

typedef int  SLDataType;
typedef struct Seqlist
{
 SLDataType* _array;
 size_t _size;
 size_t _capacity;
}SeqList;

// 基本增删查改接口 
void SeqListInit(SeqList* psl, size_t capacity); //初始化
void SeqListDestory(SeqList* psl); //释放
void CheckCapacity(SeqList* psl); //增容
void SeqListPushBack(SeqList* psl, SLDataType x); //尾插
void SeqListPopBack(SeqList* psl); //尾删
void SeqListPushFront(SeqList* psl, SLDataType x); //头插
void SeqListPopFront(SeqList* psl);
int SeqListFind(SeqList* psl, SLDataType x);
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x); //任意位置插入
void SeqListErase(SeqList* psl, size_t pos);  //任意位置删除
void SeqListRemove(SeqList* psl, SLDataType x); //删除x
void SeqListModify(SeqList* psl, size_t pos, SLDataType x);  //修改数据
void SeqListPrint(SeqList* psl);

void SeqListBubbleSort(SeqList* psl); //冒泡
int SeqListBinaryFind(SeqList* psl, SLDataType x); //二分查找
void SeqListRemoveAll(SeqList* psl, SLDataType x); //删除所有的x
void Test();

list.c—.c文件

#include "list.h"

void SeqListInit(SeqList* psl, size_t capacity)
{
 assert(psl);
 psl->_array = (SLDataType*)malloc(capacity * sizeof(SLDataType));
 psl->_size = 0;
 psl->_capacity = capacity;
}

void SeqListDestory(SeqList* psl)
{
 assert(psl);
 free(psl->_array);
 psl->_size = psl->_capacity;
}

void CheckCapacity(SeqList* psl)
{
 assert(psl);
 if (psl->_size == psl->_capacity)
 {
  psl->_capacity *= 2;
  psl->_array = (SLDataType*)realloc(psl->_array, sizeof(SLDataType)* (psl->_capacity)); 
  assert(psl->_array);
 }
}

void SeqListPrint(SeqList* psl)
{
 assert(psl);
 for (size_t i = 0; i < psl->_size; i++)
 {
  printf("%d ", psl->_array[i]);
 }
}

void SeqListPushBack(SeqList* psl, SLDataType x)
{
 //assert(psl);
 //CheckCapacity(psl);
 //psl->_array[psl->_size] = x;
 //psl->_size++;
 SeqListInsert(psl, psl->_size, x);
}

void SeqListPushFront(SeqList* psl, SLDataType x) 
{
 //assert(psl);
 //CheckCapacity(psl);
 //for (size_t i = psl->_size; i > 0; i--)
 //{
 // psl->_array[i] = psl->_array[i-1];
 //}
 //psl->_array[0] = x;
 //psl->_size++;
 SeqListInsert(psl, 0, x);  //复用
}
void SeqListPopBack(SeqList* psl)
{
 assert(psl);
 psl->_size--;
}

void SeqListPopFront(SeqList* psl)
{
 //assert(psl);
 //for (size_t i = 0; i < psl->_size; i++)
 //{
 // psl->_array[i] = psl->_array[i + 1];
 //}
 //psl->_size--;
 SeqListErase(psl, 0);
}

int SeqListFind(SeqList* psl, SLDataType x)
{
 assert(psl);
 for (size_t i = 0; i < psl->_size; i++)
 {
  if (x == psl->_array[i])
  {
   return i;
  }
 }
 return -1;
}

void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
 assert(psl);
 CheckCapacity(psl);
 for (size_t i = psl->_size; i > pos; i--)
 {
  psl->_array[i] = psl->_array[i - 1];
 }
 psl->_array[pos] = x;
 psl->_size++;
}

void SeqListErase(SeqList* psl, size_t pos)
{
 assert(psl);
 for (size_t i = pos; i < psl->_size; i++)
 {
  psl->_array[i] = psl->_array[i + 1];
 }
 psl->_size--;
}

void SeqListRemove(SeqList* psl, SLDataType x)
{
 assert(psl);
 int pos = 0;
 pos = SeqListFind(psl, x);
 SeqListErase(psl, pos);
}

void SeqListModify(SeqList* psl, size_t pos, SLDataType x)
{
 assert(psl);
 psl->_array[pos] = x;
}

void SeqListBubbleSort(SeqList* psl)
{
 assert(psl);
 int tmp = 0;
 for (size_t i = 0; i < psl->_size-1; i++)
 {
  for (size_t j = 0; j < psl->_size-1; j++)
  {
   if (psl->_array[j] >psl->_array[j + 1])
   {
    tmp = psl->_array[j + 1];
    psl->_array[j + 1] = psl->_array[j];
    psl->_array[j] = tmp;
   }
  }
 }
}

int SeqListBinaryFind(SeqList* psl, SLDataType x)
{
 assert(psl);
 int begin = 0;
 int mid = 0;
 int end = psl->_size - 1;
 while (begin < end)
 {
  mid = (begin + end) / 2;
  if (x == psl->_array[begin])
   return begin;
  if (x == psl->_array[end])
   return end;
  if (x == psl->_array[mid])
   return mid;
  if (x < psl->_array[mid])
   end = mid;
  else
   begin = mid;
 }
 return -1;
}

void SeqListRemoveAll(SeqList* psl, SLDataType x)
{
 assert(psl);
 while (SeqListFind(psl, x) != -1){
  SeqListRemove(psl, x);
 }
}

void Test()
{
 SeqList a;
 SeqListInit(&a, 4);
 SeqListPushBack(&a, 3);
 SeqListPushBack(&a, 2);
 SeqListPushBack(&a, 6);
 SeqListPushBack(&a, 8);
 SeqListPushBack(&a, 7);
 SeqListPushBack(&a, 9);
 SeqListPushBack(&a, 2);
 SeqListPushBack(&a, 1);
 //SeqListPopBack(&a);
 //SeqListPopFront(&a);
 //SeqListPopFront(&a); 
 //SeqListPushFront(&a, 1);
 //SeqListInsert(&a, 2, 6);
 //SeqListErase(&a, 2);
 //SeqListRemove(&a, 3);
 //SeqListModify(&a, 0, 6);
 //SeqListBubbleSort(&a);
 SeqListBinaryFind(&a,6);
 SeqListRemoveAll(&a, 2);
 SeqListPrint(&a);
 //printf("%d", SeqListBinaryFind(&a, 6));
 SeqListDestory(&a);
}

main.c

#include "list.h"
int main()
{
 Test();
 system("pause");
 return 0;
}