数据结构---线性表---顺序存储结构

头文件

header.h

#ifndef _LIST_H
#define _LIST_H

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

#define MY_TYPE int   /*0:int 1:double 2:float 3:char*/
#define _MY_TYPE_ 0
#define LIST_INIT_SIZE 3   /*单位：MY_TYPE*/
#define LIST_INCRE_SIZE 2   /*单位：MY_TYPE*/

typedef enum status {ERROR, OK} St; /*0  1*/

typedef struct list_array{
    MY_TYPE *head_pointer;  /*指向存储空间基址*/
    int length;             /*当前长度*/
    int listsize;           /*当前分配的存储容量*/
}ALIST;

typedef St (*compare)(const MY_TYPE, const MY_TYPE);
/*初始化*/
St init_alist(ALIST *Lpointer);
/*销毁*/
St destroy_alist(ALIST *Lpointer);
/*清空*/
St clear_alist(ALIST *Lpointer);
/*判断线性表是否为空*/
St alist_empty(const ALIST *Lpointer);
/*表长*/
int alist_length(ALIST *Lpointer);
/*取给定位置的元素用*pe返回*/
St get_elem(const ALIST *Lpointer, const int i, MY_TYPE *pe);
/*查看满足compare关系的元素的位置*/                      /*pc简单设定为大于小于等于*/
int locate_elem(const ALIST *Lpointer, const MY_TYPE e, compare pc);
/*取某个元素的前驱*/
St prior_elem(const ALIST *Lpointer, const MY_TYPE cur_e, MY_TYPE *ppre_e);
/*取某个元素的后继*/
St next_elem(const ALIST *Lpointer, const MY_TYPE cur_e, MY_TYPE *ppre_e);
/*在数组给定下标为i的位置插入e*/
St alist_insert(ALIST *Lpointer, const int i, const MY_TYPE e);
/*增加一个元素在表尾*/
St alist_add(ALIST *Lpointer, MY_TYPE e);
/*在数组给定下标为i的位置删除此元素用*P_e返回*/
St alist_delete(ALIST *Lpointer, const int i, MY_TYPE *p_e);
/*修改指定位置的元素*/
St alist_mod(ALIST *Lpointer, const int i, MY_TYPE mod_e);
/*遍历线性表*/
St alist_visit(const ALIST *Lpointer);

/*compare--->equal*/
St cmp_equal(MY_TYPE e1, MY_TYPE e2);
/*compare--->less*/
St cmp_less(MY_TYPE e1, MY_TYPE e2);
/*compare--->more*/
St cmp_more(MY_TYPE e1, MY_TYPE e2);

#endif /* _LIST_H */

顺序表基本操作

初始化

/*初始化*/
St init_alist(ALIST *Lpointer){
    Lpointer->head_pointer = (MY_TYPE *)calloc(LIST_INIT_SIZE, sizeof(MY_TYPE));
    if(!Lpointer->head_pointer){
        return ERROR;
    }
    Lpointer->length = 0;
    Lpointer->listsize = LIST_INIT_SIZE;
    return OK;
}

销毁

/*销毁*/
St destroy_alist(ALIST *Lpointer){
    Lpointer->length = 0;
    Lpointer->listsize = 0;
    free(Lpointer->head_pointer);
    Lpointer->head_pointer = NULL;
    return OK;
}

清空

/*清空*/
St clear_alist(ALIST *Lpointer){
    Lpointer->length = 0;
    memset(Lpointer->head_pointer, 0, Lpointer->listsize);
    return OK;
}

判断线性表是否为空

/*判断线性表是否为空*/
St alist_empty(const ALIST *Lpointer){
    if(Lpointer->length)
        return ERROR;
    else
        return OK;
}

表长

/*表长*/
int alist_length(ALIST *Lpointer){
    return (Lpointer->length);
}

取给定位置的元素用*pe返回

/*取给定位置的元素用*pe返回*/
St get_elem(const ALIST *Lpointer, const int i, MY_TYPE *pe){
    if(i > -1 && i < Lpointer->length){
        *pe = *(Lpointer->head_pointer + i);
        return OK;
    }else{
        return ERROR;
    }
}

查看满足compare关系的元素的位置

/*查看满足compare关系的元素的位置*/                      /*pc简单设定为大于小于等于*/
int locate_elem(const ALIST *Lpointer, const MY_TYPE e, compare pc){
    int i = 0;
    for(; i < Lpointer->length; ++i){
        if((*pc)(*(Lpointer->head_pointer + i), e))
            break;
    }
    if(i < Lpointer->length)
        return i;
    else
        return -1;
}

取某个元素的前驱

/*取某个元素的前驱*/
St prior_elem(const ALIST *Lpointer, const MY_TYPE cur_e, MY_TYPE *ppre_e){
    int i = 0;
    for(; i < Lpointer->length; ++i){
        if(cur_e == *(Lpointer->head_pointer + i)){
            break;
        }
    }
    if(i > 0 && i < Lpointer->length){
        *ppre_e = *(Lpointer->head_pointer + i - 1);
        return OK;
    }else{
        return ERROR;
    }
}

取某个元素的后继

St next_elem(const ALIST *Lpointer, const MY_TYPE cur_e, MY_TYPE *ppre_e){
    int i = 0;
    for(; i < Lpointer->length; ++i){
        if(cur_e == *(Lpointer->head_pointer + i)){
            break;
        }
    }
    if(i > -1 && i < (Lpointer->length - 1)){
        *ppre_e = *(Lpointer->head_pointer + i + 1);
        return OK;
    }else{
        return ERROR;
    }
}

在数组给定下标为i的位置插入e

/*在数组给定下标为i的位置插入e*/
St alist_insert(ALIST *Lpointer, const int i, const MY_TYPE e){
    if(!(i > -1 && i <= Lpointer->length))
        return ERROR;
    if(Lpointer->length >= Lpointer->listsize){
        MY_TYPE *newpointer = (MY_TYPE *)realloc(Lpointer->head_pointer,        (Lpointer->listsize + LIST_INCRE_SIZE) * sizeof(MY_TYPE));
        if(!newpointer)
            return ERROR;
        Lpointer->head_pointer = newpointer;
        Lpointer->listsize += LIST_INCRE_SIZE;
    }
    for(int j = (Lpointer->length - 1); j > i; --j)
        *(Lpointer->head_pointer + j + 1) = *(Lpointer->head_pointer + j);
    *(Lpointer->head_pointer + i) = e;
    ++Lpointer->length;
    return OK;
}

增加一个元素在表尾

/*增加一个元素在表尾*/
St alist_add(ALIST *Lpointer, MY_TYPE e){
    if(!e)
        return ERROR;
    if(Lpointer->length >= Lpointer->listsize){
        MY_TYPE *newpointer = (MY_TYPE *)realloc(Lpointer->head_pointer,        (Lpointer->listsize + LIST_INCRE_SIZE) * sizeof(MY_TYPE));
        if(!newpointer)
            return ERROR;
        Lpointer->head_pointer = newpointer;
        Lpointer->listsize += LIST_INCRE_SIZE;
    }
    *(Lpointer->head_pointer + Lpointer->length) = e;
    ++Lpointer->length;
    return OK;
}

在数组给定下标为i的位置删除此元素用*P_e返回

/*在数组给定下标为i的位置删除此元素用*P_e返回*/
St alist_delete(ALIST *Lpointer, const int i, MY_TYPE *p_e){
    if(!(i > -1 && i < Lpointer->length))
        return ERROR;
    *p_e = *(Lpointer->head_pointer + i);
    for(int j = (Lpointer->length - 1); j > i; --j)
        *(Lpointer->head_pointer + j - 1) = *(Lpointer->head_pointer + j);
    --Lpointer->length;
    return OK;
}

修改指定位置的元素

/*修改指定位置的元素*/
St alist_mod(ALIST *Lpointer, const int i, MY_TYPE mod_e){
    if(!(i > -1 && i < Lpointer->length))
        return ERROR;
    *(Lpointer->head_pointer + i) = mod_e;
    return OK;
}

遍历线性表

/*遍历线性表*/
St alist_visit(const ALIST *Lpointer){
    switch(_MY_TYPE_){
    case 0:
        {
            MY_TYPE *p = Lpointer->head_pointer;
            for(int i = 1; i <= Lpointer->length; ++i)
                printf("第%d个元素是：%d\n", i, (int)*p++);
            break;
        }
    case 1:
        {
            MY_TYPE *p = Lpointer->head_pointer;
            for(int i = 1; i <= Lpointer->length; ++i)
                printf("第%d个元素是：%lf\n", i, (double)*p++);
            break;
        }
    case 2:
        {
            MY_TYPE *p = Lpointer->head_pointer;
            for(int i = 1; i <= Lpointer->length; ++i)
                printf("第%d个元素是：%f\n", i, (float)*p++);
            break;
        }
    case 3:
        {
            MY_TYPE *p = Lpointer->head_pointer;
            for(int i = 1; i <= Lpointer->length; ++i)
                printf("第%d个元素是：%c\n", i, (char)*p++);
            break;
        }
    default:
        printf("属下无能\n");
        return ERROR;
    }
    return OK;
}

简单的比较函数

/*compare--->equal*/
St cmp_equal(MY_TYPE e1, MY_TYPE e2){
    if(e1 == e2)
        return OK;
    else
        return ERROR;
}
/*compare--->less*/
St cmp_less(MY_TYPE e1, MY_TYPE e2){
    if(e1 < e2)
        return OK;
    else
        return ERROR;
}
/*compare--->more*/
St cmp_more(MY_TYPE e1, MY_TYPE e2){
    if(e1 > e2)
        return OK;
    else
        return ERROR;
}

测试操作顺序表的基本功能

在main.中测试

#include "header.h"

int main()
{
    ALIST L = {0};
    init_alist(&L);
    printf("------------------------------------------------------------------\n");
    printf("地址：%d\n长度：%d\n容量：%d\n", L.head_pointer, L.length, L.listsize);
    printf("------------------------------------------------------------------\n");
    if(alist_empty(&L))
        printf("是否为空：OK\n");
    else
        printf("是否为空：NO\n");
    printf("------------------------------------------------------------------\n");
    printf("当前长度：%d\n", alist_length(&L));
    printf("------------------------------------------------------------------\n");
    alist_add(&L, 1);
    alist_add(&L, 2);
    alist_add(&L, 200);
    alist_add(&L, 34);
    alist_visit(&L);
    printf("------------------------------------------------------------------\n");
    MY_TYPE e1;
    alist_delete(&L, 2, &e1);
    printf("被删除的元素：%d\n", e1);
    printf("------------------------------------------------------------------\n");
    alist_visit(&L);
    printf("------------------------------------------------------------------\n");
    printf("地址：%d\n长度：%d\n容量：%d\n", L.head_pointer, L.length, L.listsize);
    printf("------------------------------------------------------------------\n");
    alist_insert(&L, 2, 200);
    alist_visit(&L);
    printf("------------------------------------------------------------------\n");
    printf("地址：%d\n长度：%d\n容量：%d\n", L.head_pointer, L.length, L.listsize);
    printf("------------------------------------------------------------------\n");
    MY_TYPE e2;
    if(next_elem(&L, 200, &e2))
        printf("200的后继：%d\n", e2);
    else
        printf("后继访问失败啦\n");
    printf("------------------------------------------------------------------\n");
    MY_TYPE e3;
    if(prior_elem(&L, 200, &e3))
        printf("200的前驱：%d\n", e3);
    else
        printf("前驱访问失败啦\n");
    printf("------------------------------------------------------------------\n");
    printf("%d\n", locate_elem(&L, 200, cmp_equal));
    printf("------------------------------------------------------------------\n");
    MY_TYPE e4;
    if(get_elem(&L, 4, &e4))
        printf("index=2:%d\n", e4);
    else
        printf("获取元素失败啦\n");
    printf("------------------------------------------------------------------\n");
    if(alist_mod(&L, 2, 300))
        alist_visit(&L);
    else
        printf("修改元素失败啦\n");
    printf("------------------------------------------------------------------\n");
    if(alist_empty(&L))
        printf("是否为空：OK\n");
    else
        printf("是否为空：NO\n");
    printf("------------------------------------------------------------------\n");
    if(clear_alist(&L)){
        printf("清空成功\n");
        alist_visit(&L);
    }
    else
        printf("清空失败\n");
    printf("------------------------------------------------------------------\n");
    printf("地址：%d\n长度：%d\n容量：%d\n", L.head_pointer, L.length, L.listsize);
    printf("------------------------------------------------------------------\n");
    if(destroy_alist(&L))
        printf("地址：%d\n长度：%d\n容量：%d\n", L.head_pointer, L.length, L.listsize);
    else
        printf("销毁失败啦\n");
    printf("------------------------------------------------------------------\n");

    return 0;
}

测试结果

------------------------------------------------------------------
地址：6893504
长度：0
容量：3
------------------------------------------------------------------
是否为空：OK
------------------------------------------------------------------
当前长度：0
------------------------------------------------------------------
第1个元素是：1
第2个元素是：2
第3个元素是：200
第4个元素是：34
------------------------------------------------------------------
被删除的元素：200
------------------------------------------------------------------
第1个元素是：1
第2个元素是：2
第3个元素是：34
------------------------------------------------------------------
地址：6893408
长度：3
容量：5
------------------------------------------------------------------
第1个元素是：1
第2个元素是：2
第3个元素是：200
第4个元素是：34
------------------------------------------------------------------
地址：6893408
长度：4
容量：5
------------------------------------------------------------------
200的后继：34
------------------------------------------------------------------
200的前驱：2
------------------------------------------------------------------
200的位置：2
------------------------------------------------------------------
获取元素失败啦
------------------------------------------------------------------
第1个元素是：1
第2个元素是：2
第3个元素是：300
第4个元素是：34
------------------------------------------------------------------
是否为空：NO
------------------------------------------------------------------
清空成功
------------------------------------------------------------------
地址：6893408
长度：0
容量：5
------------------------------------------------------------------
地址：0
长度：0
容量：0
------------------------------------------------------------------

原文地址：https://www.cnblogs.com/xinglichao/p/9164113.html

时间： 2024-10-09 02:31:59

数据结构---线性表---顺序存储结构的相关文章

数据结构——线性表顺序存储结构

 关于线性表 线性表是零个或者多个数据元素的集合.它主要有以下三个特征: 1:线性表的数据元素之间是有顺序的. 2:线性表中数据元素个数是有限的. 3:线性表中数据元素数据类型是相同的. 关于线性表的操作,主要有 创建线性表.销毁线性表.清空线性表.将元素插入线性表.将元素从线性表中删除.获取线性表中某个位置的元素.获取线性表的长度. 线性表主要有两种存储结构: 1:线性表的顺序存储结构,c语言中的数组及采用这种方式. 2:线性表的链式存储结构. 关于顺序存储结构 定义: 是指用一段地址连续的内

数据结构 - 线性表顺序存储结构

线性表 线性表是一种典型的线性结构.其基本特点是线性表中的数据元素是有序且是有限的.在这种结构中: ① 存在一个唯一的被称为"第一个"的数据元素: ② 存在一个唯一的被称为"最后一个"的数据元素: ③ 除第一个元素外,每个元素均有唯一一个直接前驱: ④ 除最后一个元素外,每个元素均有唯一一个直接后继. 线性表(Linear List) :是由n(n≧0)个数据元素(结点)a1,a2, -an组成的有限序列.该序列中的所有结点具有相同的数据类型. 线性表中的数据元素

线性表顺序存储结构的c语言实现

线性表顺序存储结构用C实现的操作 <1>声明一个线性表的顺序存储结构 <2> 初始化顺序线性表 <3>判断是否为空 <4>清空列表 <5>返回当前长度(线性表内元素个数) <6>返回L中第i个数据元素的值,注意i是指位置,第1个位置的数组是从0开始 <7>返回L中第1个与e满足关系的数据元素的位序.若这样的数据元素不存在,则返回值为0 <8>在L中第i个位置之前插入新的数据元素e,L的长度加1 <9>

数据结构与算法-线性表顺序存储结构删除操作的实现

这一章节我们来看一下线性表顺序存储结构删除操作的简单实现 package com.ray.testobject; public class Test { private Object[] list; public Object[] getList() { return list; } /** * 初始化list * * @param num * 元素个数 */ private void iniList(int num) { list = new Object[num]; for (int i =

数据结构与算法-总结线性表顺序存储结构的优缺点

这一章节主要总结线性表顺序存储结构的优缺点. 在总结之前,我们来讨论一下线性表顺序存储结构的执行方法的时间复杂度: 存储.读取:O(1) 插入.删除:O(n) 优点: 1.无需为表中的逻辑关系增加额外的存储空间 2.可以快速存取表中对象 缺点: 1.插入和删除需要移动大量的对象 2.存储设备的碎片化 3.当线性表过大的时候,很难确定长度 版权声明:本文为博主原创文章,未经博主允许不得转载.

线性表—顺序存储结构

线性表——顺序存储结构 我理解的顺序存储就是 存储的一组元素在内存中呈线性排列,地址相邻,就像火车一样,每个车厢都可以看做是一个元素,元素门内首尾相连且地址相邻,书看的是高一凡老师的书,学完后自己写一下总结和体会,一来加深印象,二来可以方便自己复习. 顺序存储结构似乎都是用数组来实现的,也就是以数组为核心,外面加了许多很方便的操作(函数)进行封装,然后就说这叫[顺序存储结构]——数组的深加工之后的产品 顺序存储结构的基本功能有以下几个: name:     sqlist private: T *

数据结构线性表顺序结构的实现

package com.he.list; import java.util.Arrays; import org.w3c.dom.ls.LSException; class ArrayList { private int length;// the list's length private int[] store;// store the data // initialize an empty list public ArrayList initList(String name) { retu

数据结构-线性表顺序存储（c++）

数据结构-线性表顺序存储(c++) 2018-09-06 List.h  //头文件 1 #define OK 1 2 #define ERRO0R 0 3 #define TRUE 1 4 #define FALSE 0 5 #define MAXSIZE 20 //存储空间初始分配量 6 7 typedef int Status; //Status 函数结果状态码 8 typedef int ElemType; //ElemType 据具体情况而定 9 10 class SqList 11

线性表-顺序存储结构

线性表-顺序存储结构 顺序存储结构 线性表的顺序存储结构,指的是用一段地址连续的存储单元依次存储线性表的数据元素 三个属性 存储空间的起始位置:数组data,它的存储位置就是存储空间的存储位置 线性表的最大存储容量:数组的长度MaxSize 线性表的当前长度:length 数据长度和线性表长度的区别 数据长度就是数组的长度,存放线性表的存储空间的长度,存储分配后这个量一般是不变的 线性表长度是线性表中数据元素的个数,随着线性表的删除插入操作,这个长度是改变的 在任何时刻,数组的长度大于等于线性表