1. PingCode智库首页
  2. 百科

数据结构c语言如何

Edit1 • • 百科

数据结构c语言如何

在C语言中实现数据结构的方法包括：数组、链表、栈、队列、树和图等。每种数据结构都有其独特的应用场景和实现方法。本文将详细介绍每种数据结构的实现方法及其应用场景，并给出具体的代码示例和优化建议。

一、数组

数组的定义与初始化

数组是一组相同类型的数据的集合，存储在连续的内存地址中。数组的定义与初始化在C语言中非常简单。以下是数组的定义与初始化示例：

int arr[10];  // 定义一个包含10个整数的数组


int arr2[] = {1, 2, 3, 4, 5};  // 初始化数组并赋值

数组的优缺点

优点：

  • 访问速度快：由于数组元素存储在连续的内存中，可以通过下标快速访问。
  • 简单易用：定义和操作都比较简单。

缺点：

  • 大小固定：数组一旦定义，大小就不能改变。
  • 内存浪费：如果定义的数组过大，但实际使用时数据量较小，会造成内存浪费。

数组的应用场景

数组适用于需要频繁访问元素的场景，如排序、查找等操作。以下是一个简单的数组排序示例：

#include <stdio.h>


void bubbleSort(int arr[], int n) {


    for (int i = 0; i < n-1; i++) {


        for (int j = 0; j < n-i-1; j++) {


            if (arr[j] > arr[j+1]) {


                int temp = arr[j];


                arr[j] = arr[j+1];


                arr[j+1] = temp;


            }


        }


    }


}


int main() {


    int arr[] = {64, 34, 25, 12, 22, 11, 90};


    int n = sizeof(arr)/sizeof(arr[0]);


    bubbleSort(arr, n);


    printf("Sorted array: n");


    for (int i=0; i < n; i++)


        printf("%d ", arr[i]);


    return 0;


}

二、链表

链表的定义与结构

链表是一种灵活的数据结构，它由一系列节点组成，每个节点包含数据域和指针域。以下是链表节点的定义：

struct Node {


    int data;


    struct Node* next;


};

链表的优缺点

优点：

  • 动态大小：链表的大小可以根据需要动态改变。
  • 高效插入和删除：在已知位置插入或删除元素时，链表不需要移动其他元素。

缺点：

  • 访问速度慢：由于链表不是连续存储的，访问元素时需要从头遍历。
  • 额外的存储开销：每个节点需要额外的指针域来存储下一个节点的地址。

链表的应用场景

链表适用于需要频繁插入和删除元素的场景，如实现队列、栈等。以下是一个简单的链表插入示例：

#include <stdio.h>


#include <stdlib.h>


struct Node {


    int data;


    struct Node* next;


};


void insertAtHead(struct Node head, int newData) {


    struct Node* newNode = (struct Node*) malloc(sizeof(struct Node));


    newNode->data = newData;


    newNode->next = *head;


    *head = newNode;


}


void printList(struct Node* node) {


    while (node != NULL) {


        printf("%d ", node->data);


        node = node->next;


    }


}


int main() {


    struct Node* head = NULL;


    insertAtHead(&head, 1);


    insertAtHead(&head, 2);


    insertAtHead(&head, 3);


    printf("Created Linked List: ");


    printList(head);


    return 0;


}

三、栈

栈的定义与操作

栈是一种后进先出（LIFO）的数据结构，元素的插入和删除都在同一端进行。以下是栈的基本操作：

#include <stdio.h>


#include <stdlib.h>


#define MAX 1000


struct Stack {


    int top;


    int arr[MAX];


};


struct Stack* createStack() {


    struct Stack* stack = (struct Stack*) malloc(sizeof(struct Stack));


    stack->top = -1;


    return stack;


}


int isFull(struct Stack* stack) {


    return stack->top == MAX - 1;


}


int isEmpty(struct Stack* stack) {


    return stack->top == -1;


}


void push(struct Stack* stack, int item) {


    if (isFull(stack))


        return;


    stack->arr[++stack->top] = item;


}


int pop(struct Stack* stack) {


    if (isEmpty(stack))


        return -1;


    return stack->arr[stack->top--];


}

栈的优缺点

优点：

  • 简单高效：操作简单，只需对栈顶元素进行操作。
  • 适用于递归：栈在递归过程中非常有用，可以用于存储临时数据。

缺点：

  • 有限大小：栈的大小是有限的，可能会出现栈溢出问题。
  • 只适用于特定场景：由于只能对栈顶元素进行操作，栈不适用于需要随机访问的场景。

栈的应用场景

栈适用于需要后进先出操作的场景，如表达式求值、括号匹配等。以下是一个简单的括号匹配示例：

#include <stdio.h>


#include <stdlib.h>


#include <string.h>


struct Stack {


    int top;


    unsigned capacity;


    char* array;


};


struct Stack* createStack(unsigned capacity) {


    struct Stack* stack = (struct Stack*) malloc(sizeof(struct Stack));


    stack->capacity = capacity;


    stack->top = -1;


    stack->array = (char*) malloc(stack->capacity * sizeof(char));


    return stack;


}


int isFull(struct Stack* stack) {


    return stack->top == stack->capacity - 1;


}


int isEmpty(struct Stack* stack) {


    return stack->top == -1;


}


void push(struct Stack* stack, char item) {


    if (isFull(stack))


        return;


    stack->array[++stack->top] = item;


}


char pop(struct Stack* stack) {


    if (isEmpty(stack))


        return '';


    return stack->array[stack->top--];


}


int isMatchingPair(char char1, char char2) {


    if (char1 == '(' && char2 == ')')


        return 1;


    else if (char1 == '{' && char2 == '}')


        return 1;


    else if (char1 == '[' && char2 == ']')


        return 1;


    return 0;


}


int areParenthesesBalanced(char exp[]) {


    int i = 0;


    struct Stack* stack = createStack(strlen(exp));


    while (exp[i]) {


        if (exp[i] == '{' || exp[i] == '(' || exp[i] == '[')


            push(stack, exp[i]);


        if (exp[i] == '}' || exp[i] == ')' || exp[i] == ']') {


            if (isEmpty(stack) || !isMatchingPair(pop(stack), exp[i]))


                return 0;


        }


        i++;


    }


    return isEmpty(stack);


}


int main() {


    char exp[] = "{()}[]";


    if (areParenthesesBalanced(exp))


        printf("Balanced n");


    else


        printf("Not Balanced n");


    return 0;


}

四、队列

队列的定义与操作

队列是一种先进先出（FIFO）的数据结构，元素的插入在队尾，删除在队头。以下是队列的基本操作：

#include <stdio.h>


#include <stdlib.h>


#define MAX 1000


struct Queue {


    int front, rear, size;


    unsigned capacity;


    int* array;


};


struct Queue* createQueue(unsigned capacity) {


    struct Queue* queue = (struct Queue*) malloc(sizeof(struct Queue));


    queue->capacity = capacity;


    queue->front = queue->size = 0;


    queue->rear = capacity - 1;


    queue->array = (int*) malloc(queue->capacity * sizeof(int));


    return queue;


}


int isFull(struct Queue* queue) {


    return (queue->size == queue->capacity);


}


int isEmpty(struct Queue* queue) {


    return (queue->size == 0);


}


void enqueue(struct Queue* queue, int item) {


    if (isFull(queue))


        return;


    queue->rear = (queue->rear + 1) % queue->capacity;


    queue->array[queue->rear] = item;


    queue->size = queue->size + 1;


}


int dequeue(struct Queue* queue) {


    if (isEmpty(queue))


        return -1;


    int item = queue->array[queue->front];


    queue->front = (queue->front + 1) % queue->capacity;


    queue->size = queue->size - 1;


    return item;


}

队列的优缺点

优点：

  • FIFO顺序：队列保证了元素的先进先出顺序。
  • 适用于广度优先搜索：在图和树的遍历中非常有用。

缺点：

  • 固定大小：数组实现的队列大小是固定的。
  • 操作复杂：在某些情况下，操作可能比较复杂，如循环队列的实现。

队列的应用场景

队列适用于需要先进先出操作的场景，如任务调度、广度优先搜索等。以下是一个简单的任务调度示例：

#include <stdio.h>


#include <stdlib.h>


#define MAX 1000


struct Queue {


    int front, rear, size;


    unsigned capacity;


    int* array;


};


struct Queue* createQueue(unsigned capacity) {


    struct Queue* queue = (struct Queue*) malloc(sizeof(struct Queue));


    queue->capacity = capacity;


    queue->front = queue->size = 0;


    queue->rear = capacity - 1;


    queue->array = (int*) malloc(queue->capacity * sizeof(int));


    return queue;


}


int isFull(struct Queue* queue) {


    return (queue->size == queue->capacity);


}


int isEmpty(struct Queue* queue) {


    return (queue->size == 0);


}


void enqueue(struct Queue* queue, int item) {


    if (isFull(queue))


        return;


    queue->rear = (queue->rear + 1) % queue->capacity;


    queue->array[queue->rear] = item;


    queue->size = queue->size + 1;


}


int dequeue(struct Queue* queue) {


    if (isEmpty(queue))


        return -1;


    int item = queue->array[queue->front];


    queue->front = (queue->front + 1) % queue->capacity;


    queue->size = queue->size - 1;


    return item;


}


void processTasks(struct Queue* queue) {


    while (!isEmpty(queue)) {


        int task = dequeue(queue);


        printf("Processing task: %dn", task);


    }


}


int main() {


    struct Queue* queue = createQueue(MAX);


    enqueue(queue, 1);


    enqueue(queue, 2);


    enqueue(queue, 3);


    printf("Starting task processing...n");


    processTasks(queue);


    return 0;


}

五、树

树的定义与结构

树是一种层次结构的数据结构，由节点组成，其中每个节点有零个或多个子节点。以下是二叉树节点的定义：

struct TreeNode {


    int data;


    struct TreeNode* left;


    struct TreeNode* right;


};

树的优缺点

优点：

  • 层次结构：适用于表示具有层次关系的数据。
  • 高效查找：在平衡树中，查找、插入和删除操作的时间复杂度是O(log n)。

缺点：

  • 复杂性：实现和维护树结构较为复杂。
  • 内存开销：每个节点需要额外的指针域来存储子节点的地址。

树的应用场景

树适用于表示层次关系的数据，如文件系统、组织结构等。以下是一个简单的二叉树遍历示例：

#include <stdio.h>


#include <stdlib.h>


struct TreeNode {


    int data;


    struct TreeNode* left;


    struct TreeNode* right;


};


struct TreeNode* createNode(int data) {


    struct TreeNode* newNode = (struct TreeNode*) malloc(sizeof(struct TreeNode));


    newNode->data = data;


    newNode->left = NULL;


    newNode->right = NULL;


    return newNode;


}


void inOrder(struct TreeNode* node) {


    if (node == NULL)


        return;


    inOrder(node->left);


    printf("%d ", node->data);


    inOrder(node->right);


}


int main() {


    struct TreeNode* root = createNode(1);


    root->left = createNode(2);


    root->right = createNode(3);


    root->left->left = createNode(4);


    root->left->right = createNode(5);


    printf("In-order traversal of binary tree is: ");


    inOrder(root);


    return 0;


}

六、图

图的定义与结构

图是一种复杂的数据结构，由节点（顶点）和边组成。以下是图的邻接表表示法：

#include <stdio.h>


#include <stdlib.h>


struct AdjListNode {


    int dest;


    struct AdjListNode* next;


};


struct AdjList {


    struct AdjListNode* head;


};


struct Graph {


    int V;


    struct AdjList* array;


};


struct AdjListNode* newAdjListNode(int dest) {


    struct AdjListNode* newNode = (struct AdjListNode*) malloc(sizeof(struct AdjListNode));


    newNode->dest = dest;


    newNode->next = NULL;


    return newNode;


}


struct Graph* createGraph(int V) {


    struct Graph* graph = (struct Graph*) malloc(sizeof(struct Graph));


    graph->V = V;


    graph->array = (struct AdjList*) malloc(V * sizeof(struct AdjList));


    for (int i = 0; i < V; ++i)


        graph->array[i].head = NULL;


    return graph;


}


void addEdge(struct Graph* graph, int src, int dest) {


    struct AdjListNode* newNode = newAdjListNode(dest);


    newNode->next = graph->array[src].head;


    graph->array[src].head = newNode;


}

图的优缺点

优点：

  • 表示复杂关系：可以表示任意复杂的关系。
  • 灵活：可以用多种方式表示，如邻接矩阵、邻接表等。

缺点：

  • 复杂性：实现和操作复杂。
  • 内存开销：邻接矩阵在稀疏图中会浪费大量内存。

图的应用场景

图适用于表示任意复杂关系的数据，如社交网络、网络拓扑等。以下是一个简单的广度优先搜索示例：

#include <stdio.h>


#include <stdlib.h>


struct AdjListNode {


    int dest;


    struct AdjListNode* next;


};


struct AdjList {


    struct AdjListNode* head;


};


struct Graph {


    int V;


    struct AdjList* array;


};


struct AdjListNode* newAdjListNode(int dest) {


    struct AdjListNode* newNode = (struct AdjListNode*) malloc(sizeof(struct AdjListNode));


    newNode->dest = dest;


    newNode->next = NULL;


    return newNode;


}


struct Graph* createGraph(int V) {


    struct Graph* graph = (struct Graph*) malloc(sizeof(struct Graph));


    graph->V = V;


    graph->array = (struct AdjList*) malloc(V * sizeof(struct AdjList));


    for (int i = 0; i < V; ++i)


        graph->array[i].head = NULL;


    return graph;


}


void addEdge(struct Graph* graph, int src, int dest) {


    struct AdjListNode* newNode = newAdjListNode(dest);


    newNode->next = graph->array[src].head;


    graph->array[src].head = newNode;


}


void BFS(struct Graph* graph, int startVertex) {


    int* visited = (int*) malloc(graph->V * sizeof(int));


    for (int i = 0; i < graph->V; i++)


        visited[i] = 0;


    int* queue = (int*) malloc(graph->V * sizeof(int));


    int front = 0, rear = 0;


    visited[startVertex] = 1;


    queue[rear++] = startVertex;


    while (front < rear) {


        int currentVertex = queue[front++];


        printf("Visited %dn", currentVertex);


        struct AdjListNode* temp = graph->array[currentVertex].head;


        while (temp) {


            int adjVertex = temp->dest;


            if (!visited[adjVertex]) {


                visited[adjVertex] = 1;


                queue[rear++] = adjVertex;


            }


            temp = temp->next;


        }


    }


}


int main() {


    struct Graph* graph = createGraph(4);


    addEdge(graph, 0, 1);


    addEdge(graph, 0, 2);


    addEdge(graph, 1, 2);


    addEdge(graph, 2, 0);


    addEdge(graph, 2,

相关问答FAQs：

1. 什么是数据结构？
数据结构是一种组织和存储数据的方式，它能够使我们更高效地访问和操作数据。在C语言中，我们可以使用不同的数据结构来解决不同的问题。

2. C语言中常用的数据结构有哪些？
C语言中常用的数据结构包括数组、链表、栈、队列、树、图等。每种数据结构都有其特定的应用场景和优势，我们可以根据具体问题的需求来选择合适的数据结构。

3. 如何在C语言中实现常见的数据结构？
在C语言中，我们可以使用自定义的结构体来实现数据结构。例如，我们可以定义一个结构体来表示链表的节点，然后使用指针来连接各个节点，从而构建一个链表数据结构。同样地，我们可以使用结构体和指针来实现其他的数据结构，如栈、队列等。

4. 如何使用C语言中的数组？
在C语言中，数组是一种线性的数据结构，它可以存储多个相同类型的元素。我们可以使用下标来访问数组中的元素，例如，arr[0]表示数组arr的第一个元素。同时，我们也可以使用循环来遍历数组中的所有元素。

5. 如何使用C语言中的链表？
在C语言中，链表是一种动态的数据结构，它由多个节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。我们可以使用指针来连接各个节点，从而构建一个链表。通过改变节点之间的指针，我们可以实现插入、删除和查找等操作。

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

赞 (0)
Edit1Edit1
上一篇 2024年8月27日 上午6:33
下一篇 2024年8月27日 上午6:33
免费注册
电话联系

4008001024

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