C++ 有没有结合了数组和链表优点的容器？

Posted 2023-04-23

这种容器我的理解是：
重载了operator[]，时间复杂度<=O（logn）
insert（）函数，插入一个元素 <=O（logn）
erase（）函数，删除一个元素<=O（logn）
之前见过平衡树和哈希表，但觉得它们和数组的使用方式不太一样
比如用map,以int做下标，
比如
a[5]=1,a[6]=2,a[7]=3
删除a[6]
数组中：
a[5]=1,a[6]=3
平衡树：
a[5]=1,a[6]无,a[7]=3
不好用
或者把问题改成“如何像数组一样使用平衡树和哈希表”？

C++语言中可以用数组处理一组数据类型相同的数据，但不允许动态定义数组的大小，即在使用数组之前必须确定数组的大小。而在实际应用中，用户使用数组之前有时无法准确确定数组的大小，只能将数组定义成足够大小，这样数组中有些空间可能不被使用，从而造成内存空间的浪费。
链表是一种常见的数据组织形式，它采用动态分配内存的形式实现。需要时可以用new分配内存空间，不需要时用delete将已分配的空间释放，不会造成内存空间的浪费。
A 从逻辑结构来看
A-1. 数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。
A-2. 链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）
B 从内存存储来看
B-1. (静态)数组从栈中分配空间, 对于程序员方便快速,但是自由度小
B-2. 链表从堆中分配空间, 自由度大但是申请管理比较麻烦. 参考技术A 没有。C++的所有容器没有一样能达到这个效果:
A. Sequence Container
- basic_string
- vector
- list
- forward_list( since 11)
- deque
- array
B. associative container
- map/multimap
- set/multiset
- unordered_map/unordered_multimap( since 11)
- set同上。
其他都不叫容器，包括你可能以为是容器的stack queue any等等。
你要的容器很显然就只能是map。但是正如你所说，它的下标无法做到邻接，因为维护一次邻接需要的复杂度达到nlogn级别。
但是这样的要求真的无法实现吗？不。有一种叫做order statistic tree(名次树)的数据结构能够达到这个要求，它维护键的排名，从而可以以logn级别时间查询到第k大键所在位置，这样，如果你的键是浮点数，那么你就可以达到利用浮点数的数量多这一优点几乎完美(甚至可以认为是完美)地实现你的目的。
gcc拓展pbds(policy-based data structure)中有名次树的红黑树实现，可以使用。
最后作为题外话提醒你一下渐进记号的使用。O(f(n))本身就代表上界，没有T(n)<=O(f(n))这种说法。当然对于渐进记号的讨论超出了这个问题。详见算法导论。追问

是不是把operator[x]转化成求平衡树中第x大的数（key），这个key对应的值就是要求的值。
如何求平衡树第k大数啊
名次树网上的资料太少了，只能查到它能求第k大的数
好吧现在明白了
谢谢

本回答被提问者和网友采纳 参考技术B

你确定平衡树不好用？

#include <map>
using namespace std;

int main() 
map<int, int> s;
s[5] = 1;
s[6] = 2;
s[7] = 3;
s.erase(6); //删除元素
return 0;

参考技术C 没有这样的现成东西

使用邻接表在 C++ 中实现 DFS（使用 <vector> 和链表）

【中文标题】使用邻接表在 C++ 中实现 DFS（使用 <vector> 和链表）

【英文标题】：DFS implementation in c++ using adjacency list (using <vector> and linked list)

【发布时间】：2016-09-26 16:53:06

【问题描述】：

我已经使用和链表制作了一个邻接表。在节点的结构中，我有数据，下一步和访问。当我尝试在 DFS 函数中将访问设置为 true 时，该算法无法正常工作。它仅在我创建一个存储布尔值的新数组并将该数组用于 dfs 算法时才有效。我需要帮助让访问的顶点结构的成员工作。我不确定为什么它不起作用。

图形.h

#ifndef GRAPH_H
#define GRAPH_H
#include <vector>

class Graph
private:
    struct vertex
        int data;
        bool visited;
        struct vertex* next;
    ;

    struct adjList
    
        struct vertex *head;
    ;

    int V;
    bool visited[100];
    std::vector<adjList> G;
public:
    Graph(int vertices);
    vertex* addVertex(int data);
    void addEdge(int index, int data);
    void dfs(int vertex);
    void printGraph();
;

#endif

图形.cpp

#include "Graph.h"
#include <iostream>
#include <cstdlib>
using namespace std;

Graph:: Graph(int vertices)
    this->V=vertices;
    for(int i=0; i<V; i++)
        //allocating space in G for V amount and using constructor of struct
        G.push_back(adjList());
        visited[i]=false;
    

//create a node
Graph:: vertex* Graph::addVertex(int data)
    struct vertex* newNode= new vertex;
    newNode->data= data;
    newNode->next= NULL;
    newNode->visited=false;
    return newNode;

//add an Edge to the list
void Graph:: addEdge(int index, int data)
    struct vertex* cursor= G[index].head;
    while(cursor)
      if(cursor->data==data)
        return;
      cursor= cursor->next;
    
    struct vertex* newVertex= addVertex(data);
    newVertex->next = G[index].head;
    G[index].head= newVertex;
    // this is undirected graph, so we are adding an edge from data to index;
    newVertex = addVertex(index);
    newVertex->next= G[data].head;
    G[data].head= newVertex;

// dfs algorithm
void Graph::dfs(int vertex)
    cout<<vertex<<", ";
    G[vertex].head->visited = true;
    visited[vertex]=true;
    struct vertex* cursor = G[vertex].head;
    while(cursor!=NULL)
      vertex=cursor->data;
      if(visited[vertex]==false)
          dfs(vertex);
      cursor= cursor->next;
    


void Graph::printGraph()
    for(int i=0; i<V; i++)
        struct vertex* cursor= G[i].head;
        cout<<"vertex: "<<i<<endl;
        while(cursor!=NULL)
            cout<<"->"<<cursor->data;
            cursor=cursor->next;
        
        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.printGraph();
    Graph.dfs(0);
    return 0;

【问题讨论】：

那么data中的addEdge是目标顶点吗？然后每条边都有新的顶点，即考虑添加addEdge(0, 3); addEdge(1,3); .. 存在两个顶点“3”，一个在G[0]，另一个在G[1]。因此，当您访问其中一个“3”时，它设置的只是它的本地访问值，另一个不知道。为什么是指针？为什么new？有什么特别的原因，或者这是你想出的最好的而且你不介意完全重写它？

我明白了！是的，我看到了问题。我使用指针是因为我想使用自己的链表。只是使用指针等进行练习。我正在从 Java 过渡到 C++。

对于您当前的图表，您实际上不需要任何顶点，因为顶点根本没有数据，您只需要边数据（from->to 或 v1v2，如果您愿意只有双向边）。并且在 DFS 的开头使用单个本地 vector<bool> visited(vertex_count);（无论该缩写是什么）比“访问”图形数据的一部分更合乎逻辑，如果没有一些正在进行的算法，它是毫无意义的字段（除非它在输入数据中被“访问”过） ，就像一个人去过的城市一样）。因此，您仅在 DFS 期间需要该向量，然后您可以丢弃它。局部变量visited 就是这样。

hmm... 所以.. 您的重点是：1）指针使用和内存管理 2）自己的链表创建 3）现代 C++ 编写 DFS 算法的方法？ （在 3 中不需要 1 和 2 （在这种情况下可以避免裸指针和手动内存管理，并且 STL 中已经有几个容器可用，包括一些列表变体），但是学习它们很好......但是一次一个地关注它们？）...顺便说一句，您使用的new没有delete，这意味着内存泄漏。如果您来自 Java，请先学习使用可用容器 + 局部范围变量，以避免新建/删除。

啊，是的，我明白你的意思。顺便说一下，用于深度优先搜索的“DFS”。谢谢你们的cmets。对认识到我的错误很有帮助。现在，从你的第一条评论开始，你有一个像 addEdge(0, 3); 这样的例子。 addEdge(1,3)，你说 3 现在是 2 个新顶点。我只想要一个现有的顶点而不是两个不同的实例。您建议如何解决此问题？

【参考方案1】：

首先清理你的数据结构，你过早地将它们弯曲以支持你的算法，这会带来一些混乱。首先确保您有一些可靠的“模型”，没有考虑任何算法，然后检查算法需要什么，并将其作为本地临时内部算法添加，或者将一些缓存/扩展数据添加到模型中。但保留核心模型。

我的意思是，让我向您展示您的 DFS 的超级低效但简单的实现，希望可以被认为是“现代 C++”（但我也不是专家）：

现场演示：http://cpp.sh/9fyw

#include <iostream>
#include <vector>
#include <string>

/**
 * Super naive and inefficient (but simple) implementation of Depth-first-search of graph
 * Just to show basic usage of std::vector, and how it helps to avoid new/delete
 **/

struct Vertex 
    // nothing at the moment
;

struct Edge    // One-way edge, to make things intentionally harder
    size_t fromIndex, toIndex;

    Edge(const size_t _fromIndex, const size_t _toIndex)
        : fromIndex(_fromIndex), toIndex(_toIndex) 
;

class Graph 
    std::vector<Vertex> vertices;
    std::vector<Edge> edges;

public:
    Graph(const size_t expectedVerticesCount = 20, const size_t expectedEdgesCount = 50) 
        if (expectedVerticesCount) vertices.reserve(expectedVerticesCount);
        if (expectedEdgesCount) edges.reserve(expectedEdgesCount);
    

    void clear() 
        vertices.clear();
        edges.clear();
    

    void initVertices(const size_t newVertexCount) 
        // A bit pointless function to set vertices, as vertices have no data
        // Storing the count itself inside Graph would suffice,
        // but let's demonstrate vector usage a bit more with N empty vertices
        clear();    // removes old vertices + edges
        vertices.resize(newVertexCount);
    

    void addEdgeBiDirectional(const size_t v1Index, const size_t v2Index) 
        if (vertices.size() <= v1Index || vertices.size() <= v1Index) 
            std::cout << "Ups, unexpected vertex in edge: "
                << v1Index << " <-> " << v2Index << "\n";
            return;
        
        if (v1Index == v2Index) 
            std::cout << "Ups, loop at vertex: " << v1Index << " - ignored\n";
            return;
        
        // Add two one-way edges, to make this edge work in both directions
        edges.push_back(Edge(v1Index, v2Index));
        edges.push_back(Edge(v2Index, v1Index));
    

    void printGraph() 
        for (size_t i = 0; i < vertices.size(); ++i) 
            std::cout << "Vertex " << i << " has edges to:";
            for (const auto & edge : edges) 
                if (edge.fromIndex == i) std::cout << " " << edge.toIndex;
            
            std::cout << "\n";
        
    

private:
    void dfs(std::vector<size_t> & result, std::vector<bool> & visited, size_t v) 
        // It's important to pass vectors as references here (that "&")
        // so you don't fill stack space too quickly, and the modifications
        // done to them inside are propagated up into final result.
        // Without "&" a local copy of vector would be created.
        if (visited[v]) return;
        result.push_back(v);
        visited[v] = true;
        for (const auto edge : edges) 
            if (edge.fromIndex != v) continue;
            dfs(result, visited, edge.toIndex);
        
    

public:
    // Returns vector with vertex indices found
    std::vector<size_t> dfs(const size_t vertexIndex) 
        if (vertices.size() <= vertexIndex) 
            std::cout << "DSF: Ups, invalid starting vertex: "
                << vertexIndex << "\n";
            return std::vector<size_t>();
        

        std::vector<bool> visited(vertices.size());
        std::vector<size_t> result;
        result.reserve(vertices.size());
        dfs(result, visited, vertexIndex);
        return result;
    
;

int main()

    Graph g;
    // fill up graph data
    g.initVertices(5);
    g.addEdgeBiDirectional(0,1);
    g.addEdgeBiDirectional(0,4);
    g.addEdgeBiDirectional(1,2);
    g.addEdgeBiDirectional(1,3);
    g.addEdgeBiDirectional(1,4);
    g.addEdgeBiDirectional(2,3);
    g.addEdgeBiDirectional(3,4);
    // Show the validation works
    g.addEdgeBiDirectional(1,1);
    g.addEdgeBiDirectional(5,4);

    g.printGraph();

    auto dfsResult = g.dfs(2);
    std::cout << "DFS for 2 result:";
    for (const auto v : dfsResult) std::cout << " " << v;
    std::cout << "\n";

（现在我意识到，我的“addEdge”并不能阻止重复的边缘添加，就像你的一样，认为它是错误或功能）

---

如果您检查它，您会发现性能很差，因为它每次都在搜索所有边。如何帮助它？为每个顶点准备好邻居数据。

struct Vertex 
    std::vector<size_t> adjacency;
;

然后在Graph可以为每条添加的边设置相邻顶点：

void addAdjacency(const size_t v1Index, const size_t v2Index) 
    auto & adjacency = vertices[v1Index].adjacency;
    if (adjacency.end() != std::find(adjacency.begin(), adjacency.end(), v2Index)) return;
    adjacency.push_back(v2Index);


void addEdgeBiDirectional(const size_t v1Index, const size_t v2Index) 
    ...
    addAdjacency(v1Index, v2Index);
    addAdjacency(v2Index, v1Index);

现场演示：http://cpp.sh/4saoq

现在它的效率要高得多（就深度优先的效率而言，广度优先搜索会更容易编写，而无需使用大量堆栈空间进行递归）。

但是如果 DFS 和 printGraph 是您唯一的目标，那么可以通过完全删除 edges 并仅保留 vertices 和其中的 adjacency 来重构它。您可以自己尝试一下，您会发现只需少量更改。

但visited 字段仍由dfs 临时拥有，IMO 最适合如何使用它。

---

这已经很长了，而且花了很长时间，以至于我没有心情向您展示带有指针、new 和 delete 的东西。向您展示如何避免它们可能仍然更有益，至少在您可以自己生成类似或更好的代码之前。

学习裸指针/新建/删除的东西也很重要，但是...查看一些教程？

至少有一个提示“何时到delete”：在现代 C++ 中，您可以在 范围 中思考。就像一切都属于某个地方（在某个范围内），然后在退出范围后被释放。通过这种方式，您只需在类中实现构造函数+析构函数，就完成了清理工作。

就像我的示例中的Graph g; 是main 的局部变量，因此在它的范围内。当main被退出时，g的析构函数被调用（我没有写，因为默认析构函数是由编译器创建的，调用vertices和edges析构函数，以及Vertex析构函数被vector析构函数调用，它隐式调用adjacency析构函数。所以一切都被释放了，没有内存泄漏。

如果我会在Graph 中使用一些new 通过它的生命周期（在构造函数中或在某些函数中），我会将指针放在某个 Graph 成员变量中，并编写显式析构函数检查非-nullptr 值，并删除它，或者在某些函数中尽快删除它（并将存储设置为 nullptr 以避免对同一指针进行双重删除）。

因此，如果您确保类的设计有意义，并且所有内容都属于某个合理的范围，那么您可以使用 new/delete 与构造函数/析构函数配对，并且您知道清理会在退出范围时发生，确实如此拥有（负责）那件作品。

还有其他技术，如何将指针（或实际上的任何资源）从原始所有者传递给其他类......通常我会努力避免这种情况，但如果你真的坚持这样的应用程序结构，你可以使用std::unique_ptr 周围的东西。但是这种设计有点难以保持清洁，并且难以追踪特定内存或资源的责任/所有权。观看 this video 的例子，了解如何以某种优雅的方式处理它。

---

还有一些关于new 以及指针和链表的最后说明。从 Java 到链表和哈希映射之类的东西，你可能已经习惯了，这在 VM 下是有意义的，因为你对内存管理几乎没有控制权，而且实例通常被对象元数据“弄脏”。

在 C++ 中则不同，通常开销几乎为零，因此std::vector<uint32_t> millionIntegers(1e6); 是一个长度为 400 万字节的连续内存块，此外还有几个字节的矢量元数据。

这意味着，我的第一个 O(n*n) 示例几乎每次都会遍历所有边，可以用于具有 100+k 个边的图形，其性能非常接近带有指针的 O(n)，因为每个new 可能会在内存的不同部分结束，从而破坏已处理数据的局部性。当您尝试访问缓存内存页面之外的内存时，这会带来巨大的性能损失。虽然以连续方式处理 100k 整数是 CPU 可以半睡半醒的事情，但可以最大限度地提高缓存吞吐量（不幸的是，深度优先也搞砸了）。

这就是为什么在编写第一个版本时通常不应该为容器类型而烦恼。如果vector 适合，请使用它。然后，在您拥有工作、测试过的代码之后，您可以对其进行分析，并尝试一些更智能的内存结构，最终甚至将vector 替换为某种链表。但是你不能只依赖算法理论或“逻辑”。

当涉及 x86 性能时，将真实生产代码剖析得到的硬数据优于真实生产数据至关重要，现代硬件可以在许多方面让人类逻辑感到惊讶，并以意想不到的方式挑战理论。为了获得最佳性能，您需要相当复杂（简单）的算法，以及具有可预测的常规访问模式的整齐排列的数据。仅拥有两者之一可能是不够的。

【讨论】：

美丽。非常感谢您的帮助。对此，我真的非常感激。我很高兴有计算机科学家愿意提供帮助！我一定会看看你提供的资源。 C 和 C++ 是漂亮但复杂的语言哈哈。