用v语言写一个最基本的链表
时间: 2023-03-25 10:01:08 浏览: 80
可以的,以下是用 V 语言实现最基本的链表的代码:
```
struct Node {
int value;
Node* next;
}
fn main() {
let head = Node{value: 1, next: null};
let node1 = Node{value: 2, next: null};
let node2 = Node{value: 3, next: null};
head.next = &node1;
node1.next = &node2;
}
```
这个链表包含三个节点,每个节点都有一个值和一个指向下一个节点的指针。在这个例子中,我们创建了一个头节点,然后创建两个子节点,并将它们链接到头节点上。
相关问题
用C++语言实现一个双向循环链表
双向循环链表是一种链式存储结构,每个节点包含一个指向前驱节点和后继节点的指针。在C++语言中,可以通过定义一个双向循环链表类来实现该数据结构。
以下是一个简单的双向循环链表类的实现:
```cpp
class Node {
public:
int value;
Node* prev;
Node* next;
Node(int v) : value(v), prev(nullptr), next(nullptr) {}
};
class DoublyLinkedList {
public:
DoublyLinkedList() : head(nullptr), tail(nullptr), size(0) {}
~DoublyLinkedList() {
while (head != nullptr) {
Node* temp = head;
head = head->next;
delete temp;
}
tail = nullptr;
size = 0;
}
bool empty() const {
return size == 0;
}
int length() const {
return size;
}
void push_front(int v) {
Node* newNode = new Node(v);
if (empty()) {
head = tail = newNode;
} else {
newNode->next = head;
head->prev = newNode;
head = newNode;
}
tail->next = head;
head->prev = tail;
size++;
}
void push_back(int v) {
if (empty()) {
push_front(v);
} else {
Node* newNode = new Node(v);
newNode->prev = tail;
tail->next = newNode;
tail = newNode;
tail->next = head;
head->prev = tail;
size++;
}
}
void pop_front() {
if (size == 1) {
delete head;
head = tail = nullptr;
size = 0;
} else if (!empty()) {
Node* temp = head;
head = head->next;
head->prev = tail;
tail->next = head;
delete temp;
size--;
}
}
void pop_back() {
if (size == 1) {
pop_front();
} else if (!empty()) {
Node* temp = tail;
tail = tail->prev;
tail->next = head;
head->prev = tail;
delete temp;
size--;
}
}
private:
Node* head;
Node* tail;
int size;
};
```
该类包含两个私有成员变量 `head` 和 `tail`,分别指向链表的头节点和尾节点,以及一个整型变量 `size` 表示链表的长度。类的公有成员函数包括:
- `empty()`:判断链表是否为空。
- `length()`:返回链表的长度。
- `push_front(int v)`:在链表头部插入一个值为 `v` 的节点。
- `push_back(int v)`:在链表尾部插入一个值为 `v` 的节点。
- `pop_front()`:删除链表头部的节点。
- `pop_back()`:删除链表尾部的节点。
注意,在插入第一个节点时,需要将 `head` 和 `tail` 都指向该节点,并且将该节点的 `next` 和 `prev` 指针都指向自身。在删除最后一个节点时,需要特别处理,即将 `head` 和 `tail` 都置为 `nullptr`。
可以使用以下代码进行测试:
```cpp
#include <iostream>
int main() {
DoublyLinkedList list;
std::cout << "Empty: " << list.empty() << std::endl;
std::cout << "Length: " << list.length() << std::endl;
list.push_back(1);
list.push_front(2);
list.push_back(3);
std::cout << "Empty: " << list.empty() << std::endl;
std::cout << "Length: " << list.length() << std::endl;
list.pop_front();
list.pop_back();
std::cout << "Empty: " << list.empty() << std::endl;
std::cout << "Length: " << list.length() << std::endl;
return 0;
}
```
用c写一个邻接链表的spfa算法
好的,以下是用 C 语言实现邻接链表的 SPFA 算法的代码:
```c
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAXN 100005
#define INF 0x3f3f3f3f
typedef struct Edge {
int to, w, nxt;
} Edge;
Edge edge[MAXN << 1];
int head[MAXN], dis[MAXN], cnt[MAXN];
bool vis[MAXN];
int n, m, s, t, tot;
void addEdge(int u, int v, int w) {
edge[++tot].to = v;
edge[tot].w = w;
edge[tot].nxt = head[u];
head[u] = tot;
}
bool spfa(int s, int t) {
for (int i = 1; i <= n; i++) {
dis[i] = INF;
vis[i] = false;
cnt[i] = 0;
}
dis[s] = 0;
vis[s] = true;
cnt[s] = 1;
int queue[MAXN], front = 0, rear = 0;
queue[rear++] = s;
while (front != rear) {
int u = queue[front++];
if (front == MAXN) front = 0;
vis[u] = false;
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to, w = edge[i].w;
if (dis[v] > dis[u] + w) {
dis[v] = dis[u] + w;
if (!vis[v]) {
vis[v] = true;
queue[rear++] = v;
if (rear == MAXN) rear = 0;
if (++cnt[v] > n) return false;
}
}
}
}
return true;
}
int main() {
scanf("%d%d%d%d", &n, &m, &s, &t);
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
addEdge(u, v, w);
addEdge(v, u, w);
}
if (spfa(s, t)) printf("%d\n", dis[t]);
else printf("No solution!\n");
return 0;
}
```
希望这个代码能够帮到你!