剑魄未改的博客

“就凭你提着把破剑也想闯荡江湖?”

数据结构顺序表

数据结构顺序表算法C语言实现

准备-函数结果状态码

#include <stdlib.h>
#include <malloc.h>
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define LIST_INIT_SIZE 10//线性表储存空间的初始分配量 
#define LISTADD 5//线性表储存空间的分配增量 
typedef int ElemType;//定义顺序表元素的类型为int(一般用于返回所取元素)
typedef int Status;//Status是函数的类型,其值是函数结果状态代码 ,如OK等
typedef int Boolean;//Boolea是布尔类型 
typedef struct {
    ElemType *elem;//储存空间基地址
    int length;//当前长度
    int listsize;//当前分配的储存总容量(sizeof(ElemType)为单位 
}Sqlist; 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

顺序表示的线性表的基本操作(12个包括了书中有关操作的算法)

#include <stdio.h>
// 1,  InitList(&L) 操作结果:构造一个空的顺序表L。书中算法2.3
Status InitList(Sqlist *L){
    (*L).elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));/*L.elem作为指针指向内
    存,malloc用于分配内存,而内存为LIST_INIT_SIZE*sizeof(ElemType)这么大*/
    if(!(*L).elem) exit(OVERFLOW);//exit(-1) 存储空间失败
    (*L).length = 0;//初始化列表长度为0
    (*L).listsize = LIST_INIT_SIZE;//初始化空表的储存总容量

    return OK;//返回状态码 1 
}
// 2,  DestroyList(&L)  初始条件:顺序表L已存在。 操作结果:销毁顺序表L。
Status DestroyList(Sqlist *L){
    free((*L).elem);//释放L.elem这个指针指向的内存
    (*L).elem = NULL;//指向空
    (*L).length = 0;//将长度赋值为0
    (*L).listsize = 0;//将当前分配的储存总容量变为0

    return OK; 
} 
//3, ClearList(&L) 初始条件:顺序表已经存在。操作结果:将L重置为空表。
Status ClearList(Sqlist *L){
    (*L).length = 0;//清空当前长度 
    return OK; 
} 
//4. ListEmpty(L) 初始条件:顺序表L已存在。操作结果:判断若顺序表L为空返回TRUE,否则返回FLASE。
Status ListEmpty(Sqlist L){
    if(L.length ==0){
        return TRUE;
    }else{
        return FALSE;
    }
}
//5, Listlength(L) 初始条件:顺序表已存在。操作结果:返回L中的数据元素的个数
Status ListLength(Sqlist L){
    return L.length;
} 
//6, GetElem(L,i,&e) 初始条件:顺序表已存在(l<=i<=ListLength(L)). 操作结果:用e返回L中第i个数据元素的值。
Status GetElem(Sqlist L,int i,ElemType *e){
    if(i<1||i>L.length){
        exit(ERROR);
    }
    *e = L.elem[i-1];//*e = *(L.elem+i-1)
    return OK; 
} 
//7, LocateElem(L,e,compare())  初始条件:顺序表L已存在,compare()的数据元素判定函数。
//  操作结果:返回L中第1个与e的满足关系compare()的数据元素的位序。若这样的数据元素不存在,则返回0.
//       书中算法2.6(进行两个元素之间的比较) 时间复杂度为O(L.length)
int  LocateElem(Sqlist L,ElemType e,Status (*compare)(ElemType,ElemType)){//compare()形参是函数指针
/*

    */
    int i =1;            //i的初值为第一个元素的位序
    ElemType *p=L.elem;  //p的初值为第一个元素的存储位置

    while(i<=L.length && !(*compare)((*p++),e)){
        ++i;
    }
    if(i<=L.length) return i;
    else
    return 0;  
}
//8,    PriorElem(L,cur_e,&pre_e)  初始条件:顺序表L已存在。
//操作结果:若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱,否则操作失败,pre_e无定义。
Status PriorElem(Sqlist L,ElemType cur_e,ElemType *pre_e){
    ElemType *p = L.elem+1;//指针变量p指向第二个数据元素
    int i=2;

    while(i<=L.length &&(*p)!=cur_e){
        p++;
        ++i;
    } 
    if(i>=L.length){
        return ERROR;
    }else{
        *pre_e=(*--p);  //p先自减,pre_e就指向该数据元素的前驱结点
        return OK;
    }
}
//9,     NextElem(L,cur_e,&next_e)  初始条件:顺序表L已存在。
//操作结果:若cur_e是L的数据元素,且不是第一个,则用next_e返回它的前驱,否则操作失败,next_e无定义。
Status   NextElem(Sqlist L,ElemType cur_e,ElemType *next_e){
    ElemType *p =L.elem;
    int i=1;

    while(i<L.length && (*p)!=cur_e){
        p++;
        ++i;
    }

    if(i>=L.length){
        return ERROR;
    }else{
        *next_e =(*++p);  //next_e指向该数据元素的后继结点
        return OK;
    }
}

此处是方法中的插入与删除,重点讲解

//10,  ListTraverse(L,visit())  
/*   初始条件:顺序线性表L已存在。
     操作结果:依次对L的每个数据元素调用函数visit()。一旦visit()失败,则操作失败 */
Status ListTraverse(Sqlist L,void (*visit)(ElemType*)){  //visit()的形参加&,意味着visit()可以修改L.elem中数据元素的值
    int i=1;
    ElemType *p=L.elem;
    for(i=1;i<=L.length;i++)
         (*visit)(p++);
    printf("\n");
    return OK;
}
//11,   ListInsert(Sqlist *L,i,e)  初始条件:顺序表L已存在,1<=i<=ListLength(L)+1。
                                //操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1
/*
    书中算法2.4
    算法语言描述:
          1,检查插入位置i的有效性,插入位置i的有效范围是1<=i<=ListLength(L)+1(注意:顺序表尾也能执行插入操作)。
          2,在插入之前先检查顺序表是否已满(判断顺序表的length是否等于listsize),在顺序表满的时候不能进行插入运算,需要申请内存空间。
          3,后移i位置以后的数据元素,为新数据元素让去第i个位置。
          4,将新元素e插入第i个位置。
          5,将当前的顺序表length1.
*/
Status ListInsert(Sqlist *L,int i,ElemType e){
    ElemType *p,*q,*newbase = NULL;
    //第一步
    if(i<1||i>(*L).length+1){判断i的大小是否符合,否则报错
        return ERROR;//i的值不合法 
    } 
    //第二步
    if((*L).length >=(*L).listsize){//由于当前储存空间已经满了增加分配
        newbase = (ElemType *)realloc((*L).elem,((*L).listsize+LISTADD)*sizeof(ElemType));
        //之前定义了一个结构体,名为ElemType, 现在使用realloc()函数重新分配一块内存。
        //这个内存的大小为(L.lestsize+LISTADD)个 ElemType结构体.
        if(!newbase) exit(OVERFLOW);
        (*L).elem = newbase;//L.elem这个指针指向新的地址
        (*L).listsize +=LISTADD;  //增加存储容量

    }
    //第三步
    q =&((*L).elem[i-1]);  //q指针指向插入位置(或q =(*L).elem+i-1。)
    for(p =&((*L).elem[(*L).length-1]);p >=q;--p){ //或p =((*L).elem+(*L).length-1)
        *(p+1) =*p;//此处的for循环将所有在q插入位置之后的元素后羿
    }
        /*或
        int j;
        for(j =(*L).length;j >=i;--j){
            (*L).elem[j] =(*L).elem[j-1];  //*((*L).elem+j) =((*L).elem+j-1)
        }
        (*L).elem[j-1]=e;*/
    //第四步
    *q =e; //插入数据元素
    //第五步
    ++(*L).length;
    return OK;
}
//12, ListDelete(Sqlist &L,int i,ElemType &e) 初始条件:顺序线性表L已存在,1<=i<=ListLength(L) 
//                                              操作结果:删除L的第i个数据元素,并用e返回其值,L的长度减1 
/*
    书中算法2.5
    算法语言描述:
          1,检查插入位置i的有效性,删除位置i的有效范围是1<=i<=ListLength(L)。
          2,在插入之前先检查顺序表是否为空(length!=0)。
          3,前移i+1位置以后的数据元素(注意:从i+1的位置开始,要覆盖第i个位置)。
          4,将当前的顺序表length1.
*/
Status ListDelete(Sqlist *L,int i,ElemType e){
    ElemType *p,*q,*newbase;
    //第一步,i的值不合法
    if(i<1||i>(*L).length+1){
        return ERROR; 
    } 
    //第二步,当储存空间已经满了时增加空间分配
    if((*L).length >= (*L).listsize){
        newbase = (ElemType *)realloc((*L).elem,((*L).listsize+LISTADD)*sizeof(ElemType));
        if(!newbase) exit(OVERFLOW);
        (*L).elem = newbase;
        (*L).listsize += LISTADD;
    } 
    //第三步
    q = &((*L).elem[i-1]);
    for(p =&((*L).elem[(*L).length-1]);p >=q;--p){ //或p =((*L).elem+(*L).length-1)
        *(p+1) =*p;
    }
    //第四步
    *q = e; 
    ++(*L).length;
    return OK; 

} 

那么以上就是数据结构顺序表的全部内容了,希望能够对大家有所帮助。

                                                                                作者:剑魄未改

GITHUB地址

ps:相关代码及算法引用CSDN和大话数据结构,并加入自己的修改,有错误请留言,(^__^)

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/Tryantking/article/details/79953456
文章标签: 学习 数据结构
个人分类: 数据结构
下一篇约瑟夫环双向链表
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭