动态顺序表的各种操作

动态顺序表的操作包括：动态顺序表的初始化，尾插，尾删，任意位置插，任意位置删除，获取元素个数、获取顺序表的容量、判空、顺序表元素清空、销毁顺序表，辅助操作对顺序表增容、打印顺序表。代码如下：

1、头文件声明部分
Seqlist.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int DataType;

typedef struct SeqListD
{
DataType *array;
int capacity;    //空间容量
int size;        //顺序表中有效元素个数
}SeqListD, *PSeqListD;



void SeqListDInit(PSeqListD ps, int capacity);                             //对动态顺序表初始化
void SeqListDPushBack(PSeqListD ps, DataType data);                       //尾插
void SeqListDPopBack(PSeqListD ps);                                       //尾删
void SeqListDInsert(PSeqListD ps, int pos, DataType data);                //任意位置插入
void SeqListDErase(PSeqListD ps, int pos);                                //任意位置删除

int SeqListDSize(PSeqListD ps);                                           // 获取元素个数 

int SeqListDCapacity(PSeqListD ps);                                      // 获取顺序表的容量
int SeqListDEmpty(PSeqListD ps);                                         //判空,为空返回0，

void SeqListDClear(PSeqListD ps);                                         // 将顺序表中的元素清空 注意：不改变顺序表空间的大小 
void SeqListDDestroy(PSeqListD ps);                                       //销毁顺序表




  void CheckCapacity(PSeqListD ps);                                         // 对顺序表进行增容

void print(PSeqListD ps);


“seqlist.c”
#include "Seqlist.h"

void SeqListDInit(PSeqListD ps, int capacity)                           //对动态顺序表初始化
{  
if (NULL == ps)
{
    return;
}
ps->array = (DataType *)malloc(sizeof(DataType)*capacity);

if (NULL == ps)
{
    printf("空间申请失败\n");
}

}

void SeqListDPushBack(PSeqListD ps, DataType data) //尾插
{
if (NULL == ps)
{
return;
}
if (ps->size == ps->capacity)
{
CheckCapacity(ps);
}
ps->array[ps->size] = data;
ps->size++;
}

void SeqListDPopBack(PSeqListD ps)                                       //尾删
{
if (NULL == ps)
{
    return;
}

if (0 == ps->size)
{
    printf("动态顺序表为空,尾删失败\n");
}

ps->size--;
}



void SeqListDInsert(PSeqListD ps, int pos, DataType data)                 //任意位置插入
{
int i = 0;
if(NULL == ps)
    {
        return;
    }
if ((pos < 0) && (pos >= ps->size))
{
    printf("插入位置有误，插入失败\n");
    return;
}

for (i = ps->size ; i > pos; i--)
{
    ps->array[i] = ps->array[i - 1];
}

ps->array[pos] = data;
ps->size++;
}


void SeqListDErase(PSeqListD ps, int pos)                                 //任意位置删除
{  
int i = 0;
if (NULL == ps)
{
    return;
}
if (!(pos >= 0) && (pos <= ps->size))
{
    printf("输入位置有误!!!\n");
    return;
}

for (i = pos; i < ps->size-1 ; i++)
{
    ps->array[i] = ps->array[i+1];
}
ps->size--;
}


int SeqListDSize(PSeqListD ps)                                            // 获取元素个数 
{
assert(ps);
return ps->size;
}


int SeqListDCapacity(PSeqListD ps)                                       // 获取顺序表的容量
{
assert(ps);
return ps->capacity;
}


int SeqListDEmpty(PSeqListD ps)                                           //判空,为空返回0,不为空返回1，本来就是空的返回-1
{
if (NULL == ps)
{
    assert(ps);
    return -1;
}
if (0 == ps->size)
{
    return 0;
}
return 1;
}


void SeqListDClear(PSeqListD ps)                                         // 将顺序表中的元素清空，不改变顺序表空间的大小 
{
if (NULL == ps)
{
    return;
}
ps->size = 0;

}

//销毁顺序表,大小清零，空间清零，最后将空间释放，最后给指针赋值NULL，防止产生野指针
 void SeqListDDestroy(PSeqListD ps)                                        
{
if (NULL == ps)
{
    return;
}
ps->size = 0;
ps->capacity = 0;
free(ps->array);
ps->array  = NULL;
}




void CheckCapacity(PSeqListD ps)                                         // 对顺序表进行增容
{
if (NULL == ps)
{
    return;
}
ps->array = (DataType *)realloc(ps->array,\
    (sizeof(DataType)*ps->capacity) * 2);  //新的空间申请大小是旧空间的2倍
if (NULL == ps)
{
    printf("空间申请失败\n");
    return;
}
ps->capacity = 2 * ps->capacity;
}


void print(PSeqListD ps)
{
    int i = 0;
    for (i = 0; i < ps->size; i++)
    {
        printf("%d ", ps->array[i]);
    }
    printf("\n");
}

3、测试部分
‘test.c’

#include "Seqlist.h"
#include <Windows.h>


int main()
{
int capacity = 9;
int size = 0;
SeqListD L;
PSeqListD ps = &L;

SeqListDInit(ps, capacity);                                        //初始化 
print(ps);
SeqListDPushBack(ps, 67);                                          //尾插
print(ps);
SeqListDPushBack(ps, 10);
print(ps);
SeqListDPushBack(ps, 9);
print(ps);
//SeqListDPopBack(ps);                                             //尾删
SeqListDInsert(ps, 4, 5);                                          //任意位置插入
//SeqListDErase(ps, 8);                                            //任意位置删除
print(ps);

size = SeqListDSize(ps);                                           // 获取元素个数 
capacity = SeqListDCapacity(ps);                                   // 获取顺序表的容量


CheckCapacity(ps);                                             // 对顺序表进行增容，并打印
printf("size = %d\n capacity = %d\n", size, capacity);

//SeqListDEmpty(ps);                                          //判空,为空返回0

//SeqListDClear(ps);                                          // 将顺序表中的元素清空 ,不改变顺序表的大小 
//SeqListDDestroy(ps);                                        //销毁顺序表
print(ps);                                                     //打印顺序表

system("pause");
return 0;
}

realloc实现步骤：

1、申请新空间
2、拷贝
3、释放旧空间

函数实现步骤：

1、参数检测
2、边界条件
3、逻辑操作