标签：
#include<stdio.h>
#include<stdlib.h>
//线性表的动态分配顺序存储结构
#define LIST_INIT_SIZE 100//线性表存储空间的初始分配量
#define LISTINCREMENT 10//线性表存储空间的分配增量
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;//Status是函数的类型，其值是函数结果状态代码
typedef int ElemType;
//线性表的动态分配顺序存储结构
typedef struct{
ElemType *elem;//存储空间基址
int length;//当前长度
int listsize;//当前分配的存储容量的（以sizeof(ElemType)为单位）
}SqlList;
//构造一个空的线性表L
//O(1)
Status InitList_Sq(SqlList &L)
{
//构造一个空的线性表
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem)
{
printf("线性表L构造失败！\n");
exit(OVERFLOW);//存储分配失败
}
L.length=0;//空表的长度为0
L.listsize=LIST_INIT_SIZE;//初始的存储容量
printf("线性表L构造成功！\n");
return OK;
}//InitList_Sq
//销毁线性表L
//O(1)
Status DestroyList_Sq(SqlList &L)
{
if(L.elem!=NULL)
{
free(L.elem);
L.elem=NULL;
L.length=0;
L.listsize=0;
printf("销毁线性表L成功\n");
return OK;
}else
{
printf("线性表L不存在\n");
}
return ERROR;
}//DestroyList_Sq
//将L重置为空表
//O(1)
Status ClearList_Sq(SqlList &L)
{
if(L.elem!=NULL)
{
L.length=0;
printf("已将线性表重置为空表！\n");
return OK;
}else
printf("线性表重置为空表失败！\n");
return ERROR;
}//ClearList_Sq
//若L为空表，则返回TRUE，否则返回FALSE
//O(1)
Status ListEmpty_Sq(SqlList L)
{
if(L.elem!=NULL&&L.length==0)
{
printf("线性表L为空表\n");
return TRUE;
}else if(L.elem!=NULL)
{
printf("线性表L不为空表\n");
return FALSE;
}else{
printf("线性表L不存在\n");
return FALSE;
}
}//ListEmpty_Sq
//返回L中数据元素的个数
//o(1)
Status ListLength_Sq(SqlList L)
{
if(L.elem!=NULL)
{
printf("线性表L的长度为%d\n",L.length);
return L.length;
}else
printf("线性表L不存在");
return -1;
}//ListLength_Sq
//用e返回L中第i个元素的值
//O(1)
void GetElem_Sq(SqlList L,int i,ElemType &e)
{
if(L.elem!=NULL)
{
if(i<1||i>L.length)
printf("访问位置非法");
else
{
e=L.elem[i-1];
}
}else
printf("线性表L不存在");
}//GetElem_Sq
//返回L中第一个与e满足关系compare()的元素的位序。若这样的数据元素不存在，则返回值为0
//O(n)
Status LocateElem_Sq(SqlList L,ElemType e,Status (*compare)(ElemType,ElemType))
{
int i=1;
ElemType *p=L.elem;
if(L.elem!=NULL)
{
while(i<=L.length&&!(*compare)(*p++,e))
{
++i;
}
if(i<=L.length)
{
printf("找到元素e在线性表L的位置为第%d个",i);
return i;
}else
{
printf("线性表L中不存在元素e");
return 0;
}
}else
printf("线性表L不存在");
return 0;
}//LocateElem_Sq
//若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱,否则失败,pre_e无定义
//O(n)
Status PriorElem_Sq(SqlList L,ElemType cur_e,ElemType *pre_e)
{
int i=2;
if(L.elem!=NULL)
{
while(i<=L.length)
{
if(cur_e==L.elem[i-1])
*pre_e=L.elem[i-2];
++i;
return OK;
}
return ERROR;
}else
printf("线性表L不存在");
return ERROR;
}//PriorElem_Sq
//若cur_e是L的数据元素,且不是最后一个，则用next_e返回它的后继，否则操作失败，next_e无定义
//O(n)
Status NextElem_Sq(SqlList L,ElemType cur_e,ElemType *next_e)
{
int i=1;
if(L.elem!=NULL)
{
while(i<=L.length-1)
{
if(cur_e==L.elem[i-1])
*next_e=L.elem[i];
++i;
return OK;
}
return ERROR;
}else
printf("线性表L不存在");
return ERROR;
}//NextElem_Sq
//在L中第i个位置之前插入新的数据元素e，L的长度加1
//一般情况下，在第i(1<=i<=n)个元素之前插入一个元素时，需要将第n至第i（共n-i+1）个元素向后移动一个位置
//假如pi是在第i个元素之前插入一个元素的概率，则在长度为n线性表中插入一个元素时所需移动元素的期望值（平均次数）为E(is)=pi(n-i+1),(i从1到n+1的和式)。
//不失一般性，我们可以假定在线性表的任何位置上插入，即，pi=1/(1+n),则上式可简化为，E(is)=n/2。可见在顺序存储结构的线性表插入一个元素，平均约移动表中一半元素。若表长为n，则这个算法的时间复杂度为O(n)。
Status ListInsert_Sq(SqlList &L,int i,ElemType e)
{
if(L.elem!=NULL)
{
if(i<1||i>L.length+1) return ERROR;
if(L.length>=L.listsize)
{
ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase)
{
exit(OVERFLOW);//存储分配失败
}
L.elem=newbase;//新基址
L.listsize+=LISTINCREMENT;//增加存储容量
}
ElemType *q,*p;
q=&L.elem[i-1];
for(p=&L.elem[L.length-1];p>=q;p--) *(p+1)=*p;//插入位置及以后元素后移
*q=e;//插入e
++L.length;//表长增1
return OK;
}else
printf("线性表L不存在");
return ERROR;
}//ListInsert_Sq
//删除L的第i个数据元素，并用e返回其值,L的长度减1
//一般情况下，删除第（1<=i<=n）个元素时需从第i+1至第n个（共n-i）个元素依次向前移动一个位置
//假如qi是在第i个删除第i个元素的概率，则在长度为n的线性表中删除一个元素时所需移动元素的次数的期望（平均次数为）E(dl)=qi(n-i),(i从n的和式)。
//不失一般性，我们可以假定在线性表的任何位置上删除元素都是等概率的，即qi=1/n,则上式可简化为,E(dl)=(n-1)/2。可见在顺序存储结构的线性表删除一个元素，平均约移动表中一半元素。若表长为n，则这个算法的时间复杂度为O(n)。
Status ListDelete_Sq(SqlList &L,int i,ElemType &e)
{
if(L.elem!=NULL)
{
if(i<1||i>L.length) return ERROR;//i的位置不合法
ElemType *p,*q;
p=&L.elem[i-1];//p为被删除元素的位置
e=*p;//被删除的元素赋给e
q=L.elem+L.length-1;//表尾元素的位置
for(++p;p<=q;++p) *(p-1)=*p;//被删除元素之后的元素左移
--L.length;
return OK;
}else
printf("线性表L不存在");
return ERROR;
}//ListDelete_Sq
//依次对L的每个数据元素调用函数visit().一旦visit失败，则操作失败
//O(n)
void ListTraverse_Sq(SqlList L,Status (*visit)(ElemType))
{
if(L.elem!=NULL)
{
if(L.length==0)
{
printf("线性表为空\n");
}else
{
for(int i=1;i<=L.length;i++)
{
if((*visit)(L.elem[i-1]))
{
}
else
{
printf("数据遍历失败");
return;
}
}
printf("线性表为：");
for(int i=1;i<=L.length;i++)
{
printf("%d,",L.elem[i-1]);
}
}
}else
{
printf("线性表L不存在\n");
}
}//ListTraverse_Sq
//L中第i个元素赋值同e的值
//O(1)
Status PutElem_Sq(SqlList L,int i,ElemType &e)
{
if(L.elem!=NULL)
{
if(i<1||i>L.length)
{
printf("赋值在线性表中的位置非法\n");
return ERROR;
}else{
L.elem[i-1]=e;
return OK;
}
}
else
{
printf("线性表L不存在\n");
return ERROR;
}
}//PutElem_Sq
//两个顺序表合并
//O(La.length+Lb.length)
void MergeList_Sq(SqlList La,SqlList Lb,SqlList &Lc)
{
//已知顺序线性表La和Lb的元素按值非递减排列
//归并La和Lb得到新的顺序线性表Lc,Lc的元素也按值非递减排列
ElemType *pa=La.elem;
ElemType *pb=Lb.elem;
Lc.listsize=Lc.length=La.length+Lb.length;
ElemType *pc=Lc.elem=(ElemType *)malloc(Lc.listsize*sizeof(ElemType));
if(!Lc.elem) exit(OVERFLOW);//存储分配失败
ElemType *pa_last=La.elem+La.length-1;
ElemType *pb_last=Lb.elem+Lb.length-1;
while(pa<=pa_last&&pb<=pb_last)
{
if(*pa<=*pb)*(pc++)=*(pa++);
else *(pc++)=*(pb++);
}
while(pa<=pa_last) *(pc++)=*(pa++);//插入La的剩余元素
while(pb<=pb_last) *(pc++)=*(pb++);//插入Lb的剩余元素
}//MergeList_Sq
int main()
{
SqlList L,La,Lb,Lc;
ElemType i,e;
//初始化线性表
InitList_Sq(L);
InitList_Sq(La);
InitList_Sq(Lb);
for(i=1;i<=LISTINCREMENT;i++)
{
ListInsert_Sq(La,i,i);
ListInsert_Sq(Lb,i,i+1);
}
MergeList_Sq(La,Lb,Lc);
printf("线性表La中的元素为:");
for(i=1;i<=La.length;i++)
{
GetElem_Sq(La,i,e);
printf("%d,",e);
}
printf("\n线性表La中的元素为:");
for(i=1;i<=Lb.length;i++)
{
GetElem_Sq(Lb,i,e);
printf("%d,",e);
}
printf("\n线性表Lc中的元素为:");
for(i=1;i<=Lc.length;i++)
{
GetElem_Sq(Lc,i,e);
printf("%d,",e);
}
DestroyList_Sq(La);
DestroyList_Sq(Lb);
DestroyList_Sq(Lc);
/*for(i=1;i<=LISTINCREMENT;i++)
{
L.elem[i-1]=i;
L.length++;
}*/
//给线性表赋值
/*for(i=1;i<=LISTINCREMENT;i++)
{
ListInsert_Sq(L,i,i);
}*/
/*printf("线性表中的元素为:");
for(i=1;i<=LISTINCREMENT;i++)
{
GetElem_Sq(L,i,e);
printf("%d,",e);
}*/
/*printf("线性表L元素为:");
//直接给线性表赋值，有可能会产生溢出现象，如果下标超出内存分配上届
for(i=1;i<=LISTINCREMENT;i++)
{
printf("%d,",L.elem[i-1]);
}*/
//遍历整个线性表L
//ListTraverse_Sq(L);
//得到线性表长度
ListLength_Sq(L);
//判断线性表是否为空
ListEmpty_Sq(L);
//清空线性表中的数据
ClearList_Sq(L);
//销毁整个线性表
DestroyList_Sq(L);
//清空线性表中的数据
ClearList_Sq(L);
getchar();
getchar();
return 0;
}
数据结构线性表的动态分配顺序存储结构算法c语言具体实现和算法时间复杂度分析
标签：
原文地址：http://www.cnblogs.com/likewithyou/p/5838893.html
