1. PingCode智库首页
  2. 百科

c语言如何初始化顺序表

Edit2 • • 百科

c语言如何初始化顺序表

C语言初始化顺序表的方法主要有以下几种：动态分配内存、静态数组、初始化函数。其中，动态分配内存是最常用的方法，它可以有效利用内存空间并且灵活处理顺序表的大小。下面详细讨论动态分配内存的方法。

一、动态分配内存

1、使用malloc函数

在C语言中，动态分配内存通常使用malloc函数。malloc函数从堆内存中分配一块连续的内存空间，返回一个指向该内存空间的指针。

#include <stdio.h>


#include <stdlib.h>


typedef struct {


    int *data;  // 指向顺序表中元素的指针


    int length; // 顺序表的当前长度


    int size;   // 顺序表的最大容量


} SeqList;


void initSeqList(SeqList *list, int size) {


    list->data = (int *)malloc(size * sizeof(int));


    if (list->data == NULL) {


        printf("内存分配失败n");


        exit(1);


    }


    list->length = 0;


    list->size = size;


}


int main() {


    SeqList list;


    initSeqList(&list, 10);


    printf("顺序表初始化成功，容量为%dn", list.size);


    return 0;


}

2、使用calloc函数

calloc函数与malloc函数类似，但它会将分配的内存初始化为零。

#include <stdio.h>


#include <stdlib.h>


typedef struct {


    int *data;  // 指向顺序表中元素的指针


    int length; // 顺序表的当前长度


    int size;   // 顺序表的最大容量


} SeqList;


void initSeqList(SeqList *list, int size) {


    list->data = (int *)calloc(size, sizeof(int));


    if (list->data == NULL) {


        printf("内存分配失败n");


        exit(1);


    }


    list->length = 0;


    list->size = size;


}


int main() {


    SeqList list;


    initSeqList(&list, 10);


    printf("顺序表初始化成功，容量为%dn", list.size);


    return 0;


}

3、使用realloc函数

realloc函数用于调整已分配内存的大小，可以在顺序表需要扩展时使用。

#include <stdio.h>


#include <stdlib.h>


typedef struct {


    int *data;  // 指向顺序表中元素的指针


    int length; // 顺序表的当前长度


    int size;   // 顺序表的最大容量


} SeqList;


void initSeqList(SeqList *list, int size) {


    list->data = (int *)malloc(size * sizeof(int));


    if (list->data == NULL) {


        printf("内存分配失败n");


        exit(1);


    }


    list->length = 0;


    list->size = size;


}


void resizeSeqList(SeqList *list, int newSize) {


    list->data = (int *)realloc(list->data, newSize * sizeof(int));


    if (list->data == NULL) {


        printf("内存分配失败n");


        exit(1);


    }


    list->size = newSize;


}


int main() {


    SeqList list;


    initSeqList(&list, 10);


    printf("顺序表初始化成功，容量为%dn", list.size);


    resizeSeqList(&list, 20);


    printf("顺序表扩展成功，新容量为%dn", list.size);


    return 0;


}

二、静态数组

静态数组是指在程序编译时确定大小的数组，这种方法简单易行，但灵活性较差。

#include <stdio.h>


#define MAX_SIZE 100


typedef struct {


    int data[MAX_SIZE]; // 顺序表中元素的数组


    int length;         // 顺序表的当前长度


} SeqList;


void initSeqList(SeqList *list) {


    list->length = 0;


}


int main() {


    SeqList list;


    initSeqList(&list);


    printf("顺序表初始化成功，容量为%dn", MAX_SIZE);


    return 0;


}

三、初始化函数

初始化函数可以封装顺序表的初始化过程，使代码更加模块化和易于维护。

1、封装初始化函数

#include <stdio.h>


#include <stdlib.h>


typedef struct {


    int *data;  // 指向顺序表中元素的指针


    int length; // 顺序表的当前长度


    int size;   // 顺序表的最大容量


} SeqList;


SeqList* createSeqList(int size) {


    SeqList *list = (SeqList *)malloc(sizeof(SeqList));


    if (list == NULL) {


        printf("内存分配失败n");


        exit(1);


    }


    list->data = (int *)malloc(size * sizeof(int));


    if (list->data == NULL) {


        printf("内存分配失败n");


        free(list);


        exit(1);


    }


    list->length = 0;


    list->size = size;


    return list;


}


int main() {


    SeqList *list = createSeqList(10);


    printf("顺序表初始化成功，容量为%dn", list->size);


    free(list->data);


    free(list);


    return 0;


}

2、封装销毁函数

为了避免内存泄漏，在不再使用顺序表时应释放其占用的内存。

#include <stdio.h>


#include <stdlib.h>


typedef struct {


    int *data;  // 指向顺序表中元素的指针


    int length; // 顺序表的当前长度


    int size;   // 顺序表的最大容量


} SeqList;


SeqList* createSeqList(int size) {


    SeqList *list = (SeqList *)malloc(sizeof(SeqList));


    if (list == NULL) {


        printf("内存分配失败n");


        exit(1);


    }


    list->data = (int *)malloc(size * sizeof(int));


    if (list->data == NULL) {


        printf("内存分配失败n");


        free(list);


        exit(1);


    }


    list->length = 0;


    list->size = size;


    return list;


}


void destroySeqList(SeqList *list) {


    if (list != NULL) {


        if (list->data != NULL) {


            free(list->data);


        }


        free(list);


    }


}


int main() {


    SeqList *list = createSeqList(10);


    printf("顺序表初始化成功，容量为%dn", list->size);


    destroySeqList(list);


    printf("顺序表销毁成功n");


    return 0;


}

四、顺序表操作函数

在顺序表的初始化之后，还需要对其进行各种操作，包括插入、删除、查找等。

1、插入操作

插入操作需要考虑顺序表的容量是否已满，如果已满需要扩展容量。

#include <stdio.h>


#include <stdlib.h>


typedef struct {


    int *data;  // 指向顺序表中元素的指针


    int length; // 顺序表的当前长度


    int size;   // 顺序表的最大容量


} SeqList;


SeqList* createSeqList(int size) {


    SeqList *list = (SeqList *)malloc(sizeof(SeqList));


    if (list == NULL) {


        printf("内存分配失败n");


        exit(1);


    }


    list->data = (int *)malloc(size * sizeof(int));


    if (list->data == NULL) {


        printf("内存分配失败n");


        free(list);


        exit(1);


    }


    list->length = 0;


    list->size = size;


    return list;


}


void destroySeqList(SeqList *list) {


    if (list != NULL) {


        if (list->data != NULL) {


            free(list->data);


        }


        free(list);


    }


}


void insertSeqList(SeqList *list, int index, int value) {


    if (index < 0 || index > list->length) {


        printf("插入位置无效n");


        return;


    }


    if (list->length >= list->size) {


        list->size *= 2;


        list->data = (int *)realloc(list->data, list->size * sizeof(int));


        if (list->data == NULL) {


            printf("内存分配失败n");


            exit(1);


        }


    }


    for (int i = list->length; i > index; i--) {


        list->data[i] = list->data[i - 1];


    }


    list->data[index] = value;


    list->length++;


}


int main() {


    SeqList *list = createSeqList(10);


    printf("顺序表初始化成功，容量为%dn", list->size);


    insertSeqList(list, 0, 5);


    insertSeqList(list, 1, 10);


    printf("顺序表插入成功，当前长度为%dn", list->length);


    for (int i = 0; i < list->length; i++) {


        printf("%d ", list->data[i]);


    }


    printf("n");


    destroySeqList(list);


    printf("顺序表销毁成功n");


    return 0;


}

2、删除操作

删除操作需要将删除位置后的元素依次前移。

#include <stdio.h>


#include <stdlib.h>


typedef struct {


    int *data;  // 指向顺序表中元素的指针


    int length; // 顺序表的当前长度


    int size;   // 顺序表的最大容量


} SeqList;


SeqList* createSeqList(int size) {


    SeqList *list = (SeqList *)malloc(sizeof(SeqList));


    if (list == NULL) {


        printf("内存分配失败n");


        exit(1);


    }


    list->data = (int *)malloc(size * sizeof(int));


    if (list->data == NULL) {


        printf("内存分配失败n");


        free(list);


        exit(1);


    }


    list->length = 0;


    list->size = size;


    return list;


}


void destroySeqList(SeqList *list) {


    if (list != NULL) {


        if (list->data != NULL) {


            free(list->data);


        }


        free(list);


    }


}


void insertSeqList(SeqList *list, int index, int value) {


    if (index < 0 || index > list->length) {


        printf("插入位置无效n");


        return;


    }


    if (list->length >= list->size) {


        list->size *= 2;


        list->data = (int *)realloc(list->data, list->size * sizeof(int));


        if (list->data == NULL) {


            printf("内存分配失败n");


            exit(1);


        }


    }


    for (int i = list->length; i > index; i--) {


        list->data[i] = list->data[i - 1];


    }


    list->data[index] = value;


    list->length++;


}


void deleteSeqList(SeqList *list, int index) {


    if (index < 0 || index >= list->length) {


        printf("删除位置无效n");


        return;


    }


    for (int i = index; i < list->length - 1; i++) {


        list->data[i] = list->data[i + 1];


    }


    list->length--;


}


int main() {


    SeqList *list = createSeqList(10);


    printf("顺序表初始化成功，容量为%dn", list->size);


    insertSeqList(list, 0, 5);


    insertSeqList(list, 1, 10);


    printf("顺序表插入成功，当前长度为%dn", list->length);


    for (int i = 0; i < list->length; i++) {


        printf("%d ", list->data[i]);


    }


    printf("n");


    deleteSeqList(list, 1);


    printf("顺序表删除成功，当前长度为%dn", list->length);


    for (int i = 0; i < list->length; i++) {


        printf("%d ", list->data[i]);


    }


    printf("n");


    destroySeqList(list);


    printf("顺序表销毁成功n");


    return 0;


}

3、查找操作

查找操作用于在顺序表中查找指定元素，并返回其位置。

#include <stdio.h>


#include <stdlib.h>


typedef struct {


    int *data;  // 指向顺序表中元素的指针


    int length; // 顺序表的当前长度


    int size;   // 顺序表的最大容量


} SeqList;


SeqList* createSeqList(int size) {


    SeqList *list = (SeqList *)malloc(sizeof(SeqList));


    if (list == NULL) {


        printf("内存分配失败n");


        exit(1);


    }


    list->data = (int *)malloc(size * sizeof(int));


    if (list->data == NULL) {


        printf("内存分配失败n");


        free(list);


        exit(1);


    }


    list->length = 0;


    list->size = size;


    return list;


}


void destroySeqList(SeqList *list) {


    if (list != NULL) {


        if (list->data != NULL) {


            free(list->data);


        }


        free(list);


    }


}


void insertSeqList(SeqList *list, int index, int value) {


    if (index < 0 || index > list->length) {


        printf("插入位置无效n");


        return;


    }


    if (list->length >= list->size) {


        list->size *= 2;


        list->data = (int *)realloc(list->data, list->size * sizeof(int));


        if (list->data == NULL) {


            printf("内存分配失败n");


            exit(1);


        }


    }


    for (int i = list->length; i > index; i--) {


        list->data[i] = list->data[i - 1];


    }


    list->data[index] = value;


    list->length++;


}


void deleteSeqList(SeqList *list, int index) {


    if (index < 0 || index >= list->length) {


        printf("删除位置无效n");


        return;


    }


    for (int i = index; i < list->length - 1; i++) {


        list->data[i] = list->data[i + 1];


    }


    list->length--;


}


int findSeqList(SeqList *list, int value) {


    for (int i = 0; i < list->length; i++) {


        if (list->data[i] == value) {


            return i;


        }


    }


    return -1;


}


int main() {


    SeqList *list = createSeqList(10);


    printf("顺序表初始化成功，容量为%dn", list->size);


    insertSeqList(list, 0, 5);


    insertSeqList(list, 1, 10);


    printf("顺序表插入成功，当前长度为%dn", list->length);


    for (int i = 0; i < list->length; i++) {


        printf("%d ", list->data[i]);


    }


    printf("n");


    int index = findSeqList(list, 10);


    if (index != -1) {


        printf("元素10在顺序表中的位置为%dn", index);


    } else {


        printf("元素10不在顺序表中n");


    }


    deleteSeqList(list, 1);


    printf("顺序表删除成功，当前长度为%dn", list->length);


    for (int i = 0; i < list->length; i++) {


        printf("%d ", list->data[i]);


    }


    printf("n");


    destroySeqList(list);


    printf("顺序表销毁成功n");


    return 0;


}

通过以上步骤，可以在C语言中实现顺序表的初始化、插入、删除和查找等基本操作。在实际应用中，可以根据具体需求选择适合的方法来实现顺序表的操作。

相关问答FAQs：

1. 顺序表是什么？C语言如何初始化顺序表？

顺序表是一种线性表的存储结构，它使用一段连续的存储空间来存储数据元素。在C语言中，可以使用数组来实现顺序表。要初始化一个顺序表，首先需要定义一个数组，并为数组分配足够的内存空间。然后，可以通过遍历数组，将每个元素初始化为默认值或者根据需求进行赋值。

2. 如何定义顺序表的容量和元素类型？

在C语言中，定义顺序表的容量和元素类型可以通过定义数组来实现。可以使用关键字"int"、"char"等来指定元素类型，然后使用方括号来指定容量大小。例如，定义一个容量为10的整型顺序表可以使用以下语句：int seqList[10];

3. 如何初始化顺序表的元素？

初始化顺序表的元素可以通过遍历数组，逐个对元素进行赋值。可以使用循环结构，如for循环，来遍历数组，并使用赋值语句对每个元素进行初始化。例如，初始化一个整型顺序表，可以使用以下代码：

for(int i=0; i<10; i++) {
    seqList[i] = i+1;
}

上述代码将顺序表的前10个元素依次赋值为1、2、3、…、10，实现了顺序表的初始化。

原创文章，作者：Edit2，如若转载，请注明出处：https://docs.pingcode.com/baike/1205464

赞 (0)
Edit2Edit2
上一篇 2024年8月30日 下午11:38
下一篇 2024年8月30日 下午11:39
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部