【数据结构】顺序线性表（1）

顺序线性表（数组）

#define LIST_INIT_SIZE 10
#define LIST_INCREMENT 2

typedef int ElemType;

struct SqListArray
{
    ElemType * pBase;    //数组首地址
    int length;          //数组最大长度
    int cnt;             //数组有效长度
};


//顺序存储的线性表的基本操作（12个）
//1构造一个空的线性表
void init_arr(struct SqListArray * arr)
{
    arr->pBase = (ElemType *) malloc(sizeof (ElemType) * LIST_INIT_SIZE);
    if (NULL == arr->pBase)
    {
        printf("动态内存分配失败！\n");
        exit(-1);
    }
    else
    {
        arr->length = LIST_INIT_SIZE;
        arr->cnt = 0;
    }
}

//2顺序线性表若存在，销毁顺序线性表
void destroy_arr(struct SqListArray * arr)
{
    free(arr->pBase = NULL);
    arr->pBase = NULL;
    arr->cnt = 0;
    arr->length = 0;
}

//3顺序线性表重置为空表
void clear_arr(struct SqListArray * arr)
{
    arr->cnt = 0;
}

//4判断是否为空
bool is_empty(struct SqListArray * arr)
{
    if (0 == arr->cnt)
        return true;
    else
        return false;
}

//5.返回顺序线性表元素个数
int length_arr(struct SqListArray * arr)
{
    return arr->cnt;
}

//6获取第pos个元素的值  从 1 开始
bool get_arr(struct SqListArray * arr, int pos, ElemType * value)
{
    if (pos < 0 || pos > arr->cnt)
        return false;
    *value = arr->pBase[pos - 1];

    return true;
}

//7给定一个数，得到线性表中与此数相等的最小的位序
bool compare(ElemType e1, ElemType e2)
{
    if (e1 == e2)
        return true;
    else
        return false;
}
int locate_arr(struct SqListArray * arr, ElemType value)
{
    int i = 1;
    while (i < arr->cnt && !compare(value, arr->pBase[i-1]))
    {
        i++;
    }
    if ( i < arr->cnt)
        return i;
    else
    {
        return 0;
    }
}

//8给定一个数，判断是否在数组里，如果在，从第二个元素开始得到此数的前一个数
bool prior_arr(struct SqListArray * arr, ElemType cur_e, ElemType * pre_e)
{
    int i = 1;
    while (i < arr->cnt && arr->pBase[i] != cur_e)
    {
        i++;
    }
    if (i > arr->cnt - 1)
    {
        return false;
    }
    else
    {
        *pre_e = arr->pBase[i-1];
        return true;
    }
}

//9返回cur的后一个
bool next_arr(struct SqListArray * arr, ElemType cur_e, ElemType * next_e)
{
    int i = 0;
    while (i < arr->cnt && arr->pBase[i] != cur_e)
    {
        i++;
    }
    if (i == arr->cnt - 2)
        return false;
    else
    {
        *next_e = arr->pBase[i + 1];
        return true;
    }
}

//10插入元素
bool insert_arr(struct SqListArray * arr, int pos, ElemType value)
{
    ElemType * pNewBase;
    if (pos < 0 || pos > arr->cnt + 1)
        return false;
    if (arr->cnt == arr->length)
    {
        pNewBase = (ElemType *) realloc(arr->pBase, sizeof (ElemType) * (arr->length + LIST_INCREMENT));
        if (!pNewBase)
            exit(-1);

        arr->pBase = pNewBase;
        arr->length += LIST_INCREMENT;
    }
    for (int i = arr->cnt - 1; i >= pos - 1; --i)
    {
        arr->pBase[i+1] = arr->pBase[i];
    }
    arr->pBase[pos - 1] = value;
    arr->cnt++;

    return true;
}

//11删除第i个位置上的元素
bool delete_arr(struct SqListArray * arr, int pos, ElemType * pValue)
{
    if (is_empty(arr))
        return false;
    if (pos < 0 || pos > arr->cnt)
        return false;

    *pValue = arr->pBase[pos-1];
    for (int i = pos; i <= arr->cnt; i++)
    {
        arr->pBase[i-1] = arr->pBase[i];
    }
    arr->cnt--;
    return true;
}

//12遍历数组
void traverse_arr(struct SqListArray * arr)
{
    if(is_empty(arr))
    {
        printf("数组为空！\n");
    }
    else
    {
        for (int i = 0; i < arr->cnt; i++)
        {
            printf("%d ", arr->pBase[i]);
        }
        printf("\n");
    }
}
//将所有在线性表Lb中但不在La的数据元素插入到表La中
void Union(struct SqListArray * La, struct SqListArray * Lb)
{
    ElemType value;
    for (int i = 0; i < Lb->cnt; i++)
    {
        get_arr(Lb, i+1, &value);
        if (!locate_arr(La, value))
            insert_arr(La, La->cnt + 1, value);
    }
}
//La Lb先排序(给定升序)，归并La 和 Lb 得到新的线性表 Lc 也是升序
void MergeList_array(struct SqListArray * La, struct SqListArray * Lb, struct SqListArray * Lc)
{
    Lc->length = length_arr(La) + length_arr(Lb) ;
    printf("Lc->length = %d\n", Lc->length);
    Lc->pBase = (ElemType *) malloc(sizeof (ElemType) * Lc->length);
    if (NULL == Lc->pBase)
    {
        printf("动态内存分配失败！\n");
        exit(-1);
    }

    int i = 0;
    int j = 0;
    Lc->cnt = 0;
    while (i < La->cnt && j < Lb->cnt)
    {

        if (La->pBase[i] <= Lb->pBase[j])
        {
            Lc->pBase[Lc->cnt] = La->pBase[i];
            i++;
            Lc->cnt++;
        }
        else
        {
            Lc->pBase[Lc->cnt] = Lb->pBase[j];
            j++;
            Lc->cnt++;
        }

    }
    while (i < La->cnt )
    {
        Lc->pBase[Lc->cnt] = La->pBase[i];
        i++;
        Lc->cnt++;
    }
    while (j < Lb->cnt )
    {
        Lc->pBase[Lc->cnt] = Lb->pBase[j];
        j++;
        Lc->cnt++;
    }

}

测试

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <stdbool.h>


int main()
{
    struct SqListArray array;
    init_arr(&array);
    for (int i = 0; i < 6; i++)
    {
        insert_arr(&array, i+1, i);
    }
    insert_arr(&array, 7, 3);
    insert_arr(&array, 8, 3);
    insert_arr(&array, 9, 4);


    int len = length_arr(&array);
    printf("len = %d\n", len);

    ElemType val;
    get_arr(&array, 3, &val);
    printf("val = %d\n", val);

    int locate_cnt;
    locate_cnt = locate_arr(&array, 4);
    printf("locate_cnt = %d\n", locate_cnt);

    ElemType pre_e;
    prior_arr(&array, 4, &pre_e);
    printf("pre_e = %d\n", pre_e);

    ElemType next_e;
    next_arr(&array, 4, &next_e);
    printf("pre_e = %d\n", next_e);

    traverse_arr(&array);

    ElemType value;
    delete_arr(&array, 7, &value);
    printf("value = %d\n", value);
    traverse_arr(&array);
    /*
    clear_arr(&array);
    destroy_arr(&array);

    traverse_arr(&array);
    */

    struct SqListArray La;
    struct SqListArray Lb;
    struct SqListArray Lc;
    init_arr(&La);
    init_arr(&Lb);

    insert_arr(&La, 1, 2);
    insert_arr(&La, 2, 2);
    insert_arr(&La, 3, 3);
    insert_arr(&La, 4, 6);
    insert_arr(&La, 5, 9);

    insert_arr(&Lb, 1, 2);
    insert_arr(&Lb, 2, 4);
    insert_arr(&Lb, 3, 6);
    insert_arr(&Lb, 4, 8);
    insert_arr(&Lb, 5, 9);
    insert_arr(&Lb, 6, 10);

    traverse_arr(&La);
    traverse_arr(&Lb);
    //Union(&La, &Lb);
    //traverse_arr(&La);
    MergeList_array(&La, &Lb, &Lc);
    printf("La->length = %d\n", La.cnt);
    traverse_arr(&Lc);

    return 0;
}