数据结构应用实现

每种数据结构的实现通常可以通过多种语言来完成,以下是一些常用数据结构的基本实现示例,使用C++和Python分别演示:

1. 数组(Array)

C++ 实现
#include <iostream>
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;
}
Python 实现
arr = [1, 2, 3, 4, 5]
for elem in arr:
    print(elem, end=' ')

2. 链表(Linked List)

C++ 单链表实现
#include <iostream>
using namespace std;

struct Node {
    int data;
    Node* next;
};

void insert(Node** head, int data) {
    Node* newNode = new Node();
    newNode->data = data;
    newNode->next = *head;
    *head = newNode;
}

void printList(Node* node) {
    while (node != nullptr) {
        cout << node->data << " ";
        node = node->next;
    }
}

int main() {
    Node* head = nullptr;
    insert(&head, 1);
    insert(&head, 2);
    insert(&head, 3);
    printList(head);
    return 0;
}
Python 单链表实现
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def insert(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node

    def print_list(self):
        temp = self.head
        while temp:
            print(temp.data, end=' ')
            temp = temp.next

ll = LinkedList()
ll.insert(1)
ll.insert(2)
ll.insert(3)
ll.print_list()

3. 栈(Stack)

C++ 实现
#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> s;
    s.push(10);
    s.push(20);
    s.push(30);

    while (!s.empty()) {
        cout << s.top() << " ";
        s.pop();
    }
    return 0;
}
Python 实现
stack = []
stack.append(10)
stack.append(20)
stack.append(30)

while stack:
    print(stack.pop(), end=' ')

4. 队列(Queue)

C++ 实现
#include <iostream>
#include <queue>
using namespace std;

int main() {
    queue<int> q;
    q.push(10);
    q.push(20);
    q.push(30);

    while (!q.empty()) {
        cout << q.front() << " ";
        q.pop();
    }
    return 0;
}
Python 实现
from collections import deque

queue = deque([10, 20, 30])

while queue:
    print(queue.popleft(), end=' ')

5. 哈希表(Hash Table)

C++ 实现
#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    unordered_map<string, int> hashTable;
    hashTable["apple"] = 1;
    hashTable["banana"] = 2;

    for (auto& pair : hashTable) {
        cout << pair.first << ": " << pair.second << endl;
    }
    return 0;
}
Python 实现
hash_table = {"apple": 1, "banana": 2}
for key, value in hash_table.items():
    print(f"{key}: {value}")

6. 二叉树(Binary Tree)

C++ 实现
#include <iostream>
using namespace std;

struct Node {
    int data;
    Node* left;
    Node* right;
    
    Node(int val) : data(val), left(nullptr), right(nullptr) {}
};

void inOrder(Node* node) {
    if (node == nullptr) return;
    inOrder(node->left);
    cout << node->data << " ";
    inOrder(node->right);
}

int main() {
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);
    inOrder(root);
    return 0;
}
Python 实现
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

def in_order(node):
    if not node:
        return
    in_order(node.left)
    print(node.data, end=' ')
    in_order(node.right)

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
in_order(root)

7. 图(Graph)

C++ 邻接表实现
#include <iostream>
#include <vector>
using namespace std;

class Graph {
    int V;
    vector<int>* adj;
public:
    Graph(int V);
    void addEdge(int v, int w);
    void printGraph();
};

Graph::Graph(int V) {
    this->V = V;
    adj = new vector<int>[V];
}

void Graph::addEdge(int v, int w) {
    adj[v].push_back(w);
}

void Graph::printGraph() {
    for (int v = 0; v < V; ++v) {
        cout << v << ": ";
        for (int x : adj[v])
            cout << x << " ";
        cout << endl;
    }
}

int main() {
    Graph g(4);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 2);
    g.addEdge(2, 0);
    g.addEdge(2, 3);
    g.printGraph();
    return 0;
}
Python 邻接表实现
class Graph:
    def __init__(self, vertices):
        self.V = vertices
        self.graph = [[] for _ in range(vertices)]

    def add_edge(self, v, w):
        self.graph[v].append(w)

    def print_graph(self):
        for i in range(self.V):
            print(f"{i}: {self.graph[i]}")

g = Graph(4)
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(2, 0)
g.add_edge(2, 3)
g.print_graph()

8. 堆(Heap)

C++ 实现(最大堆)
#include <iostream>
#include <queue>
using namespace std;

int main() {
    priority_queue<int> maxHeap;
    maxHeap.push(10);
    maxHeap.push(5);
    maxHeap.push(20);

    while (!maxHeap.empty()) {
        cout << maxHeap.top() << " ";
        maxHeap.pop();
    }
    return 0;
}
Python 实现(最小堆)
import heapq

min_heap = []
heapq.heappush(min_heap, 10)
heapq.heappush(min_heap, 5)
heapq.heappush(min_heap, 20)

while min_heap:
    print(heapq.heappop(min_heap), end=' ')

总结

这些是一些常见的数据结构的基本实现,使用不同的编程语言可以用不同的语法和方法来实现它们的操作。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值