静态顺序表

顺序表：用一段连续的存储单元依次存储数据元素的线性结构，顺序表分为静态数据表和动态数据表。
顺序表和数组的区别：
顺序表要求数据必须是连续的，而数组的数据元素可以不连续。
下面是实现了顺序表的一些功能，代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#define M 10
typedef int DataType;
typedef struct SqeList//结构体
{
     DataType _arr[M];
     int _size;
}SqeList;
void SqeListPrint(SqeList* pSqe)//打印
{
     int i= 0;
     for (i = 0; i < pSqe->_size; i++)
     {
          printf("%d ", pSqe->_arr[i]);
     }
}
void SqeListInit(SqeList* pSqe)//初始化
{
     assert(pSqe);
     memset(pSqe->_arr, 0, sizeof(DataType)*M);
     pSqe->_size = 0;
}
void SqeListpushback(SqeList* pSqe, DataType x)//后插
{
     assert(pSqe);
     if (pSqe->_size >= M)
     {
          printf("shuzu is full");
     }
     else
     {
          pSqe->_arr[pSqe->_size++] = x;
     }
}
void SqeListpushfront(SqeList* pSqe, DataType x)//前插
{
     assert(pSqe);
     if (pSqe->_size >= M)
     {
          printf("shuzu is full");
     }
     else
     {
          int i = pSqe->_size;
          while (i >0 )
          {
              pSqe->_arr[i] = pSqe->_arr[i-1];
              i--;
          }
          pSqe->_arr[0] = x;
     }
     pSqe->_size++;
}
void SqeListPopfront(SqeList* pSqe)//前删
{
     assert(pSqe);
     if (pSqe->_size < 1)
     {
          printf("arr is empty!");
     }
     else
     {
          int i = 0;
          while (i <pSqe->_size-1)
          {
              pSqe->_arr[i] = pSqe->_arr[i+1];
              i++;
          }
          pSqe->_size--;
     }
}
void SqeListPopback(SqeList* pSqe)//后删
{
     assert(pSqe);
     if (pSqe->_size < 1)
     {
          printf("arr is empty!");
     }
     else
     {
          pSqe->_arr[pSqe->_size-1] = 0;
          pSqe->_size--;
     }
}
void SqeListInsert(SqeList* pSqe, size_t pos, DataType x)//在指定位置插入
{
     assert(pSqe);
     if (pSqe->_size >= M)
     {
          printf("arr is full!");
     }
     else
     {
          int i = pSqe->_size-1;
          while (i >= (int)pos-1)
          {
              pSqe->_arr[i+1] = pSqe->_arr[i];
              i--;
          }
          pSqe->_arr[pos - 1] = x;
          pSqe->_size++;
     }
}
void SqeListErase(SqeList* pSqe, size_t pos)//删除指定位
{
     assert(pSqe);
     if (pSqe->_size == 0)
     {
          printf("arr is empty!");
     }
     else
     {
          int i = pos-1;
          while (i < pSqe->_size)
          {
              pSqe->_arr[i] = pSqe->_arr[i + 1];
              i++;
          }
          pSqe->_size--;
     }
}
void SqeListModify(SqeList* pSqe, size_t pos,DataType x)//替换指定位
{
     assert(pSqe);
     pSqe->_arr[pos-1] = x;
}
void SqeListRemoveAll(SqeList* pSqe)//删除所有
{
     assert(pSqe);
     int i = pSqe->_size - 1;
     while (i >= 0)
     {
          pSqe->_arr[i] = 0;
          i--;
          pSqe->_size--;
     }
}
int SqeListFind(SqeList* pSqe, DataType x)//查找
{
     assert(pSqe);
     int i = 0;
     for (i = 0; i < pSqe->_size;i++)
     {
          if (pSqe->_arr[i] == x)
              return i;
     }
     return -1;
}
int IsEmpty(SqeList* pSqe)//判空
{
     assert(pSqe);
     if (pSqe->_size == 0)
          return 1;
     else
          return 0;
}
void swap(DataType *p1, DataType *p2)
{
     DataType tmp = *p1;
     *p1 = *p2;
     *p2 = tmp;
}
void SqeListBubbleSort(SqeList* pSqe)//冒泡排序
{
     int i = 0;
     int j = 0;
     for (i = 0; i < pSqe->_size-1; i++)
     {
          for (j = 0; j < pSqe->_size - i - 1; j++)
          {
              if (pSqe->_arr[j]>pSqe->_arr[j + 1])
              {
                   swap(&(pSqe->_arr[j]), &(pSqe->_arr[j + 1]));
              }
          }
     }
}
void SqeListSlelectSort(SqeList* pSqe)//选择排序
{
     int left = 0;
     int right = pSqe->_size - 1;
     while (left < right)
     {
          int max = left;
          int min = right;
          int i = left;
          while (i <= right)
          {
              if (pSqe->_arr[i] < pSqe->_arr[min])
              {
                   min = i;
              }
              else
              {
                   i++;
              }
          }
          swap(&(pSqe->_arr[left]), &(pSqe->_arr[min]));
          left++;
     }
}
void test()
{
     SqeList S;
     SqeListInit(&S);
     SqeListpushback(&S, 1);
     SqeListpushback(&S, 2);
     SqeListpushback(&S, 3);
     SqeListpushback(&S, 4);
     SqeListpushback(&S, 5);
     SqeListpushfront(&S, 9);
     SqeListpushfront(&S, 20);
     SqeListpushfront(&S, 24);
     SqeListPopback(&S);
     SqeListPopfront(&S);
     SqeListInsert(&S, 3, 7);
     SqeListErase(&S,3);
     SqeListModify(&S, 4, 99);
     //SqeListRemoveAll(&S);//删除所有
     //SqeListBubbleSort(&S);
     SqeListSlelectSort(&S);
     SqeListPrint(&S);
     int ret = 0;
     if (ret = SqeListFind(&S, 3))
     {
     if (ret == -1)
     {
     printf("没有找到!");
     }
     else
     {
     printf("找到了！");
     }
     }
     /*int ret = IsEmpty(&S);
     if (ret == 0)
     {
          printf("不为空\n");
     }
     else
     {
          printf("空\n");
     }*/
}

测试代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include "test.h"
int main()
{
     test();
     system("pause");
     return 0;
}