动态顺序表

</pre><pre name="code" class="cpp">//seqlist.h
#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#define CAPACITY 3
typedef struct
{
	int *array;
	int size;
	int capacity;
}Seqlist;

typedef enum
{
	TRUE,
	FALSE,
}Tag;


typedef struct
{
	Tag isFind; //是否找到
	int index;  //该数对应的数组下标
}FindRet;

void ExpendSeqlist(Seqlist *pSeq);//扩大容量为原来的2倍
void InitSeqlist(Seqlist *pSeq);//表的初始化
void PrintSeqlist(Seqlist *pSeq);//输出表里数据
void PushBack(Seqlist *pSeq,int x);//增加数据
void PopBack(Seqlist *pSeq);//从后往前减少数据
void PushFront(Seqlist *pSeq,int x);//在最前面写入数据x
void PopFront(Seqlist *pSeq);//删除最前面的数据
void Insert(Seqlist *pSeq,int index ,int x);//在index位置上插入x数据
void Modifity(Seqlist *pSeq,int index,int x);//修改index位置的数据
void Remove(Seqlist *pSeq,int index);//删除index位置的数据
FindRet find(Seqlist *pSeq,int x,int index);//查找某数据
Tag Erase(Seqlist *pSeq,int x,Tag all);//删除某数据
void BubbleSeqlist(Seqlist *pSeq);//冒泡排序
void SelectSeqlist(Seqlist *pSeq);//选择排序
FindRet BinarySearch(Seqlist *pSeq,int x);//二分搜索

#endif //__SEQLIST_H__


//seqlist.c
#include"seqlist.h"
#include<assert.h>
#include<stdio.h>
#include<string.h>
#include<malloc.h>
//扩大容量为原来的2倍
void ExpendSeqlist(Seqlist *pSeq)
{
	assert(pSeq);
	if(pSeq->size==pSeq->capacity)
	{
		//第一种方式
		int *tmp=(int *)malloc(pSeq->capacity*2*sizeof(int));
		pSeq->capacity=pSeq->capacity*2;
		memcpy(tmp,pSeq->array,pSeq->size*sizeof(int));
		free(pSeq->array);
		pSeq->array=tmp;
		//优化
		/*pSeq->array=(int *)realloc(pSeq->array,pSeq->capacity*2*sizeof(int));
		pSeq->capacity=pSeq->capacity*2;*/
		printf("pSeq->capacity=%d\n",pSeq->capacity);
	}
}
//表的初始化
void InitSeqlist(Seqlist *pSeq)
{
	assert(pSeq);
	pSeq->array=(int *)malloc(CAPACITY*sizeof(int));
	pSeq->size=0;
	pSeq->capacity=CAPACITY;
	printf("pSeq->size=%d\n",pSeq->size);
	printf("pSeq->capacity=%d\n",pSeq->capacity);
}
//输出表里数据
void PrintSeqlist(Seqlist *pSeq)
{
	int i=0;
	assert(pSeq);
	for(i=0;i<pSeq->size;i++)
	{
		printf("%d ",pSeq->array[i]);
	}
	printf("pSeq->size=%d\n",pSeq->size);
}
//增加数据
void PushBack(Seqlist *pSeq,int x)
{
	ExpendSeqlist(pSeq);
	pSeq->array[pSeq->size++]=x;
	printf("pSeq->size=%d\n",pSeq->size);
}
//从后往前减少数据
void PopBack(Seqlist *pSeq)
{
	assert(pSeq);
	if(pSeq->size==0)
	{
		printf("seqlist is null\n");
		return ;
	}
	pSeq->size--;
}
//在最前面写入数据x
void PushFront(Seqlist *pSeq,int x)
{
	int i=0;
	ExpendSeqlist(pSeq);
	for(i=pSeq->size-1;i>=0;i--)
	{
		pSeq->array[i+1]=pSeq->array[i];
	}
	pSeq->array[0]=x;
	pSeq->size++;
}
//删除最前面的数据
void PopFront(Seqlist *pSeq)
{
	int i=0;
	assert(pSeq);
	if(pSeq->size==0)
	{
		printf("seqlist is null\n");
		return ;
	}
	for(i=1;i<=pSeq->size-1;i++)
	{
		pSeq->array[i-1]=pSeq->array[i];
	}
	pSeq->size--;
}
//在index位置上插入x数据
void Insert(Seqlist *pSeq,int index ,int x)
{	int i=0;
	ExpendSeqlist(pSeq);	
	for(i=pSeq->size-1;i>=index;i--)
	{
		pSeq->array[i+1]=pSeq->array[i];
	}
	pSeq->array[index]=x;
	pSeq->size++;
}
//修改index位置的数据
void Modifity(Seqlist *pSeq,int index,int x)
{
	assert(pSeq);
	assert(index<pSeq->size);
	pSeq->array[index]=x;
}
//删除index位置的数据
void Remove(Seqlist *pSeq,int index)
{
	int i=0;
	assert(pSeq);
	if(pSeq->size==0)
	{
		printf("seqlist is null\n");
		return ;
	}
	for(i=index+1;i<=pSeq->size-1;i++)
	{
		pSeq->array[i-1]=pSeq->array[i];
	}
	pSeq->size--;
}
//查找某数据
FindRet find(Seqlist *pSeq,int x,int index)
{
	int i=0;
	FindRet ret;
	//assert(index<pSeq->size);
	assert(pSeq);
	ret.isFind=FALSE;
	for(;index<pSeq->size;index++)
	{
		if(pSeq->array[index]==x)
		{
			ret.isFind=TRUE;
			ret.index=index;
			return ret;
		}
	}
	return ret;
}

//删除某数据	
//all为FALSE删除数据的第一次出现，all为TRUE，该数据被全部删除		
Tag Erase(Seqlist *pSeq,int x,Tag all)
{
	
	Tag success=FALSE;
	FindRet ret;
	assert(pSeq);
	ret=find(pSeq,x,0);
	while(ret.isFind==TRUE)
	{
		Remove(pSeq,ret.index);
		if(all==TRUE)
		{
			ret=find(pSeq,x,ret.index);//紧接着向后查找，不用从头开始
			success=TRUE;
		}
		else
		{
			break;
		}
	}
	return success;
}

//冒泡排序
void BubbleSeqlist(Seqlist *pSeq)
{
	int i=0;
	int j=0;
	char tmp;
	assert(pSeq);
	for(i=0;i<pSeq->size-1;i++)
	{
		for(j=0;j<pSeq->size-1-i;j++)
		{
			if(pSeq->array[j]<pSeq->array[j+1])
			{
				tmp=pSeq->array[j];
				pSeq->array[j]=pSeq->array[j+1];
				pSeq->array[j+1]=tmp;
			}
		}
	}
}
//选择排序
void SelectSeqlist(Seqlist *pSeq)
{
	int i=0;
	int j=0;
	int k=0;
	char tmp;
	assert(pSeq);
	for(i=0;i<pSeq->size-1;i++)
	{
		k=i;
		for(j=i+1;j<pSeq->size;j++)
		{
			if(pSeq->array[k]>pSeq->array[j])
			{
				k=j;
			}
		}
		if(k!=i)
		{
			tmp=pSeq->array[i];
			pSeq->array[i]=pSeq->array[k];
			pSeq->array[k]=tmp;
		}
	}
}

//二分搜索
FindRet BinarySearch(Seqlist *pSeq,int x)
{
	int i=0;
	FindRet ret;
	int left=0;
	int right=pSeq->size-1;
	int mid=0;
	assert(pSeq);
	while(left<=right)
	{
		mid=(left+right)/2;
		if(x==pSeq->array[mid])
		{
			ret.isFind=TRUE;
			ret.index=mid;
			return ret;
		}
		if(x>pSeq->array[mid])
		{
			left=mid+1;
		}
		if(x<pSeq->array[mid])
		{
			right=mid-1;
		}
	}
	ret.isFind=FALSE;
	return ret;
}


//main.c
#include<stdio.h>
#include"seqlist.h"
void Test()
{
	 Seqlist s;
	 FindRet ret;
	 InitSeqlist(&s);
	 PrintSeqlist(&s);
	 printf("写入数据：");
	 PushBack(&s,1);
	 PushBack(&s,2);
	 PushBack(&s,3);
	 PushBack(&s,4);
	 PushBack(&s,5);
	 printf("输出表中数据：\n");
	 PrintSeqlist(&s);
	 printf("从后往前删除数据：\n");
	 PopBack(&s);
	 PrintSeqlist(&s);
	 printf("在表最前面插入数据：\n");
	 PushFront(&s,5);
	 PrintSeqlist(&s);
	 printf("删除表最前面数据：\n");
	 PopFront(&s);
	 PrintSeqlist(&s);
	 printf("在index插入数据：\n");
	 Insert(&s,2 ,8);
	 PrintSeqlist(&s);
	 printf("修改index位置数据：\n");
	 Modifity(&s,2,6);
	 PrintSeqlist(&s);
	 printf("删除index位置数据：\n");
	 Remove(&s,2);
	 PrintSeqlist(&s);
	 printf("找到某数据位置：\n");
	 ret=find(&s,3,0);
	 printf("ret=%d\n",ret.index);
	 printf("删除某数据：\n");
	 Erase(&s,1,FALSE);
	 PrintSeqlist(&s);
	 printf("冒泡排序：\n");
	 BubbleSeqlist(&s);
	 PrintSeqlist(&s);
	 printf("选择排序：\n");
	 SelectSeqlist(&s);
	 PrintSeqlist(&s);
	 printf("二分搜索某数据：\n");
	 ret=BinarySearch(&s,3);
	 printf("ret=%d\n",ret.index);
}
int main()
{
	Test();
	return 0;
}