用连续内存空间实现线性表

用结构体，实现了线性表初始化，删除索引的元素，查找元素，销毁线性表空间。

#include <stdio.h>
#include <stdlib.h>
#define error -1
#define ok 1


typedef unsigned unit;
typedef int eleType;

//定义一个结构体，用来存线性表的属性
typedef struct {
    eleType * element;//定义一个元素类型指针
    unit length;
    unit listsize;
}arrayList;

//初始化一个线性表,给定线性表的可容纳元素的总个数
arrayList array_init(unit len){
    arrayList t; // 构造一个结构体，类型是arrayList
    //分配一块堆内存空间，用来存储线性表
    t.element=(eleType *)malloc(len* sizeof(eleType)); //element是线性表元素所在内存的指针
    t.length = 0; //初始元素个数为0
    t.listsize = len;
    return t;
};

//顺序表的输出，按顺序遍历线性表，打印出来其中的每一个元素
void print_array(arrayList t){
    printf("the array elements are:\n");
    int i;
    for (i=0;i<t.length;i++){
        printf("%d\n",t.element[i]);
    };
};

//顺序表的取值，根据下标取值，如果下标不合法，返回一个错误值。如果下标合法，返回下标对应的值
eleType get_element(arrayList t,unit index){
    if (index<t.length){
        printf("the index is out range");
        return -1;
    }
    return t.element[index];
}

// 顺序表的查找，从左到右，遍历顺序表，比较元素与所给元素是否相等，如果相等就返回该索引
int find_element(arrayList t,eleType elem){
    int index;
    for (index=0;index<t.length;index++){
        if (elem==t.element[index]){
            return index;
        }
    }
    return -1;
}

//顺序表的销毁
int arrayList_destroy(arrayList *t){
    if (NULL == t){
        return error;
    }
    if (t->element != NULL){
        free(t->element);
        t->length=0;
        t->listsize=0;
    }
    return ok;
}

//删除指定位置的元素，先判定索引是否合法，如果不合法，返回错误。
// 如果合法，把指定元素删除后，i+1到length-1的索引元素往前移动一位。线性表长度-1
int locate_element_delete(arrayList *t,unit index){
    if (NULL == t)
        return error;
    if (index > t->length-1){
        printf("index out range");
        return error;
    }
    int i;
    for (i=index;i<t->length-1;i++){
        t->element[i]=t->element[i+1];
    }
    t->length = t->length -1;
    return ok;
}


int main()
{   arrayList t;//构造一个结构体
    t = array_init(20);//初始化结构体
    int i=0;  //往线性表里赋值
    for (i;i<10;i++){
        t.element[i]=100+i;
        t.length++;
    }
    //打印出线性表中的元素

    locate_element_delete(&t,3);
   /* int j=0;
    for (j;j<t.length;j++){
        printf("%d ",t.element[j]);
    }
    printf("%d",t.length);
    */

    return 0;
}

• 删除指定元素
• 线性表扩容
• 在指定索引出插入元素

#define error -1
#define ok 1

//删除指定的元素值，指定的元素值可能有多个重复的元素，要遍历整个列表长度
int delete_designated_element(arrayList *t,unit elem){
    if (NULL == t){
        return error;
    }
    int index=0;
    while (index !=t->length-1){
        if (t->element[index] != elem){
            index++;
            continue;
        }
        //查找到相同的元素，从这个元素之后的所有元素往前移动一位
        //指针index不要+1，后边移位来的元素可能还是要删除的元素，但是列表的长度要-1
        int i=index;
        for (i;i<t->length-1;i++){
            t->element[i]=t->element[i+1];
        }
        t->length--;
    }
    return ok;
}

//线性表扩容成原来2倍
int expand(arrayList *t){
    if (NULL == t){
        return error;
    }
    t->listsize *=2;//为顺序表分配新的空间
    t->element = (eleType *)realloc(t->element,t->listsize* sizeof(eleType));
    return ok;
}

//在指定索引处插入一个元素
int element_insert(arrayList *t, int index,int elem){
    if (NULL == t)
    {
        printf("[%s %d] SqList is NULL\n", __FUNCTION__ , __LINE__);
        return error;
    }
    //判断插入的位置是否合法
    if (index > t->length)
        return error;

    //判断顺序表是否满了，如果满了则扩容
    if (t->length == t->listsize)
    {
        expand(&t);
    }
    int i=0;
    for (i;i<t->length-index;i++){
        //从最后一个元素开始，往后移动一位
        t->element[t->length-i]=t->element[t->length-i-1];
    }
    t->element[index] = elem;
    t->length++;
    return ok;
}