关于顺序表概念及其用法总结

1. 什么是线性结构？
线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。
2. 线性结构中都包含什么内容？
顺序表、链表、栈、队列、字符串
3. 什么是顺序表？顺序表的分类？
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。
顺序表一般可以分为：

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

4.顺序表的基本操作
这一段为该项目的h文件，注明拥有的函数，本函数实现了排序各种插入和删除，以及自动扩容

#pragma once
typedef int DataType;
//动态
typedef struct SeqList{
 DataType *_array;
 int _capacity; //顺序表中有效元素总个数
 int _size;   //实际存的元素
}SeqList,*PSeq;
//void SeqListlnit(SeqList 8)
void SeqListInit(PSeq ps, int capacity);  //顺序表的初始化
void SeqListPushBack(PSeq ps, DataType data);//尾部插入 
void SeqListPopBack(PSeq ps);//尾部删除函数
void SeqListPushFront(PSeq ps, DataType data);//头部插入函数 
void SeqListPopFront(PSeq ps);//头部删除函数
void SeqListInsert(PSeq ps, int pos, DataType data);//指定位置插入函数
void SeqListErase(PSeq ps, int pos); //
int SeqListFind(PSeq ps, DataType data);//查找函数
int SeqListEmpty(PSeq ps);
int SeqListSize(PSeq ps);
int SeqListCapacity(PSeq ps);//容量检测
void SeqListClear(PSeq ps);
void SeqListRemove(PSeq ps, DataType data);
void SeqListDestroy(PSeq ps); //顺序表的销毁
void CheckCapacity(PSeq ps); //检测
void TestSeqList();

.c文件如下

#include<stdio.h>
#include<malloc.h>
#include"SeqList.h"
#include<assert.h>
#include<stdlib.h>
void SeqListInit(PSeq ps, int capacity) {   //初始化
 ps->_array = (DataType*)malloc(sizeof(DataType)*capacity);
 if (NULL == ps->_array) {
  assert(0);    //只在调试版本下起作用  在release的版本
  return;//返回了但是可能会继续运行
 }
 ps->_capacity = capacity;    //上面申请空间 这两句话是用来
 ps->_size = 0;               //设置容量和有效元素的大小
} 
void SeqListDestroy(PSeq ps) {    //销毁顺序表
 if (ps->_array) {
  free(ps->_array);
  ps->_array = NULL;
  ps->_capacity = 0;
  ps->_size = 0;
 }
}
//判断顺序表是不是没有元素
int SeqListEmpty(PSeq ps) {
 assert(ps);
 return 0 == ps->_size;
}
//尾部插入
void SeqListPushBack(PSeq ps, DataType data) {
 assert(ps);
  CheckCapacity(ps);
 ps->_array[ps->_size] = data;
 ps->_size++;
}
//尾部删除函数
void SeqListPopBack(PSeq ps) {
     assert(ps);
  if (SeqListEmpty(ps))
  return;
     ps->_size--;
}
//头部插入函数 
void SeqListPushFront(PSeq ps, DataType data) {
 assert(ps);
 void CheckCapacity(PSeq ps);
 for (int i = ps->_size - 1; i >=0; i--) { //0号位置元素也需要搬移
  ps->_array[i] = ps->_array[i - 1];    //元素为搬移
 }
 ps->_array[0] = data;
 ps->_size++;
}
//头部删除函数
void SeqListPopFront(PSeq ps) {
 for (int i =1; i<ps->_size; ++i)  //如果没有元素 size为0无法进入循环
 {
  ps->_array[i - 1] = ps->_array[i];
 }
 ps->_size--;
}
//打印函数
void SeqListPrint(PSeq ps) {
 for (int i = 0; i < ps->_size; ++i)
 {
  printf("%d ", ps->_array[i]);
 }
 printf("\n");
}
//指定位置插入函数
void SeqListInsert(PSeq ps, int pos, DataType data) {
 assert(ps);
 if (pos<0 || pos>ps->_size) {
  return;
 }
  CheckCapacity( ps);
 for (int i = ps->_size - 1; i >= pos; --i) {
  ps->_array[i + 1] = ps->_array[i];
 }
 ps->_array[pos] = data;
 ps->_size++;
}
//指定位置删除
void SeqListErse(PSeq ps, int pos) {
 assert(ps);
 if (pos < 0 || pos >= ps->_size) {
  return;
 }
 for (int i = pos + 1; i < ps->_size; ++i) {
  ps->_array[i - 1] = ps->_array[i];
 }
 ps->_size--;
}
//查找函数
int SeqListFind(PSeq ps, DataType data) {
 assert(ps);
 for (int i = 0; i < ps->_size; i++) {
  if (ps->_array[i] == data)
   return i;
 }
 return -1;
}
void SeqListClear(PSeq ps) {
 assert(ps);
 ps->_size = 0;
}
//移除第一个值为data值的元素
void SeqListRemove(PSeq ps, DataType data) {
 assert(ps);
 SeqListErse(ps, SeqListFind(ps, data));
}
//扩容
void CheckCapacity(PSeq ps) {
 assert(ps);
 if (ps->_size >= ps->_capacity) {
  int newCapacity = ps->_capacity * 2;
  int *ptemp = (DataType*)malloc(newCapacity * sizeof(DataType));
  if (NULL == ptemp) {
   assert(0);
  }
  for (int i = 0; i < ps->_size; i++)
   ptemp[i] = ps->_array[i];
  free(ps->_array);
  ps->_array = ptemp;
  ps->_capacity = newCapacity;
 }
}
//打印目前容量和总大小
void SeqListCapacity1(PSeq ps) {
 assert(ps);
 printf("总容量为%d有效元素为%d\n", ps->_capacity, ps->_size);
}
//检验函数
void BuddleSort(PSeq ps) {
 
 for (int i = 0; i < ps->_size - 1; i++)
 {
  int a = 0;
  for (int j = 0; j < ps->_size-1; j++)
  {
   if (ps->_array[j] > ps->_array[j + 1])
   {
    a = 1;
    int b = ps->_array[j];
    ps->_array[j] = ps->_array[j + 1];
    ps->_array[j + 1] = b;
   }
  }
  if (a == 0) {
   return;
}
}
}
int main() {
  SeqList s;
  SeqListInit(&s, 10);
  SeqListPushBack(&s, 1);
  SeqListPrint(&s);
  SeqListPushBack(&s, 4);
  SeqListPushBack(&s, 5);
  SeqListPushBack(&s, 4);
  SeqListPushBack(&s, 5);
  SeqListPushBack(&s, 4);
  SeqListPushBack(&s, 5);
  SeqListPrint(&s);
  SeqListPopBack(&s);
  SeqListPrint(&s);
  SeqListPushFront(&s, 9);
  SeqListPrint(&s);
  SeqListPopFront(&s);
  SeqListPrint(&s);
  SeqListInsert( &s,0,8 );
  SeqListPrint(&s);
  SeqListErse( &s,1);
     SeqListPrint(&s);
  int a = SeqListFind(&s,5);
  printf("找到了在%d位置\n", a); 
  SeqListPushBack(&s, 4);
  SeqListPushBack(&s, 5);
  SeqListPushBack(&s, 4);
  SeqListPushBack(&s, 5);
  SeqListPushBack(&s, 4);
  SeqListPushBack(&s, 5);
  SeqListPushBack(&s, 4);
  SeqListPushBack(&s, 5);
  SeqListPushBack(&s, 4);
  SeqListPushBack(&s, 5);
  SeqListPushBack(&s, 4);
  SeqListPushBack(&s, 5);
  SeqListPrint(&s);
  SeqListCapacity1(&s);
  BuddleSort(&s);
  SeqListPrint(&s);
  SeqListDestroy(&s);
  system("pause");
  return 0;
}

函数运行如此
可以对照主函数完成了数字的头插入任意位置插入以及尾插入和相对于的删除，最后用冒泡排序将所有数字拍好排号由小打到排列。