数据结构顺序表

原创 2018年04月15日 21:20:17

数据结构顺序表算法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

数据结构—顺序表的插入

数据结构第一篇-顺序表   刚开始复习数据结构,感觉还是蛮吃力的,基础不是很好有太多不明白的点了,还好有个耐心极棒的蓝朋友(献花),虽然现在还不是很明白,但是我相信继续学习下去一定会拨开乌云的。 知...
  • xulu95
  • xulu95
  • 2017-03-19 14:44:06
  • 620

数据结构(一)——顺序表(C语言实现)

顺序表的简单实现
  • flueky
  • flueky
  • 2016-09-30 18:00:37
  • 7107

数据结构 顺序表(c++实现)

  • 2015年09月27日 20:17
  • 50KB
  • 下载

数据结构学习心得——顺序表

一、线性表的定义线性表是具有相同特性数据元素的一个有限序列。该序列中所含元素的个数叫做线性表的长度,用n(n>0)表示。二、线性表的存储结构线性表的存储结构有顺序存储和链式存储两种。前者称为顺序表,后...
  • u012350430
  • u012350430
  • 2017-08-16 23:07:06
  • 693

数据结构之顺序表的建立

#include #include #include #define OK 1 #define ERROR 0 #define OVERFLOW 0 #define LIST_INI...
  • tao_benet
  • tao_benet
  • 2012-03-15 17:01:10
  • 446

数据结构——顺序表(c++)

数据结构——顺序表(c++)
  • cckevincyh
  • cckevincyh
  • 2015-06-18 12:02:45
  • 656

《数据结构》 顺序表常用操作代码集合

Ps:每段代码中,添加了署名Solo的是博主自己写的,其余来自课本或者老师。//定义线性表的存储结构 #define MAXSIZE 100 typedef struct { ElemType...
  • Solo95
  • Solo95
  • 2016-03-23 18:07:20
  • 1068

【c++版数据结构】之顺序表的实现

SeqList.h #ifndef SEQLIST_H #define SEQLIST_H #include using namespace std; typedef enum{TRUE,FALS...
  • ZongYinHu
  • ZongYinHu
  • 2015-08-19 13:32:12
  • 1587

数据结构——创建顺序表

一、实验目的1、熟练掌握线性表的结构特点,掌握顺序表的基本操作。 2、巩固 C++相关的程序设计方法与技术。 3、学会使用顺序表解决实际问题。 二、实验内容1、顺序表的建立与操作实现 ...
  • a2009a11a29
  • a2009a11a29
  • 2017-09-18 21:55:58
  • 469

数据结构中顺序表的相关查找算法

今天给大家带来的是相关数据结构的查找算法,相信读过前几篇相关数据结构构建的读者应该能体会到两种常用数据结构的相关基础知识。 查找算法的基础就需要数据结构的支撑,很显然,我们需要掌握的是顺序表和动态链...
  • qq_15718789
  • qq_15718789
  • 2016-10-08 16:13:36
  • 1597
收藏助手
不良信息举报
您举报文章:数据结构顺序表
举报原因:
原因补充:

(最多只允许输入30个字)