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

/*
链表 顺序存储
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define ElemType int
#define MAX_SIZE 100

typedef struct Node
{
    ElemType data[MAX_SIZE];
    int length;
}SeqList;

void initSeqList(SeqList *list)
{
    assert(list);
    list->length = 0;
    memset(list->data, 0, sizeof(list->data));
}

void dumpSeqList(SeqList *list)
{
    assert(list);
    for (int i=0;i<list->length;i++)
    {
        printf("%d ", list->data[i]);
    }
    printf("\n");
    printf("length=%d\n", list->length);
}

void pushBack(SeqList *list, ElemType value)
{
    assert(list);
    if (list->length == MAX_SIZE)
    {
        printf("顺序表已满，无法插入元素!\n");
        return;
    }
    list->data[list->length] = value;
    list->length ++;
}

void popBack(SeqList *list, ElemType *value)
{
    assert(list);
    if (list->length == 0)
    {
        printf("顺序表为空，无元素可删!\n");
        return;
    }
    *value = list->data[list->length - 1];
    list->length--;
}

void pushFront(SeqList *list, ElemType value)
{
    assert(list);
    if (list->length >= MAX_SIZE)
    {
        printf("顺序表已满，无法插入元素！\n");
        return;
    }
    for (int i = list->length - 1; i >= 0; i--)
    {
        list->data[i + 1] = list->data[i];
    }
    list->data[0] = value;
    list->length++;
}

void popFront(SeqList *list, ElemType *value)
{
    assert(list);
    *value = list->data[0];
    for (int i = 0; i < list->length; i++)
    {
        list->data[i] = list->data[i+1];
    }
    list->length--;
}

int find(SeqList *list, ElemType value)
{
    assert(list);
    int index = -1;
    for (int i = 0; i < list->length; i++)
    {
        if (list->data[i] == value)
        {
            index = i;
            break;
        }
    }
    return index;
}

void insert(SeqList *list,int pos,ElemType value)
{
    assert(list);
    if (list->length >= MAX_SIZE)
    {
        printf("顺序表已满，无法插入元素！\n");
        return;
    }
    for (int i = list->length - 1; i >= pos; i--)
    {
        list->data[i + 1] = list->data[i];
    }
    list->data[pos] = value;
    list->length++;
}

void erase(SeqList *list, int pos,ElemType *value)
{
    assert(list && pos >= 0 && pos < list->length);
    *value = list->data[pos];
    for (int i = pos; i < list->length; i++)
    {
        list->data[i] = list->data[i + 1];
    }
    list->length--;
}

void removeItem(SeqList *list, ElemType value)
{
    assert(list);
    if (list->length == 0)
    {
        printf("顺序表为空，无元素可删!\n");
        return;
    }
    int i = 0;
    for (int i = 0; i < list->length; i++)
    {
        if (list->data[i] == value)
        {
            break;
        }
    }
    if (i == list->length)
    {
        printf("未找到该元素！\n");
    }
    for (int j = i; j < list->length; j++)
    {
        list->data[j] = list->data[j + 1];
    }
    list->length--;
}

void removeAll(SeqList *list,ElemType value)
{
    assert(list);
    if (list->length == 0)
    {
        printf("顺序表为空，无元素可删!\n");
        return;
    }
    int j = 0;
    for (int i = 0; i < list->length; i++)
    {
        if (list->data[i] != value)
        {
            list->data[j] = list->data[i];
            j++;
        }
    }
    list->length = j;
}

int size(SeqList *list)
{
    assert(list);
    return list->length;
}

int empty(SeqList *list)
{
    assert(list);
    return list->length == 0;
}

int main()
{
    SeqList *head = (SeqList *)malloc(sizeof(SeqList));
    initSeqList(head);
    pushBack(head, 1);
    pushBack(head, 2);
    pushBack(head, 3);
    pushBack(head, 4);
    pushBack(head, 3);
    pushBack(head, 3);
    pushBack(head, 5);
    dumpSeqList(head);
    int i = 0;
    popBack(head,&i);
    popBack(head, &i);
    dumpSeqList(head);
    pushFront(head, 3);
    pushFront(head, 4);
    dumpSeqList(head);
    popFront(head,&i);
    dumpSeqList(head);
    int pos = find(head, 5);
    insert(head, 1, 10);
    dumpSeqList(head);
    erase(head, 2, &i);
    removeItem(head, 3);
    dumpSeqList(head);
    removeAll(head, 3);
    dumpSeqList(head);
    return 0;
}

链表顺序存储的优缺点：

1：不用为表中的元素之间的逻辑关系添加额外的存储结构  也就是说元素之间的先后顺序本身就已经定了

2：可以快速的存取表中的任意位置的元素 (快速获取值)

缺点：

插入和删除元素需要移动大量的元素

造成存储空间碎片