順序表的定義

? ?順序表是一種線性數(shù)據(jù)結(jié)構(gòu)，它由一組連續(xù)的存儲單元組成，用來存儲具有相同數(shù)據(jù)類型的元素。順序表中的元素按照邏輯順序依次存放，并且可以通過索引來訪問和修改元素。

順序表的實現(xiàn)方式

? ? ? ?兩種：靜態(tài)順序表和動態(tài)順序表。

• 靜態(tài)順序表：
  靜態(tài)順序表使用靜態(tài)數(shù)組來實現(xiàn)，需要在創(chuàng)建順序表時提前確定順序表的大小。靜態(tài)順序表的大小是固定的，一旦分配了固定大小的存儲空間，就不能動態(tài)地改變大小。因此，靜態(tài)順序表的容量是有限的，如果插入的元素超過了容量，就會導(dǎo)致溢出。
• ? ? ? ?優(yōu)點：可以直接通過下標(biāo)直接訪問元素，訪問元素速度快，時間復(fù)雜度是O（1）。
• ? ? ? ?缺點：插入與刪除元素的操作比較耗時，需要移動其他元素，時間復(fù)雜度位O（n）。
• 動態(tài)順序表：
• 動態(tài)順序表使用動態(tài)數(shù)組來實現(xiàn)，可以根據(jù)需要動態(tài)調(diào)整順序表的大小。動態(tài)順序表的大小是可變的，當(dāng)插入的元素超過當(dāng)前容量時，會自動擴容，當(dāng)刪除元素后，如果剩余容量過多，可以縮小容量，以節(jié)省內(nèi)存空間。
• ? ? ? ?優(yōu)點：可以根據(jù)動態(tài)調(diào)整大小，靈活性較高。
• ? ? ? ?缺點：在插入和刪除元素時，可能需要重新分配存儲空間，導(dǎo)致一定的時間開銷。

  ---

  靜態(tài)順序表的例子

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

// 定義靜態(tài)順序表的最大長度
#define MAX_SIZE 100

// 定義結(jié)構(gòu)體，表示靜態(tài)順序表
struct SeqList 
{
    int data[MAX_SIZE];  // 數(shù)據(jù)數(shù)組
    int length;          // 當(dāng)前表長
};

// 初始化順序表
void initSeqList(struct SeqList* list) 
{
    list->length = 0;  // 初始化表長為0
}

// 插入元素到順序表
int insertElement(struct SeqList* list, int position, int value) 
{
    // 檢查插入位置的有效性
    if (position < 1 || position > list->length + 1 || list->length >= MAX_SIZE) 
    {
        printf("插入位置無效或表滿，插入失敗\n");
        return 0;  // 插入失敗
    }

    // 將插入位置及之后的元素后移
    for (int i = list->length; i >= position; i--) 
    {
        list->data[i] = list->data[i - 1];
    }

    // 在插入位置處插入新元素
    list->data[position - 1] = value;

    // 表長加1
    list->length++;

    printf("插入成功\n");
    return 1;  // 插入成功
}

// 刪除順序表中指定位置的元素
int deleteElement(struct SeqList* list, int position) 
{
    // 檢查刪除位置的有效性
    if (position < 1 || position > list->length) 
    {
        printf("刪除位置無效，刪除失敗\n");
        return 0;  // 刪除失敗
    }

    // 將刪除位置之后的元素前移
    for (int i = position; i < list->length; i++) 
    {
        list->data[i - 1] = list->data[i];
    }

    // 表長減1
    list->length--;

    printf("刪除成功\n");
    return 1;  // 刪除成功
}

// 打印順序表中的元素
void printSeqList(struct SeqList* list) 
{
    printf("順序表元素：");
    for (int i = 0; i < list->length; i++) 
    {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}

int main() 
{
    // 聲明并初始化順序表
    struct SeqList myList;
    initSeqList(&myList);

    // 在順序表中插入元素
    insertElement(&myList, 1, 10);
    insertElement(&myList, 1, 20);
    insertElement(&myList, 1, 5);
    insertElement(&myList, 1, 6);
    // 打印順序表
    printSeqList(&myList);

    // 刪除順序表中的元素
    deleteElement(&myList, 1);

    // 打印刪除后的順序表
    printSeqList(&myList);

    return 0;
}

上述程序?qū)崿F(xiàn)了一個簡單的靜態(tài)順序表，包括初始化、插入、刪除和打印操作。大家可以自己修改插入，刪除數(shù)據(jù)，體會其中的奧秘。

效果

動態(tài)順序表的例子

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

// 定義動態(tài)順序表的初始容量和增量
#define INIT_CAPACITY 10
#define INCREMENT 5

// 定義結(jié)構(gòu)體，表示動態(tài)順序表
struct SeqList 
{
    int* data;          // 數(shù)據(jù)指針
    int length;         // 當(dāng)前表長
    int capacity;       // 當(dāng)前容量
};

// 初始化順序表
void initSeqList(struct SeqList* list) 
{
    list->data = (int*)malloc(INIT_CAPACITY * sizeof(int));  // 分配初始容量的內(nèi)存
    list->length = 0;  // 初始化表長為0
    list->capacity = INIT_CAPACITY;  // 初始化容量為初始容量
}

// 銷毀順序表
void destroySeqList(struct SeqList* list) 
{
    free(list->data);  // 釋放動態(tài)分配的內(nèi)存
    list->data = NULL;  // 將指針置為空
    list->length = 0;  // 表長置為0
    list->capacity = 0;  // 容量置為0
}

// 打印順序表中的元素
void printSeqList(struct SeqList* list) 
{
    printf("順序表元素：");
    for (int i = 0; i < list->length; i++) 
    {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}

// 自動增容
void increaseCapacity(struct SeqList* list) 
{
    int* newData = (int*)realloc(list->data, (list->capacity + INCREMENT) * sizeof(int));  // 重新分配內(nèi)存
    if (newData != NULL) 
    {  // 分配成功
        list->data = newData;  // 將指針指向新的內(nèi)存
        list->capacity += INCREMENT;  // 容量增加
        printf("自動增容成功，容量增加到%d\n", list->capacity);
    }
    else 
    {  // 分配失敗
        printf("自動增容失敗\n");
    }
}

// 插入元素到順序表
int insertElement(struct SeqList* list, int position, int value) 
{
    // 檢查插入位置的有效性
    if (position < 1 || position > list->length + 1) 
    {
        printf("插入位置無效，插入失敗\n");
        return 0;  // 插入失敗
    }

    // 如果表滿，自動增容
    if (list->length >= list->capacity) 
    {
        increaseCapacity(list);
    }

    // 將插入位置及之后的元素后移
    for (int i = list->length; i >= position; i--) 
    {
        list->data[i] = list->data[i - 1];
    }

    // 在插入位置處插入新元素
    list->data[position - 1] = value;

    // 表長加1
    list->length++;

    printf("插入成功\n");
    return 1;  // 插入成功
}

// 刪除順序表中指定位置的元素
int deleteElement(struct SeqList* list, int position) 
{
    // 檢查刪除位置的有效性
    if (position < 1 || position > list->length) 
    {
        printf("刪除位置無效，刪除失敗\n");
        return 0;  // 刪除失敗
    }

    // 將刪除位置之后的元素前移
    for (int i = position; i < list->length; i++) 
    {
        list->data[i - 1] = list->data[i];
    }

    // 表長減1
    list->length--;

    printf("刪除成功\n");
    return 1;  // 刪除成功
}

// 查找元素在順序表中的位置
int searchElement(struct SeqList* list, int value) 
{
    for (int i = 0; i < list->length; i++) 
    {
        if (list->data[i] == value) 
        {
            printf("元素%d在順序表中的位置是%d\n", value, i + 1);
            return i + 1;  // 返回位置
        }
    }

    printf("元素%d不在順序表中\(zhòng)n", value);
    return 0;  // 查找失敗
}

int main() 
{
    // 聲明并初始化順序表
    struct SeqList myList;
    initSeqList(&myList);

    // 在順序表中插入元素
    insertElement(&myList, 1, 10);
    insertElement(&myList, 2, 20);
    insertElement(&myList, 1, 5);

    // 打印順序表
    printSeqList(&myList);

    // 刪除順序表中的元素
    deleteElement(&myList, 2);

    // 打印刪除后的順序表
    printSeqList(&myList);

    // 查找元素在順序表中的位置
    searchElement(&myList, 20);
    searchElement(&myList, 30);

    // 銷毀順序表
    destroySeqList(&myList);

    return 0;
}

效果

文章來源地址http://www.zghlxwxcb.cn/news/detail-780789.html

到了這里，關(guān)于數(shù)據(jù)結(jié)構(gòu)c語言版：順序表的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！