静态，动态顺序表

#include<stdio.h>

#include<stdlib.h>

#include<assert.h>

#include<string.h>

#define _CRT_SECURE_NO_WARNINGS 1

#define MAX 10
typedef int DataType;
typedef struct SeqList
{
DataType arr[10];
int size;
}SeqList ,*PSeqList;
void InitSeqLis(PSeqList seq);
void Pushback(PSeqList seq,DataType data);
void Popback(PSeqList seq);
void PushFront(PSeqList seq,DataType data);
void PopFront(PSeqList seq);
void Insert(PSeqList seq,int pos,DataType data);
void Erase(PSeqList seq,int pos);
int Find(PSeqList seq,DataType data);
void Remmove(PSeqList seq,DataType data);
void Remmove_All(PSeqList seq,DataType data);
void Empty(PSeqList seq);
void Print(PSeqList seq,DataType data);




void InitSeqList(PSeqList seq)
{
assert(seq);
//int i=0;
//for(i=0;i<10;i++)
//{
// seq->arr[i]=0;
//}
//seq->size=0;
memset(seq->arr,0,10*sizeof(DataType));
seq->size=0;

}
void Pushback(PSeqList seq,DataType data)
{
assert(seq);
if(seq->size>=10)
{
printf("已满\n");
}
else
{
seq->arr[seq->size]=data;
}
seq->size++;
seq->size='\0';
}
void Popback(PSeqList seq)
{
assert(seq);
if(seq->size=0)
{
printf("表是空\n");
}
else
{
seq->size--;
seq->arr[seq->size]='\0';
}
}
void PushFront(PSeqList seq,DataType data)
{
int i=0;
assert(seq);
if(seq->size>=10)
{
printf("表已满\n");
}
else
{
for(i=seq->size;i>0;i--)
{
seq->arr[i]=seq->arr[i-1];
}
seq->arr[0]=data;
}
seq->size++;


}
void PopFront(PSeqList seq)   
{
int i=0;
assert(seq);
if(seq->size==0)
{
printf("表已空\n");
}
else
{
for(i=1;i<seq->size;i++)
{
seq->arr[i-1]=seq->arr[i];
}


}
}
void Insert(PSeqList seq,int pos,DataType data)
{
int i=0;
assert(seq);
if(seq->size>=10)
{ 
printf("表已满\n");
}
else if(pos>0&&pos<=seq->size)
{
for(i=seq->size;i>=pos;i--)
{
seq->arr[i+1]=seq->arr[i];
}
seq->arr[pos]=data;

}
seq->size++;
}
void Erase(PSeqList seq,int pos)
{
int i=0;
assert(seq);
if(seq->size==0)
{
printf("表已空\n");
return ;
}
else
{
for(i=pos;i<seq->size;i++)
{
seq->arr[i]=seq->arr[i+1];
}
}
seq->size--;
}
int Find(PSeqList seq,DataType data)
{
assert(seq);
int i,pos;
for(i=0;i<seq->size;i++)
{
if(seq->arr[i]==data)
{
pos=i;
}
}
if(i>=seq->size)
{
printf("不存在\n");
return -1;
}
return pos;
}
void Remmove(PSeqList seq, DataType data)
{
assert(seq);
if(seq->size==0)
{
printf("表已空\n");
return ;
}
int ret=Find(seq,data);
if(ret==-1)
{
printf("不存在这个数\n");
}
else
{
Erase(seq,ret);
}


}
void Remmove_All(PSeqList seq,DataType data)
{
assert(seq);
int i=0,j=0;
int count=0;
for(i=0;i<seq->size;i++)
{
if(seq->arr[i]==data)
{
count++;
for(j=i+1;j<seq->size;j++)
{
if(seq->arr[j]==data)
{
count++;
}
else
{
seq->arr[j-count]=seq->arr[j];
}
}
}
seq->size=seq->size-count;
return ;
}
printf("没有找到\n");
}
void Empty(PSeqList seq,DataType data)
{
assert(seq);
seq->size=0;
printf("表已清空\n");
}
void Print(PSeqList seq,DataType data)
{
assert(seq);
int i=0;
if(seq->size==0)
{
printf("表为空\n");
}
else
{
for(i=0;i<seq->size;i++)
{
printf("%d ",seq->arr[i]);
}
printf("\n");
}
}*/
//动态顺序表
#define _CRT_ _SECURE_ NO_WARNINGS 1
typedef int DataType;
typedef struct SeqList
{
DataType* arr;
int size;
int capatity;
}SeqList,*PSeqList;
void InitSeqList(PSeqList Dseq,DataType data);
void CheckCapatity(PSeqList Dseq,DataType data);
void PushBack(PSeqList Dseq,DataType data);
void PopBack(PSeqList Dseq);
void PushFront(PSeqList Dseq,DataType data);
void PopFront(PSeqList Dseq);
int Find(PSeqList Dseq,DataType data);
void Insert(PSeqList Dseq,int pos,DataType data);
void Erase(PSeqList Dseq,int pos);
void Mommove(PSeqList Dseq,DataType data);
void Mommove_All(PSeqList Dseq,DataType data);
void Print(PSeqList Dseq,DataType data);
int BinarySearch(PSeqList Dseq,DataType data);
void SeletSort(PSeqList Dseq);
void BubbleSort(PSeqList Dseq);


void PushBack(PSeqList Dseq,DataType data)
{
Insert(Dseq,Dseq->size,data);
}
void PopBack(PSeqList Dseq)
{
Erase(Dseq,Dseq->size-1);
}
void PushFront(PSeqList Dseq,DataType data)
{
Insert(Dseq,0,data);
}
void PopFront(PSeqList Dseq)
{
Erase(Dseq,0);
}
void InitSeqList(PSeqList Dseq,DataType data)
{
DataType *Temp=NULL;
    assert(Dseq);
Temp=(DataType*)malloc(3*sizeof(DataType));
if(Temp==NULL)
{
printf("out of memory\n");
exit(EXIT_FAILURE);
}
else
{
Dseq->arr=Temp;
Dseq->capatity=3;
Dseq->size=0;
}
}
void CheckCapatity(PSeqList Dseq)
{
assert(Dseq);
DataType* Temp=NULL;
if(Dseq->size>=Dseq->capatity)
{
Temp=(DataType*)malloc(2*Dseq->capatity*sizeof(DataType));\
if(Temp==NULL)
{
printf("out of memory\n");
exit(EXIT_FAILURE);
}
else
{
memcpy(Temp,Dseq->arr,Dseq->capatity*sizeof(DataType));
free(Dseq->arr);
Dseq->arr=Temp;
Dseq->capatity*=2;
}
}
}
void Insert(PSeqList Dseq,int pos,DataType data);
{
assert(Dseq);
int i=0;
CheckCapatity(Dseq);
if(pos>=0&&pos<=Dseq->size)
{
for(i=Dseq->size;i>pos;i++)
{
Dseq->arr[i]=Dseq->arr[i-1];
}
Dseq->arr[pos]=data;
Dseq->size++;
printf("添加成功\n");
}
else
{
printf("你输入的指定位置有误：\n");
}
}
void Erase(PSeqList Dseq,int pos)
{
assert(Dseq);
int i=0;
if(Dseq->size==0)
{
printf("表为空\n");
}
else if(pos>=0&&pos<=Dseq->size)
{
for(i=pos;i<Dseq->size;i++)
{
Dseq->arr[i]=Dseq->arr[i+1];
}
Dseq->size--;
printf("添加成功\n");
}
else
{
printf("你的输入有误：\n");
}
}
int BinarySeary(PSeqList Dseq,DataType data)//非递归
{
int left=0;
int right=Dseq->size-1;
int mid=0;
assert(Dseq);
BubbleSort(Dseq);
if(left>right)
{
return -1;
}
while(left<=right)
{
int mid=right-((right-left)>>1);
if(Dseq->arr[mid]==data)
{
return data;
}
else if(Dseq->arr[mid]<data)
{
left=mid+1;
}
else if(Dseq->arr[mid]>data)
{
right=mid-1;


}
}
return -1;
}
int BinarySearch(PSeqList Dseq,DataType data,int left,int right)
{
int left=0;
int right=Dseq->size-1;
assert(Dseq);
BubbleSort(Dseq);
if(left>right)
{
return -1;
}
while(left<=right)
{
int mid=right-((right-left)>>1);
if(Dseq->arr[mid]==data)
{
return data;
}
else if(Dseq->arr[mid]<data)
{
return BinarySearch(Dseq,data,mid+1,right);
}
else if(Dseq->arr[mid]>data)
{
return BinarySearch(Dseq,data,left,mid-1);
}
}
return -1;
}
void BulleSort(PSeqList Dseq,int n)
{
int i=0;
int j=0;
assert(Dseq);
for(i=0;i<Dseq->size;i++)
{
for(j=i+1;j<Dseq->size;j++)
{
if(n==1)
{
if(Dseq->arr[i]>Dseq->arr[j])
{
Dseq->arr[i]=Dseq->arr[i]+Dseq->arr[j];
Dseq->arr[j]=Dseq->arr[i]-Dseq->arr[j];
Dseq->arr[i]=Dseq->arr[i]-Dseq->arr[j];
}
}
else
{
if(Dseq->arr[i]<Dseq->arr[j])
{
Dseq->arr[i]=Dseq->arr[i]+Dseq->arr[j];
Dseq->arr[j]=Dseq->arr[i]-Dseq->arr[j];
Dseq->arr[i]=Dseq->arr[i]-Dseq->arr[j];
}
}
}
}
}
void SelectSort(PSeqList Dseq)
{
int i=0;
int j=0;
int max=0;
int min=0;
DataType temp1,temp2;
assert(Dseq);
for(i=0;i<=(Dseq->size-1)/2;i++)
{
min=i;
max=i;
for(j=i+1;j<Dseq->size-1;j++)
{
if(Dseq->arr[j]>Dseq->arr[max])
max=j;
if(Dseq->arr[j]<Dseq->arr[min])
min=j;
}
if(max!=Dseq->size-i-1)
{
temp1=Dseq->arr[Dseq->size-i-1];
Dseq->arr[Dseq->size-i-1]=Dseq->arr[max];
Dseq->arr[max]=temp1;
}
if(max!=i)
{
if(min!=i)
{
temp2=Dseq->arr[min];
Dseq->arr[min]=Dseq->arr[i];
Dseq->arr[i]=temp2;
}
}
}
printf("排序完成\n");
}