动态顺序表

1.头文件

#include"stdio.h"

#include "windows.h"
#include"assert.h"
#include "malloc.h"




#ifndef _SEQLISTD_H__
#define _SEQLISTD_H__




typedef int DataType;
struct seqlistd
{
DataType* pdata;
int size; // 顺序表中有效元素的个数 
int capacity; // 顺序表中可容纳元素的最大值 
};
typedef struct seqlistd seqlistd;
typedef struct seqlistd* pseqlistd;//指向seqlistd类型的指针








// 顺序表的初始化 
void SeqListdInit(struct seqlistd* pseq);


//顺序表的打印
void SeqListdPrint(pseqlistd pseq);


// 尾插 
void SeqListDPushBack(pseqlistd pseq, DataType data);
// 尾删 
void SeqListDPopBack(pseqlistd pseq);


// 判断顺序表是否为空，为空返回true，否则返回false 
int SeqListDEmpty(pseqlistd pseq);


// 获取顺序表中有效元素的个数 
int SeqListDSize(pseqlistd pseq);


//获取顺序表的容量 
int SeqListDCapacity(pseqlistd pseq);


// 清空顺序表中的所有元素 
void SeqListDClear(pseqlistd pseq);


// 动态增容 
int CheckCapacity(pseqlistd pseq);


// 销毁顺序表 
void SeqListDDestroy(pseqlistd pseq);


// 顺序表任意位置插入元素 
void SeqListDInsert(pseqlistd pseq, size_t pos, DataType data);


// 顺序表任意位置删除元素 

void SeqListDErase(pseqlistd pseq, size_t pos);

2.操作函数

#include "seqlistd.h"

// 顺序表的初始化 
void SeqListdInit(struct seqlistd* pseq)
{
pseq->size = 0;
pseq->capacity = 9;
pseq->pdata = (DataType *)malloc(pseq->capacity * sizeof(DataType));
if (NULL == pseq->pdata)
{
printf("初始化顺序表失败");
}
}



//顺序表的打印
void SeqListdPrint(pseqlistd pseq)
{
assert(pseq);
for (int i = 0; i < pseq->size; i++)
{
printf("%d->", pseq->pdata[i]);
}
printf("\n");
}


// 尾插 
void SeqListDPushBack(pseqlistd pseq, DataType data)
{
assert(pseq);
int last = pseq->size;
CheckCapacity(&pseq);
pseq->pdata[last++] = data;
pseq->size++;
}
// 尾删 
void SeqListDPopBack(pseqlistd pseq)
{
assert(pseq);
if (SeqListDEmpty(&pseq))
{
printf("顺序表已空");
}
else
pseq->size--;
}




// 判断顺序表是否为空，为空返回true，否则返回false 
int SeqListDEmpty(pseqlistd pseq)
{
assert(pseq);
if (pseq->size == 0)
return 1;
else
return 0;


}


// 获取顺序表中有效元素的个数 
int SeqListDSize(pseqlistd pseq)
{
assert(pseq);
return pseq->size;


}


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




// 清空顺序表中的所有元素 
void SeqListDClear(pseqlistd pseq)
{
assert(pseq);
if (pseq->size == 0)
{
printf("顺序表已空");
}
else
pseq->size = 0;
}


// 动态增容 
int CheckCapacity(pseqlistd pseq)
{
assert(pseq);
DataType *ptemp = pseq->pdata;//ptemp指向扩容之前的空间
if (pseq->capacity <=pseq->size)//需要增容
{
DataType newcapacity = pseq->capacity *2;//新的空间为以前的两倍
//增容
  ptemp= (DataType *)realloc(pseq->pdata, newcapacity * sizeof(DataType));


if (NULL == ptemp)
{
pseq->pdata = ptemp;    
printf("扩容失败");
return 0;    
}
else
{
pseq->capacity = newcapacity;
return 1;
}
}
}


// 销毁顺序表 
void SeqListDDestroy(pseqlistd pseq)
{
assert(pseq);
pseq->capacity = 0;
pseq->size = 0;
free(pseq->pdata );
}


// 顺序表任意位置插入元素 
void SeqListDInsert(pseqlistd pseq, size_t pos, DataType data)
{
assert(pseq);
if (pseq->size >= pseq->capacity)
{
printf("顺序表已满");
}
if (pos<0 || pos> pseq->size)
{
printf("插入位置不合法");
return;
}
int temp = CheckCapacity(&pseq);
if (temp)
{
for (int i = pseq->size - 1; i > pos; --i)
{
pseq->pdata[i + 1] = pseq->pdata[i];//整体后移
pseq->size++;


}
pseq->pdata[pos] =data;
}
}


// 顺序表任意位置删除元素 
void SeqListDErase(pseqlistd pseq, size_t pos)
{
assert(pseq);
if (SeqListDEmpty(&pseq))
{
printf("顺序表已空");
}
if (pos<0 || pos> pseq->size)
{
printf("删除位置不合法");
return;
}
for (int i = pos; i <pseq->size-1; i++)
    {
pseq->pdata[i] = pseq->pdata[i+1];//整体后移
pseq->size--;


     }
}


3.测试函数

#include "seqlistd.h"

int main()
{
seqlistd s;
SeqListdInit(&s);

SeqListDPushBack(&s, 1);
SeqListDPushBack(&s, 2);
SeqListDPushBack(&s, 3);
SeqListDPushBack(&s, 4);
SeqListDPushBack(&s, 5);
    SeqListdPrint(&s);


SeqListDPopBack(&s);
SeqListdPrint(&s);


SeqListDEmpty(&s);


SeqListDSize(&s);


SeqListDCapacity(&s);


SeqListDClear(&s);


CheckCapacity(&s);//增容




SeqListDDestroy(&s);
SeqListdPrint(&s);


SeqListDInsert(&s, 3, 0);
SeqListdPrint(&s);


SeqListDErase(&s, 5);
SeqListdPrint(&s);
system("pause");
return 0;
}