动态顺序表部分接口的简易实现

顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

代码目标：实现部分接口函数

代码：

头文件部分：

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <errno.h>
#include <string.h>


#define DEFAULT_SZ 3
#define DEFAULT_INC 2

typedef int DataType;
typedef struct SeqList
{
	DataType *pdata;
	int sz;	//有效个数
	int v;	//容量
}SeqList,*pSeqList;

void menu();
void InitSeqList(pSeqList ps);	//初始化
void DestroySeqList(pSeqList ps);	//销毁
void PushBack(pSeqList ps, DataType d);	//最后部分压入d
void PrintSeqList(const pSeqList ps);	//打印顺序表
void PopBack(pSeqList ps);	//弹出最后一个元素
void PushFront(pSeqList ps, DataType d);	//首位置压入d
void PopFront(pSeqList ps);	//弹出首元素
void Insert(pSeqList ps, int pos, DataType d);	//在pos坐标前插入d
int Find(pSeqList ps, DataType d);	//查找d
void Remove(pSeqList ps, DataType d);	//移除d
void ReverseSeqlist(pSeqList ps);	//逆序
void SortSeqlist(pSeqList ps);	//排序
int BinarySearch(pSeqList ps, DataType d);	//二分查找

#endif 

函数实现部分

#include "SeqList.h"

void menu()
{
	printf("*************\n");
	printf("*************\n");
}

void check_full(pSeqList ps)	//检查开辟的内存够不够
{
	if(ps->sz == ps->v)
	{
		DataType *tem = realloc(ps->pdata,sizeof(SeqList)*(ps->v+DEFAULT_INC));
		if(NULL == tem)
			printf("%s",strerror(errno));
		else
			ps->pdata = tem;
		ps->v += DEFAULT_INC;
	}
}
void InitSeqList(pSeqList ps)	//初始化
{
	ps->pdata = malloc(DEFAULT_SZ*(sizeof(SeqList)));
	if(!ps->pdata)
		return ;	//开辟失败则直接返回
	ps->sz = 0;
	ps->v = DEFAULT_INC;
}
void DestroySeqList(pSeqList ps)	//销毁顺序表
{
	ps->sz = 0;
	ps->v = DEFAULT_INC;
	free(ps->pdata);
	ps->pdata = NULL;

}

void PushBack(pSeqList ps, DataType d)	//在最后面压入一个元素
{
	assert(ps);
	check_full(ps);
	ps->pdata[ps->sz] = d;
	ps->sz++;
}
void PrintSeqList(const pSeqList ps)	//输出顺序表元素
{
	int i = 0;
	assert(ps);
	for(i=0; i<ps->sz; i++)
	{
		printf("%d ",ps->pdata[i]);
	}
	printf("\n");
}
void PopBack(pSeqList ps)	//弹出最后一个元素
{
	assert(ps);
	ps->sz --;

}

void PushFront(pSeqList ps, DataType d)	//在顺序表最前面压入一个元素
{
	int i = 0;
	assert(ps);
	check_full(ps);
	for(i=ps->sz; i>0; i--)	//把所有元素都往后挪一个下标的位置,就将守元素腾出来放d
	{
		ps->pdata[i] = ps->pdata[i-1];
	}
	ps->pdata[0] = d;
	ps->sz++;
}
void PopFront(pSeqList ps)	//把顺序表守元素弹出
{
	int i = 0;
	assert(ps);
	for(i=0; i<ps->sz-1; i++)	//与压入相反，将所有元素向前挪一位即可
	{
		ps->pdata[i] = ps->pdata[i+1];
	}
	ps->sz--;

}
void Insert(pSeqList ps, int pos, DataType d)	//在pos坐标的元素前 插入d
{
	int i = 0;
	assert(ps);
	check_full(ps);
	for(i=ps->sz; i>pos; i--)	//将pos坐标及其以后的元素都向后挪一位，以便于插入d
	{
		ps->pdata[i] = ps->pdata[i-1];
	}
	ps->pdata[pos] = d;
	ps->sz++;
}

int Find(pSeqList ps, DataType d)	//在顺序表中找出第一个出现的d并返回其下标
{
	int i = 0;
	assert(ps);
	for(i=0; i<ps->sz; i++)
	{
		if(ps->pdata[i] == d)	//找到就返回下标，否则返回-1
			return i;
	}
	return -1;
}
void Remove(pSeqList ps, DataType d)	//在顺序表中移除 d
{
	int i = 0;
	int ret = 0;
	assert(ps);
	ret = Find(ps,d);
	for(i=ret; i<ps->sz-1; i++)	
	{
		ps->pdata[i] = ps->pdata[i+1];
	}
	ps->sz--;
}
void ReverseSeqlist(pSeqList ps)	//将顺序表元素逆序
{
	int left = 0;
	int right = ps->sz-1;
	int temp = 0;
	assert(ps);
	while(left<right)
	{
		temp = ps->pdata[left];
		ps->pdata[left] = ps->pdata[right];
		ps->pdata[right] = temp;
		left++;
		right--;
	}

}
void SortSeqlist(pSeqList ps)	//将顺序表中元素按从小到大顺序排序
{
	int i = 0;
	int k = 0;
	int temp = 0;
	assert(ps);
	for(i=0; i<ps->sz-1; i++)	//一手冒泡。。
	{
		for(k=0; k<ps->sz-i-1; k++)
		{
			if(ps->pdata[k] > ps->pdata[k+1])
			{
				temp = ps->pdata[k];
				ps->pdata[k] = ps->pdata[k+1];
				ps->pdata[k+1] = temp;
			}
		}
	}

}

int BinarySearch(pSeqList ps, DataType d)	//二分查找
{
	int left = 0;
	int right = ps->sz-1;
	int mid = 0;
	assert(ps);
	SortSeqlist(ps);	//先排序
	while(left<=right)	//二分查找找到返回其下标，没找到返回-1
	{
		mid = (left+right)>>1;
		if(ps->pdata[mid] == d)
		{
			return mid;
		}
		else if(ps->pdata[mid] < d)
		{
			left = mid+1;
		}
		else
			right = mid-1;

	}
	return -1;

}

测试及结果展示：亲测，没什么大毛病。。