数据结构线性表的动态分配顺序存储结构算法c语言具体实现和算法时间复杂度分析

#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;
}

发表于 2016-09-04 11:29 小白的悟道阅读(3984) 评论(0) 编辑收藏举报

公告