Cell Linked List

已于 2024-06-20 14:10:33 修改
阅读量687 收藏 6
点赞数 16
分类专栏： 并行计算算法 文章标签： 算法 性能优化 c++ c语言
于 2024-06-20 13:50:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51476950/article/details/139830607
版权

Cell Linked List

概念

🌟cell linked list算法是一种高效的邻域搜索算法，广泛应用于分子动力学（Molecular Dynamics, MD）模拟中，用于计算原子之间的相互作用力。该算法通过将模拟区域划分成多个小的立方体单元（cells），并使用链表来组织每个单元中的原子数据，从而加速邻域搜索过程。

⭐️过程：通常在有限的截止距离𝑟𝑐内计算相互作用。一个原子只与该截止距离内的原子相互作用，这极大地减少了需要计算的相互作用数量。Cell Linked List通过将模拟盒子分割成更小的单元，并且仅考虑每个单元及其相邻单元内的相互作用。

Cell Linked List步骤

  1. 划分模拟区域：将整个模拟区域划分为一系列小的立方体单元（cells）。这些单元的边长通常选择为原子相互作用力的截断半径（cutoff radius） 𝑟𝑐 的值，这样可以确保每个单元只需要与其周围的单元进行相互作用计算。

  2. 链表构建：

    • 定义数据结构：

      // 数据结构定义
float4* coords;      // 存储原子坐标的数组
int* cell_starts;    // 存储每个单元链表起始索引的数组
int* cell_ends;      // 存储每个单元链表结束索引的数组
int* cell_list;      // 存储链表中每个原子索引的数组

    • 构建细胞链表：每个线程处理一个原子，计算其所在的单元索引。使用原子操作更新单元结束索引，记录原子在细胞链表中的位置。

      __global__ void build_cell_list(int n_atoms, float4* coords, int* cell_starts, int* cell_ends, int* cell_list, int3 n_cells, float3 box_size, float cell_size) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n_atoms) {
        float4 coord = coords[i];
        int3 cell_idx;
        cell_idx.x = floorf(coord.x / cell_size);
        cell_idx.y = floorf(coord.y / cell_size);
        cell_idx.z = floorf(coord.z / cell_size);
​
        cell_idx.x = (cell_idx.x + n_cells.x) % n_cells.x;
        cell_idx.y = (cell_idx.y + n_cells.y) % n_cells.y;
        cell_idx.z = (cell_idx.z + n_cells.z) % n_cells.z;
​
        int cell_idx_flat = cell_idx.x + cell_idx.y * n_cells.x + cell_idx.z * n_cells.x * n_cells.y;
        int cell_start = atomicAdd(&cell_ends[cell_idx_flat], 1);
        cell_list[cell_start] = i;
    }
}

  3. 计算相互作用：每个线程处理一个原子，遍历其所在单元及相邻单元中的原子。如果两个原子之间的距离小于截止距离，则计算并更新它们之间的相互作用力。

    __global__ void compute_interactions(int n_atoms, float4* coords, float4* forces, int* cell_starts, int* cell_ends, int* cell_list, int3 n_cells, float3 box_size, float cell_size, float cutoff_squared) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n_atoms) {
        float4 coord_i = coords[i];
        float4 force_i = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
​
        int3 cell_idx;
        cell_idx.x = floorf(coord_i.x / cell_size);
        cell_idx.y = floorf(coord_i.y / cell_size);
        cell_idx.z = floorf(coord_i.z / cell_size);
​
        cell_idx.x = (cell_idx.x + n_cells.x) % n_cells.x;
        cell_idx.y = (cell_idx.y + n_cells.y) % n_cells.y;
        cell_idx.z = (cell_idx.z + n_cells.z) % n_cells.z;
​
        for (int dx = -1; dx <= 1; ++dx) {
            for (int dy = -1; dy <= 1; ++dy) {
                for (int dz = -1; dz <= 1; ++dz) {
                    int3 neighbor_idx = make_int3(
                        (cell_idx.x + dx + n_cells.x) % n_cells.x,
                        (cell_idx.y + dy + n_cells.y) % n_cells.y,
                        (cell_idx.z + dz + n_cells.z) % n_cells.z
                    );
​
                    int neighbor_idx_flat = neighbor_idx.x + neighbor_idx.y * n_cells.x + neighbor_idx.z * n_cells.x * n_cells.y;
                    for (int j = cell_starts[neighbor_idx_flat]; j < cell_ends[neighbor_idx_flat]; ++j) {
                        int atom_j = cell_list[j];
                        if (i < atom_j) {
                            float4 coord_j = coords[atom_j];
                            float3 r_ij = make_float3(coord_i.x - coord_j.x, coord_i.y - coord_j.y, coord_i.z - coord_j.z);
​
                            if (r_ij.x > box_size.x * 0.5f) r_ij.x -= box_size.x;
                            if (r_ij.y > box_size.y * 0.5f) r_ij.y -= box_size.y;
                            if (r_ij.z > box_size.z * 0.5f) r_ij.z -= box_size.z;
                            if (r_ij.x < -box_size.x * 0.5f) r_ij.x += box_size.x;
                            if (r_ij.y < -box_size.y * 0.5f) r_ij.y += box_size.y;
                            if (r_ij.z < -box_size.z * 0.5f) r_ij.z += box_size.z;
​
                            float r_squared = r_ij.x * r_ij.x + r_ij.y * r_ij.y + r_ij.z * r_ij.z;
                            if (r_squared < cutoff_squared) {
                                float force_magnitude = ...; // 根据相互作用势能计算力的大小
                                float3 force_ij = make_float3(
                                    force_magnitude * r_ij.x,
                                    force_magnitude * r_ij.y,
                                    force_magnitude * r_ij.z
                                );
                                atomicAdd(&forces[i].x, force_ij.x);
                                atomicAdd(&forces[i].y, force_ij.y);
                                atomicAdd(&forces[i].z, force_ij.z);
                                atomicAdd(&forces[atom_j].x, -force_ij.x);
                                atomicAdd(&forces[atom_j].y, -force_ij.y);
                                atomicAdd(&forces[atom_j].z, -force_ij.z);
                            }
                        }
                    }
                }
            }
        }
    }
}

  4. main调用：初始化原子坐标数组和其他辅助数组，分配设备内存。调用 build_cell_list 内核函数构建细胞链表， 调用 compute_interactions 内核函数计算相互作用。

    // 初始化和分配内存
int n_atoms = ...;
int3 n_cells = ...;
float3 box_size = ...;
float cell_size = ...;
float cutoff_squared = ...;
float4* h_coords = ...; // 初始化原子坐标
float4* d_coords;
int* d_cell_starts;
int* d_cell_ends;
int* d_cell_list;
float4* d_forces;

cudaMalloc(&d_coords, n_atoms * sizeof(float4));
cudaMalloc(&d_cell_starts, n_cells.x * n_cells.y * n_cells.z * sizeof(int));
cudaMalloc(&d_cell_ends, n_cells.x * n_cells.y * n_cells.z * sizeof(int));
cudaMalloc(&d_cell_list, n_atoms * sizeof(int));
cudaMalloc(&d_forces, n_atoms * sizeof(float4));

cudaMemcpy(d_coords, h_coords, n_atoms * sizeof(float4), cudaMemcpyHostToDevice);
cudaMemset(d_cell_starts, 0, n_cells.x * n_cells.y * n_cells.z * sizeof(int));
cudaMemset(d_cell_ends, 0, n_cells.x * n_cells.y * n_cells.z * sizeof(int));
cudaMemset(d_forces, 0, n_atoms * sizeof(float4));

// 调用内核函数
int blockSize = 256;
int numBlocks = (n_atoms + blockSize - 1) / blockSize;
build_cell_list<<<numBlocks, blockSize>>>(n_atoms, d_coords, d_cell_starts, d_cell_ends, d_cell_list, n_cells, box_size, cell_size);
compute_interactions<<<numBlocks, blockSize>>>(n_atoms, d_coords, d_forces, d_cell_starts, d_cell_ends, d_cell_list, n_cells, box_size, cell_size, cutoff_squared);

// 释放内存
cudaFree(d_coords);
cudaFree(d_cell_starts);
cudaFree(d_cell_ends);
cudaFree(d_cell_list);
cudaFree(d_forces);

示例代码

#include <cuda_runtime.h>
#include <stdio.h>
#include <math.h>
#include <iostream>
// 内核函数：构建细胞链表
__global__ void build_cell_list(int n_atoms, float4* coords, int* cell_starts, int* cell_ends, int* cell_list, int3 n_cells, float3 box_size, float cell_size) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n_atoms) {
        float4 coord = coords[i];
        int3 cell_idx;
        cell_idx.x = floorf(coord.x / cell_size);
        cell_idx.y = floorf(coord.y / cell_size);
        cell_idx.z = floorf(coord.z / cell_size);
​
        cell_idx.x = (cell_idx.x + n_cells.x) % n_cells.x;
        cell_idx.y = (cell_idx.y + n_cells.y) % n_cells.y;
        cell_idx.z = (cell_idx.z + n_cells.z) % n_cells.z;
​
        int cell_idx_flat = cell_idx.x + cell_idx.y * n_cells.x + cell_idx.z * n_cells.x * n_cells.y;
        int cell_start = atomicAdd(&cell_ends[cell_idx_flat], 1);
        cell_list[cell_start] = i;
    }
}
​
// 内核函数：计算原子之间的相互作用
__global__ void compute_interactions(int n_atoms, float4* coords, float4* forces, int* cell_starts, int* cell_ends, int* cell_list, int3 n_cells, float3 box_size, float cell_size, float cutoff_squared) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n_atoms) {
        float4 coord_i = coords[i];
        float4 force_i = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
​
        int3 cell_idx;
        cell_idx.x = floorf(coord_i.x / cell_size);
        cell_idx.y = floorf(coord_i.y / cell_size);
        cell_idx.z = floorf(coord_i.z / cell_size);
​
        cell_idx.x = (cell_idx.x + n_cells.x) % n_cells.x;
        cell_idx.y = (cell_idx.y + n_cells.y) % n_cells.y;
        cell_idx.z = (cell_idx.z + n_cells.z) % n_cells.z;
​
        for (int dx = -1; dx <= 1; ++dx) {
            for (int dy = -1; dy <= 1; ++dy) {
                for (int dz = -1; dz <= 1; ++dz) {
                    int3 neighbor_idx = make_int3(
                        (cell_idx.x + dx + n_cells.x) % n_cells.x,
                        (cell_idx.y + dy + n_cells.y) % n_cells.y,
                        (cell_idx.z + dz + n_cells.z) % n_cells.z
                    );
​
                    int neighbor_idx_flat = neighbor_idx.x + neighbor_idx.y * n_cells.x + neighbor_idx.z * n_cells.x * n_cells.y;
                    for (int j = cell_starts[neighbor_idx_flat]; j < cell_ends[neighbor_idx_flat]; ++j) {
                        int atom_j = cell_list[j];
                        if (i < atom_j) {
                            float4 coord_j = coords[atom_j];
                            float3 r_ij = make_float3(coord_i.x - coord_j.x, coord_i.y - coord_j.y, coord_i.z - coord_j.z);
​
                            if (r_ij.x > box_size.x * 0.5f) r_ij.x -= box_size.x;
                            if (r_ij.y > box_size.y * 0.5f) r_ij.y -= box_size.y;
                            if (r_ij.z > box_size.z * 0.5f) r_ij.z -= box_size.z;
                            if (r_ij.x < -box_size.x * 0.5f) r_ij.x += box_size.x;
                            if (r_ij.y < -box_size.y * 0.5f) r_ij.y += box_size.y;
                            if (r_ij.z < -box_size.z * 0.5f) r_ij.z += box_size.z;
​
                            float r_squared = r_ij.x * r_ij.x + r_ij.y * r_ij.y + r_ij.z * r_ij.z;
                            if (r_squared < cutoff_squared) {
                                float force_magnitude = 10; // 根据相互作用势能计算力的大小
                                float3 force_ij = make_float3(
                                    force_magnitude * r_ij.x,
                                    force_magnitude * r_ij.y,
                                    force_magnitude * r_ij.z
                                );
                                atomicAdd(&forces[i].x, force_ij.x);
                                atomicAdd(&forces[i].y, force_ij.y);
                                atomicAdd(&forces[i].z, force_ij.z);
                                atomicAdd(&forces[atom_j].x, -force_ij.x);
                                atomicAdd(&forces[atom_j].y, -force_ij.y);
                                atomicAdd(&forces[atom_j].z, -force_ij.z);
                            }
                        }
                    }
                }
            }
        }
    }
}
​
// 内核函数：更新原子位置和速度
__global__ void update_positions(int n_atoms, float4* coords, float4* velocities, float4* forces, float dt) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n_atoms) {
        float4 force = forces[i];
        float3 acceleration = make_float3(force.x, force.y, force.z);
        velocities[i].x += acceleration.x * dt;
        velocities[i].y += acceleration.y * dt;
        velocities[i].z += acceleration.z * dt;
        coords[i].x += velocities[i].x * dt;
        coords[i].y += velocities[i].y * dt;
        coords[i].z += velocities[i].z * dt;
    }
}
​
​
int main() {
    int n_atoms = 1000;
    int3 n_cells = make_int3(10, 10, 10);
    float3 box_size = make_float3(10.0f, 10.0f, 10.0f);
    float cell_size = box_size.x / n_cells.x;
    float cutoff = 2.5f;
    float cutoff_squared = cutoff * cutoff;
    int n_steps = 1000;
    float dt = 0.001f; // 时间步长
​
    float4* h_coords = (float4*)malloc(n_atoms * sizeof(float4));
    float4* h_velocities = (float4*)malloc(n_atoms * sizeof(float4));
    float4* d_coords;
    float4* d_velocities;
    float4* d_forces;
    int* d_cell_starts;
    int* d_cell_ends;
    int* d_cell_list;
​
    // 初始化示例数据
    for (int i = 0; i < n_atoms; ++i) {
        h_coords[i] = make_float4((float)rand() / RAND_MAX * box_size.x,
                                  (float)rand() / RAND_MAX * box_size.y,
                                  (float)rand() / RAND_MAX * box_size.z,
                                  0.0f);
        h_velocities[i] = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
    }
​
    cudaMalloc(&d_coords, n_atoms * sizeof(float4));
    cudaMalloc(&d_velocities, n_atoms * sizeof(float4));
    cudaMalloc(&d_forces, n_atoms * sizeof(float4));
    cudaMalloc(&d_cell_starts, n_cells.x * n_cells.y * n_cells.z * sizeof(int));
    cudaMalloc(&d_cell_ends, n_cells.x * n_cells.y * n_cells.z * sizeof(int));
    cudaMalloc(&d_cell_list, n_atoms * sizeof(int));
​
    cudaMemcpy(d_coords, h_coords, n_atoms * sizeof(float4), cudaMemcpyHostToDevice);
    cudaMemcpy(d_velocities, h_velocities, n_atoms * sizeof(float4), cudaMemcpyHostToDevice);
    cudaMemset(d_cell_starts, 0, n_cells.x * n_cells.y * n_cells.z * sizeof(int));
    cudaMemset(d_cell_ends, 0, n_cells.x * n_cells.y * n_cells.z * sizeof(int));
    cudaMemset(d_forces, 0, n_atoms * sizeof(float4));
​
    int blockSize = 256;
    int numBlocks = (n_atoms + blockSize - 1) / blockSize;
​
    for (int step = 0; step < n_steps; ++step) {
        cudaMemset(d_forces, 0, n_atoms * sizeof(float4)); // 重置力数组
​
        build_cell_list<<<numBlocks, blockSize>>>(n_atoms, d_coords, d_cell_starts, d_cell_ends, d_cell_list, n_cells, box_size, cell_size);
        compute_interactions<<<numBlocks, blockSize>>>(n_atoms, d_coords, d_forces, d_cell_starts, d_cell_ends, d_cell_list, n_cells, box_size, cell_size, cutoff_squared);
        update_positions<<<numBlocks, blockSize>>>(n_atoms, d_coords, d_velocities, d_forces, dt);
​
        // 检查原子是否越界,如果是则应用周期性边界条件
        cudaMemcpy(h_coords, d_coords, n_atoms * sizeof(float4), cudaMemcpyDeviceToHost);
        for (int i = 0; i < n_atoms; ++i) {
            h_coords[i].x = fmodf(h_coords[i].x, box_size.x);
            h_coords[i].y = fmodf(h_coords[i].y, box_size.y);
            h_coords[i].z = fmodf(h_coords[i].z, box_size.z);
        }
        cudaMemcpy(d_coords, h_coords, n_atoms * sizeof(float4), cudaMemcpyHostToDevice);
​
        // 输出当前步的统计信息
        if (step % 100 == 0) {
            float4 total_momentum = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
            cudaMemcpy(&total_momentum, d_velocities, sizeof(float4), cudaMemcpyDeviceToHost);
            for (int i = 1; i < n_atoms; ++i) {
                float4 velocity;
                cudaMemcpy(&velocity, d_velocities + i, sizeof(float4), cudaMemcpyDeviceToHost);
                total_momentum.x += velocity.x;
                total_momentum.y += velocity.y;
                total_momentum.z += velocity.z;
            }
            std::cout << "Step " << step << ": Total Momentum = (" << total_momentum.x << ", " << total_momentum.y << ", " << total_momentum.z << ")" << std::endl;
        }
    }
​
    cudaFree(d_coords);
    cudaFree(d_velocities);
    cudaFree(d_forces);
    cudaFree(d_cell_starts);
    cudaFree(d_cell_ends);
    cudaFree(d_cell_list);
    free(h_coords);
    free(h_velocities);
​
    return 0;
}
GentlemanLin
关注
  • 16
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
hp-lru-cpp:轻量级高性能 LRU C++
07-08
执行：建筑学： HashMapDouble Linked List ----------------------- _______________ cell-1 cell-2cell-n|key-1 | cell-1 ||---------------| ---------|key-2 | cell-2 || key-1 ||---------------||---------|--...
基于SpringBoot框架管理Excel和PDF文件类型
08-25
List<Object> linked = new LinkedList(); for (int j = row.getFirstCellNum(); j (); j++) { XSSFCell cell = row.getCell(j); if (cell == null) { continue; } Object value ; switch (cell.getCellType...
Palindrome Linked List 链表是否对称
Agiz的博客
03-21 106
Given a singly linked list, determine if it is a palindrome. Example 1: Input: 1->2 Output: false Example 2: Input: 1->2->2->1 Output: true Follow up: Could you do it in O(n) time and O...
Array 数组 && Linked List 链表
Sunny_Future的博客
04-10 242
1、数组方法论 1.1 数组的时间复杂度 查询的时间复杂度是 O(1) 插入的平均复杂度是O(n) 删除的平均复杂度也是O(n) 2、链表 查询的时间复杂度是 O(n) 插入的平均复杂度是O(1) 删除的平均复杂度也是O(1) 2.1 Linked List 单向链表 用next指针连向下一个点，形成一张表 在计算机科学中, 一个 链表 是数据元素的线性集合, 元素的线性顺序不是由它们在内存中的物理位置给出的。 相反, 每个元素指向下一个元素。它是由一组节点组成的数据结构,这些节点一起,表
LeetCode 234. Palindrome Linked List(回文链表) -- c语言
d_benhua的博客
05-25 296
234. Palindrome Linked List Given a singly linked list, determine if it is a palindrome. Example 1: Input: 1->2 Output: false Example 2: Input: 1->2->2->1 Output: true Follow up: C...
2.线性表-Linked list
weixin_30832405的博客
11-09 79
fatal.h #include <stdio.h> #include <stdlib.h> #define Error(Str) FatalError(Str) #define FatalError(Str) fprintf(stderr, "%s\n", Str), exit(1) linkedlist.h typedef int ElementT...
Data Structure Study: Linked List(Part A)
Sammy_Chou的博客
11-26 398
Basic ConceptionsDefinition A linked list is a linear collection of data elements, called nodes, each pointing to the next node by means of a pointer. It is a data structure consisting of a group of
Implementation of Static Linked List ( in C/C++ )
DUAN的专栏
06-25 958
Using static linked list is an alternative solution when the programming language you are using does not supportpointer operations. This short article gives some key operations of the static linked
数据结构与算法分析 C 语言描述第二版第三章——链表（linked list）
ALWAYS LEARNING
12-20 398
数据结构与算法分析 C 语言描述第二版第三章——链表（linked list）1. General idea2. Doubly linked lists3. Circularly linked lists4. Examples4.1 The Polynomial ADT 1. General idea The linked list consists a series of structures,...
defination list html 调整颜色,html
weixin_30316287的博客
07-08 102
htmlUsageview: view_name {dimension: field_name {html: ;;}}Possible Field TypesDimension, Dimension Group, MeasureAcceptsAn HTML expression, possibly using Liquid template elements, followed by tw...
JAVA 集合——2.List
weixin_42193767的博客
09-21 287
List java.util.list: 线性表，是一类可以存放重复元素并且有序的集合，可以通过下标操作元素 可重复，有序，下标操作 E get(int index) 获取指定下标处对应的元素 E set（int index ,E e）给定元素设置到指定位置，返回值为原位置对应的元素，所以 set是替换操作 实现了get ，set方法 Arratlist（线）： java.util.Array...
并行 M D优化算法与纳米晶体力学模拟 (2004年)
05-15
MD算法基于经典的对势和多体势上的 Verlet算法,并行格式基于 Linked-Cell-List方案,并针对特定的研究模型进行了各计算层次的优化。构建了交互式显示和控制子系统,可提供显示原子图像和属性的高质量图形输出。利用此...
论文研究-社会力行人仿真模型的分子动力学方法实现.pdf
09-20
将分子动力学的Gear预测校正法应用到社会力仿真模型中，并根据柯朗条件确定了行人仿真显式方法的最小时间步长，引入了链接列表元胞（linked-list cell method）加速算法. 最后设计了编程实现框架，采用VC 实现了...
DevExpress VCL v2012 vol 1.6源码-例子-帮助-part1
11-29
The following sections list all minor and major changes in DevExpress VCL 12.1.6. Note that products, controls and libraries which aren't mentioned in the list below are included in the unified ...
【代码随想录】【算法训练营】【第39天】 [62]不同路径 [63]不同路径II [343]整数拆分 [96]不同的二叉搜索树
weixin_54954007的博客
06-15 793
思路及算法思维，指路。题目来自。day 39，周六，坚持不住了~
算法篇-二叉树
最新发布
分享Java知识，记录思考和感悟
06-21 241
分享二叉树相关概念和算法题
代码随想录二刷DAY1~3
illuosion7的博客
06-16 1081
没做出来，发现问题了，滑动的应当是右指针for()里面填，这样一来，sum的初始化应当放到for的外面。//这句初始化很重要，我们要让反转后的最后一个元素指向nullptr，那么head的pre自然应该初始化为nullptr。题面：在一个排序的链表中，存在重复的节点，请删除该链表中重复的节点，重复的节点不保留。//条件也重要呀，不用判它的next，手写模拟就知道了。这题有难度，要求重复的节点不保留，显然需要三指针了。// 如果是最长，一发现不符合，就扩。//如果是最长，一发现不符合，就扩。
力扣136. 只出现一次的数字
LNsupermali的博客
06-15 573
力扣136. 只出现一次的数字
linked list
05-12
链表（Linked List）是一种常见的数据结构，它由一个节点的集合组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表的每个节点都可以动态地添加、删除和移动。 链表分为单向链表和双向链表。单向链表中每个节点只有一个指向下一个节点的指针，而双向链表中每个节点有两个指针，一个指向前一个节点，一个指向后一个节点。 链表的优点是可以在任意位置添加或删除节点，而不需要像数组一样移动其他元素。缺点是访问元素时需要遍历整个链表，时间复杂度为O(n)，而数组的访问时间复杂度为O(1)。 链表常用于实现栈、队列、哈希表等数据结构，也可以用于解决一些问题，如寻找链表中的环、求链表的中间节点等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GentlemanLin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值