【C语言】实现动态顺序表

     其实动态顺序表就是在静态顺序表的基础上进行修改的，动态顺序表的底层实现是一个指向动态数组；我们根据存储数据的个数，在原开辟内存的基础上扩容，提供多余的空间储存数据；这种办法，不会造成多余开辟空间，对空间的浪费。也不会遇到储存数据太多，空间不够的情况（在正常内存范围内）；下面同样使用三个函数文件实现：

Seqlist.h

#ifndef __SeqList_H__ 
#define __SeqList_H__ 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
typedef int DataType;
#define PrintType "%d "
//#define MAX 10
#define Orgin_capacity 2
#define Expand_INC 2


typedef struct SeqList
{
	DataType *data;//动态数组
	int sz;//顺序表元素个数
	int capacity;//当前容量
}SeqList,*pSeqList;


void InitSeqList(pSeqList ps);//初始化
void CheckSeqList(pSeqList ps);//内存大小检查及处理
void DestorySeqList(pSeqList ps);//内存释放
void PushBack(pSeqList ps, DataType d);//尾部插入数据d
void PushFront(pSeqList ps, DataType d);//在头部插入数据d
void DisPlay(pSeqList ps);//打印所有数据
void PopBack(pSeqList ps);//尾部删除数据
void PopFront(pSeqList ps);//头部删除数据
int Find(pSeqList ps, DataType d);//删除指定位置的数据
void Insert(pSeqList ps, DataType d, int pos);//在指定的位置插入数据
void Remove(pSeqList ps, DataType d);//删除数据d
void RemoveAll(pSeqList ps, DataType d);//删除所有相同的数据d
void Reverse(pSeqList ps);//将所有数据逆序
void Sort(pSeqList ps);//给所有数据排序
int BinarySearch(pSeqList ps, DataType d);//二分查找指定数据
#endif//__SeqList_H__ 

Seqlist.c

#include"Seqlist.h"
void InitSeqList(pSeqList ps)
{
	assert(ps != NULL);
	ps->sz = 0;
	ps->data = malloc(sizeof(DataType)*Orgin_capacity);
	//ps->sz = 0;
	if (ps->data == NULL)
	{
		perror("use malloc");
		exit(EXIT_FAILURE);
	}
	memset(ps->data, 0, sizeof(DataType)*Orgin_capacity);
	ps->capacity = Orgin_capacity;
}

void CheckSeqList(pSeqList ps)
{
	assert(ps != NULL);
	if (ps->capacity==ps->sz)
	{
		DataType *ptr = (DataType*)realloc(ps->data, (sizeof(DataType))*(ps->capacity + Expand_INC));
		if (ptr == NULL)
		{
			perror("use realloc");
			exit(EXIT_FAILURE);
		}
		else
		{
			ps->data = ptr;
		}
		ps->capacity += Expand_INC;
		printf("增容成功！\n");
	}
}

void DestorySeqList(pSeqList ps)
{
	assert(ps);
	free(ps->data);
	ps->sz = 0;
	ps->capacity = 0;
}

void DisPlay(pSeqList ps)
{
	int i= 0;
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return;
	}
	for (i = 0; i < ps->sz; i++)
	{
		printf(PrintType, ps->data[i]);
	}
	printf("\n");
}

void PushBack(pSeqList ps, DataType d)
{
	assert(ps != NULL);
	CheckSeqList(ps);

	ps->data[ps->sz] = d;
	ps->sz++;

	/*if (ps->sz == MAX)
	{
		return;
	}
	else*/
	///{
		ps->data[ps->sz] = d;
		ps->sz++;
	//}
}

void PushFront(pSeqList ps, DataType d)
{
	int i = 0;
	assert(ps != NULL);
	CheckSeqList(ps);
	/*if (ps->sz == MAX)
	{
		return;
	}*/
	for (i = ps->sz-1; i >= 0; i--)
	{
		ps->data[i+1] = ps->data[i];
	}
	ps->data[0] = d;
	ps->sz++;
}

void PopBack(pSeqList ps)
{
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return;
	}
	ps->sz--;
}

void PopFront(pSeqList ps)
{
	assert(ps);

	memmove(ps->data , ps->data+1, (ps->sz - 1)*sizeof(DataType));
	ps->sz--;
}

int Find(pSeqList ps, DataType d)
{
	int i = 0;
	assert(ps != NULL);
	

	for (i = 0; i < ps->sz; i++)
	{
		if (ps->data[i] == d)
		{
			return i;
		}
		
	}
	return -1;
}

void Insert(pSeqList ps, DataType d,int pos)
{
	assert(ps != NULL);
	CheckSeqList(ps);
	/*if (ps->sz == MAX)
	{
		return;
	}*/
	memmove(ps->data + pos + 1, ps->data + pos, (ps->sz - pos)*sizeof(DataType));
	ps->data[pos] = d;
	ps->sz++;
}

void Remove(pSeqList ps, DataType d)
{
	int pos = 0;
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return;
	}
    pos = Find(ps, d);
	if (pos != -1)
	{
		memmove(ps->data + pos, ps->data + pos+1, sizeof(DataType)*(ps->sz - pos - 1));
		ps->sz--;
	}
}

void RemoveAll(pSeqList ps, DataType d)
{
	int i = 0;
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return;
	}
	while ((Find(ps, d)) != -1)
	{	memmove(ps->data + i, ps->data + i + 1, sizeof(DataType)*(ps->sz - i));
			ps->sz--;
	}
}

void Reverse(pSeqList ps)
{
	int left = 0;
	int right = ps->sz - 1;
	assert(ps);
	if (ps->sz == 0)
	{
		return;
	}
	while (left < right)
	{
		int tmp = ps->data[left];
		ps->data[left] = ps->data[right];
		ps->data[right] = tmp;
		left++;
		right--;
	}
}

void Sort(pSeqList ps)
{
	int i = 0;
	int j = 0;
	assert(ps);
	if (ps->sz == 0)
	{
		return;
	}
	for (i = 0; i < ps->sz-1; i++)
	{
		for (j = 0; j < (ps->sz - i - 1); j++)
		{
			if (ps->data[j]>ps->data[j + 1])
			{
				DataType tmp = ps->data[j];
				ps->data[j] = ps->data[j + 1];
				ps->data[j + 1] = tmp;
			}
		}
	}
}

int BinarySearch(pSeqList ps, DataType d)
{
	int left = 0;
	int right = ps->sz - 1;
	int mid = left + ((right - left) >> 2);
	while (left <= right)
	{
		if (ps->data[mid] == d)
			return mid;
		else if (ps->data[mid] > d)
		{
			right = mid - 1;
		}
		else
		{
			left = mid + 1;
		}
	}
	return -1;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"Seqlist.h"

void test1()
{
	SeqList my_list;
        InitSeqList(&my_list);
	PushBack(&my_list,1);
	PushBack(&my_list,2);
	/*PushBack(&my_list,3);
	PushBack(&my_list,4);*/
        DisPlay(&my_list);
	PushFront(&my_list, 5);
	PushFront(&my_list, 6);
	/*PushFront(&my_list, 7);
	PushFront(&my_list, 8);*/
	DisPlay(&my_list);
	PopBack(&my_list);
	DisPlay(&my_list);
	PopFront(&my_list);
	DisPlay(&my_list);
}

void test2()
{
	SeqList my_list;
	InitSeqList(&my_list);
	PushBack(&my_list, 1);
	PushBack(&my_list, 2);
	DisPlay(&my_list);
	PushBack(&my_list, 3);
	PushBack(&my_list, 4);
	DisPlay(&my_list);
	PushFront(&my_list, 5);
	PushFront(&my_list, 6);
	DisPlay(&my_list);
	PushFront(&my_list, 7);
	PushFront(&my_list, 8);
	DisPlay(&my_list);
	PopBack(&my_list);
	DisPlay(&my_list);
	PopFront(&my_list);
	DisPlay(&my_list);
	int pos = Find(&my_list, 3);//查找  
	printf("要寻找的下标为:%d \n", pos);
	DisPlay(&my_list);
    Insert(&my_list, 6, 2);
	DisPlay(&my_list);
	Remove(&my_list,3);
    DisPlay(&my_list);
	Remove(&my_list, 7);
	DisPlay(&my_list);
	Sort(&my_list);
	DisPlay(&my_list);
	int mid = BinarySearch(&my_list, 2);
	printf("二分法查找要寻找的下标为:%d \n", mid);
	DisPlay(&my_list);
	Reverse(&my_list);
	DisPlay(&my_list);
	RemoveAll(&my_list, 6);
	DisPlay(&my_list);
	Remove(&my_list, 5);
	DisPlay(&my_list);
	//DestorySeqList(&my_list);
}
    

int main()
{
	SeqList my_list;
	InitSeqList(&my_list);
	//test1();
	test2();
	DestorySeqList(&my_list);
	system("pause");
	return 0;
}