数据结构与算法之顺序表C语言实现

顺序表等相关概念请自行查阅资料，这里主要是实现。

注：

1.顺序表C语言实现；

2.按较简单的方式实现，主要帮助理解，可在此基础上修改，更加完善；

3.提供几个简单函数，可自行添加功能；

4.可用C++封装，得知STL中vector原理。

 

 顺序表容量。

#define CAPACITY 20 //容量

顺序表结构体。

typedef struct 
{
    int *m_pHead; //指向数组头
    int m_iSize; //大小
    int m_iCapacity; //容量
}STABLE;

部分操作，可自行添加其他操作。

STABLE* createTable();
void appendElement(STABLE* pTable, int iElement);
void insertElement(STABLE* pTable, int iElement, int index);
void delElement(STABLE* pTable, int index);
int getAt(STABLE* pTable, int index);
void setAt(STABLE* pTable, int iElement, int index);
void showTable(STABLE* pTable);
void releaseMem(STABLE* pTable);

分配内存，元素个数为0。

STABLE* createTable()
{
    STABLE *pTable = (STABLE*)malloc(sizeof(STABLE));
    if(!pTable)
    {
        printf("动态内存分配失败!\n");
        return pTable;
    }

    pTable->m_pHead = (int*)malloc(sizeof(int) * CAPACITY);
    if(!pTable->m_pHead)
    {
        printf("动态内存分配失败!\n");
        return NULL;
    }

    pTable->m_iSize = 0;
    pTable->m_iCapacity = CAPACITY;

    return pTable;
}

追加

void appendElement(STABLE* pTable, int iElement) 
{
    if(!pTable || !pTable->m_pHead)
    {
        printf("顺序表不存在!\n");
        return;
    }

    if(pTable->m_iSize == pTable->m_iCapacity)
    {
        printf("顺序表已满!\n"); //可以重新分配内存 这里就不实现了 从简
        return;
    }
    
    pTable->m_pHead[pTable->m_iSize] = iElement;
    pTable->m_iSize++;
}

插入

void insertElement(STABLE* pTable, int iElement, int index)
{
    if(!pTable || !pTable->m_pHead)
    {
        printf("顺序表不存在!\n");
        return;
    }

    if(pTable->m_iSize == pTable->m_iCapacity)
    {
        printf("顺序表已满!\n"); //可以重新分配内存 这里就不实现了 从简
        return;
    }

    if(index < 0 || index > pTable->m_iSize)
    {
        printf("插入位置不合理!\n");
        return;
    }

    //后移
    for(int i = pTable->m_iSize - 1; i >= index; i--)
    {
        pTable->m_pHead[i+1] = pTable->m_pHead[i];
    }
    pTable->m_pHead[index] = iElement;
    pTable->m_iSize++;
}

删除

void delElement(STABLE* pTable, int index)
{
    if(!pTable || !pTable->m_pHead)
    {
        printf("顺序表不存在!\n");
        return;
    }

    if(pTable->m_iSize < 1)
    {
        printf("顺序表元素个数为0!\n");
        return;
    }

    if(index < 0 || index > pTable->m_iSize - 1)
    {
        printf("删除元素位置不合理!\n");
        return;
    }

    //前移
    for(int i = index; i < pTable->m_iSize - 1; i++)
    {
        pTable->m_pHead[i] = pTable->m_pHead[i+1];
    }

    pTable->m_iSize--;
}

获取

int getAt(STABLE* pTable, int index)
{
    if(!pTable || !pTable->m_pHead)
    {
        printf("顺序表不存在!\n");
        return -1;
    }

    if(index < 0 || index > pTable->m_iSize - 1)
    {
        printf("索引不合理!\n");
        return -1;
    }

    return pTable->m_pHead[index];
}

修改

void setAt(STABLE* pTable, int iElement, int index)
{
    if(!pTable || !pTable->m_pHead)
    {
        printf("顺序表不存在!\n");
        return;
    }

    if(index < 0 || index > pTable->m_iSize - 1)
    {
        printf("索引不合理!\n");
        return;
    }

    pTable->m_pHead[index] = iElement;
}

打印所有元素。

void showTable(STABLE* pTable)
{
    if(!pTable || !pTable->m_pHead)
    {
        printf("顺序表不存在!\n");
        return;
    }

    printf("容量：%d，大小：%d，打印元素：\n", pTable->m_iCapacity, pTable->m_iSize);
    for(int i = 0; i < pTable->m_iSize; i++)
        printf("%d ", pTable->m_pHead[i]);

    printf("\n");
}

内存释放。

void releaseMem(STABLE* pTable)
{
    if(!pTable)
    {
        printf("顺序表不存在!\n");
        return;
    }

    if(pTable->m_pHead)
        free(pTable->m_pHead);

    free(pTable);
    printf("内存释放成功!\n");
}

转载于:https://www.cnblogs.com/chendong-leslie/p/10189170.html