C++语言的数据结构

C++语言的数据结构

引言

数据结构是计算机科学中的一个核心概念，它对解决实际问题至关重要。随着计算机技术的快速发展，数据结构在人们生活中的应用愈加广泛，尤其是在软件开发、算法设计及系统性能优化等领域。C++因其面向对象的特性和强大的功能，成为了实现各种数据结构和算法的理想语言。本文将深入探讨C++语言中的几种常见数据结构，并通过实例加以说明。

1. 数据结构概述

数据结构是指在计算机中组织、存储和处理数据的方式，以便于高效地访问和修改。数据结构可以分为线性结构和非线性结构两大类。

1.1 线性结构

线性结构是指元素之间一对一的关系，常见的线性数据结构包括：

• 数组（Array）
• 链表（Linked List）
• 栈（Stack）
• 队列（Queue）

1.2 非线性结构

非线性结构是指元素之间存在一对多或多对多的关系，常见的非线性数据结构包括：

• 树（Tree）
• 图（Graph）
• 散列表（Hash Table）

2. C++中的线性数据结构

2.1 数组

数组是最基本的数据结构，它是相同类型元素的集合。C++中的数组有静态数组和动态数组之分。

示例： ```cpp

include

using namespace std;

int main() { int arr[5] = {1, 2, 3, 4, 5}; for (int i = 0; i < 5; i++) { cout << arr[i] << " "; } return 0; } ```

2.1.1 动态数组

C++可以使用new关键词来创建动态数组，使用delete释放内存。

示例 ： cpp int* dynamicArray = new int[5]; for (int i = 0; i < 5; i++) { dynamicArray[i] = i + 1; } for (int i = 0; i < 5; i++) { cout << dynamicArray[i] << " "; } delete[] dynamicArray;

2.2 链表

链表是一种线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。

示例： ```cpp struct Node { int data; Node* next; };

class LinkedList { public: Node* head;

LinkedList() { head = nullptr; }

void append(int value) {
    Node* newNode = new Node();
    newNode->data = value;
    newNode->next = nullptr;

    if (head == nullptr) {
        head = newNode;
    } else {
        Node* temp = head;
        while (temp->next != nullptr) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}

void display() {
    Node* temp = head;
    while (temp != nullptr) {
        cout << temp->data << " ";
        temp = temp->next;
    }
    cout << endl;
}

};

int main() { LinkedList list; list.append(1); list.append(2); list.append(3); list.display(); return 0; } ```

2.3 栈

栈是一种后进先出（LIFO）的数据结构。C++中可以通过数组或链表实现栈。

示例： ```cpp class Stack { int top; int maxSize; int* stackArray;

public: Stack(int size) { maxSize = size; stackArray = new int[maxSize]; top = -1; }

~Stack() {
    delete[] stackArray;
}

void push(int value) {
    if (top < maxSize - 1) {
        stackArray[++top] = value;
    } else {
        cout << "Stack Overflow" << endl;
    }
}

int pop() {
    if (top >= 0) {
        return stackArray[top--];
    } else {
        cout << "Stack Underflow" << endl;
        return -1; // or throw exception
    }
}

};

int main() { Stack stack(5); stack.push(1); stack.push(2); stack.push(3); cout << stack.pop() << endl; // 输出3 return 0; } ```

2.4 队列

队列是一种先进先出（FIFO）的数据结构，C++中也可以通过数组或链表实现队列。

示例： ```cpp class Queue { int front, rear, maxSize; int* queueArray;

public: Queue(int size) { maxSize = size; queueArray = new int[maxSize]; front = -1; rear = -1; }

~Queue() {
    delete[] queueArray;
}

void enqueue(int value) {
    if (rear < maxSize - 1) {
        if (front == -1) front = 0;
        queueArray[++rear] = value;
    } else {
        cout << "Queue Overflow" << endl;
    }
}

int dequeue() {
    if (front <= rear) {
        return queueArray[front++];
    } else {
        cout << "Queue Underflow" << endl;
        return -1; // or throw exception
    }
}

};

int main() { Queue queue(5); queue.enqueue(1); queue.enqueue(2); queue.enqueue(3); cout << queue.dequeue() << endl; // 输出1 return 0; } ```

3. C++中的非线性数据结构

3.1 树

树是一种非线性的数据结构，广泛应用于数据库、文件系统等。二叉树是最常见的树结构。

示例 ： ```cpp struct TreeNode { int data; TreeNodeleft; TreeNode right;

TreeNode(int value) : data(value), left(nullptr), right(nullptr) {}

};

class BinaryTree { public: TreeNode* root;

BinaryTree() { root = nullptr; }

void insert(int value) {
    root = insertRec(root, value);
}

TreeNode* insertRec(TreeNode* node, int value) {
    if (node == nullptr) {
        return new TreeNode(value);
    }

    if (value < node->data) {
        node->left = insertRec(node->left, value);
    } else {
        node->right = insertRec(node->right, value);
    }
    return node;
}

void inorder() {
    inorderRec(root);
}

void inorderRec(TreeNode* node) {
    if (node != nullptr) {
        inorderRec(node->left);
        cout << node->data << " ";
        inorderRec(node->right);
    }
}

};

int main() { BinaryTree tree; tree.insert(5); tree.insert(3); tree.insert(7); tree.inorder(); // 输出 3 5 7 return 0; } ```

3.2 图

图是一种复杂的非线性结构，由节点和边组成。在C++中，图可以通过邻接矩阵或邻接表来实现。

示例（邻接表）： ```cpp

include

include

using namespace std;

class Graph { int V; // 顶点数 vector > adj; // 邻接表

public: Graph(int v) : V(v), adj(v) {}

void addEdge(int u, int v) {
    adj[u].push_back(v);
    adj[v].push_back(u); // 如果是有向图，可以去掉这一行
}

void display() {
    for (int i = 0; i < V; ++i) {
        cout << "Vertex " << i << ":";
        for (int j : adj[i]) {
            cout << " -> " << j;
        }
        cout << endl;
    }
}

};

int main() { Graph graph(5); graph.addEdge(0, 1); graph.addEdge(0, 4); graph.addEdge(1, 2); graph.addEdge(1, 3); graph.addEdge(1, 4); graph.addEdge(2, 3); graph.addEdge(3, 4);

graph.display();
return 0;

} ```

3.3 散列表

散列表是一种能够提供快速数据检索的数据结构。C++的STL有现成的unordered_map，这里我们简单实现一个。

示例： ```cpp

include

include

using namespace std;

class HashTable { vector >> table; // 存储键值对的链表 int size;

public: HashTable(int s) : size(s) { table.resize(size); }

int hashFunction(int key) {
    return key % size;
}

void insert(int key, int value) {
    int index = hashFunction(key);
    table[index].push_back(make_pair(key, value));
}

int search(int key) {
    int index = hashFunction(key);
    for (auto& pair : table[index]) {
        if (pair.first == key) {
            return pair.second;
        }
    }
    return -1; // 若未找到
}

};

int main() { HashTable hashTable(7); hashTable.insert(1, 10); hashTable.insert(2, 20); hashTable.insert(15, 30);

cout << "Value for key 1: " << hashTable.search(1) << endl; // 输出10
cout << "Value for key 15: " << hashTable.search(15) << endl; // 输出30
return 0;

} ```

结论

数据结构是程序设计的基础，C++作为一种强大的编程语言，为我们提供了丰富的工具和灵活的实现。通过对线性和非线性数据结构的深入研究，我们可以更好地设计和优化程序，提高效率和性能。

理解和掌握各种数据结构在现代软件开发中是不可或缺的。同时，它也为解决复杂问题提供了有效的方法论。因此，学习C++中的数据结构，不仅能够提高编程技能，还能够为后续的算法学习打下坚实的基础。