动态数组在内存中是连续分配的吗？
动态数组在内存中是连续分配的。
动态数组是一种可以根据需要自动扩展或缩小长度的数组。它在内存中分配一块连续的存储区域来存储数据。
当动态数组需要扩展时，它会申请一块更大的内存空间，并将原有数据复制到新的内存空间中。这意味着动态数组在扩展时可能需要重新分配一块更大的连续内存区域来存储数据。
相反，当动态数组需要缩小时，它会释放多余的内存空间，并将数据复制到较小的内存空间中。这意味着动态数组在缩小时可能需要重新分配一块较小的连续内存区域来存储数据。
总之，动态数组在内存中是连续分配的，但在扩展或缩小时可能需要重新分配连续的内存空间。这是为了确保动态数组的灵活性和效率。
相关·内容
5回答
1.这两个维度是如何存储在内存中的，它们是连续的吗？(我的意思是intM，不是动态分配，我认为intM发生在堆栈区域，所以是连续的，不是吗？)
2. malloc分配的区域是否必须是连续的？
3.如果不需要动态分配内存空间，应该在哪里使用？堆栈或堆。例如，我想要一个字符数组来存储10000个字符，那么我应该使用：
char a[10000];
或
char *a = calloc(sizeof(char),10000);
“函数调用栈”是否与变量栈在同一区域？？在同一堆栈中还是不同？
浏览 3提问于2013-02-23得票数 3
回答已采纳
正如我上面描述的，当我动态分配二维数组时，每行总是有12字节的间隙。
在该代码中，我预计ppa1为0x1005626e4。但结果是0x1005626f0。我知道动态分配可能不会在相邻的空间中分配。但总有至少12字节的间隙。(实际上，每一行都分配在不同的空间中)。
我知道当在堆中分配时，需要一些存储信息的空间。例如尺寸、类型..。这就是12位拜特的原因吗？如果有人知道12 Byte的真实原因，告诉我这件事。
代码
int** ppa;
ppa = new int*[3];
for (int i = 0; i < 3; ++i) {
ppa[i] = new int[5];
c
浏览 1提问于2020-01-04得票数 0
回答已采纳
2回答
C语言中的动态数组实现
、、、、
C中的realloc函数是否分配连续内存空间？
我正在尝试实现动态整数数组。是按数组元素的大小还是按1来增加指针？
在C中还有其他更好的方法来实现动态数组吗？
浏览 1提问于2014-01-31得票数 1
回答已采纳
3回答
我知道局部变量将按顺序存储在堆栈中。
但是，当我在c++中动态分配堆内存中的变量时，就像这样。
int * a = new int{1};
int * a2 = new int{2};
int * a3 = new int{3};
int * a4 = new int{4};
问题1:这些变量是否存储在连续的内存位置？问题2:如果不是，是因为动态分配将变量存储在堆内存中的随机位置吗？Question3 :那么动态分配是否会增加缓存未命中的可能性，并具有低空间局部性？
浏览 0提问于2019-03-16得票数 3
1回答
下面的C代码创建了一个动态分配的2D数组。
numbersArray = (int **)malloc(sizeof(int *)* primeNumber);
for (i =0 ; i < primeNumber; i++)
numbersArray[i] = (int *)malloc(sizeof(int)*2);
numbersArray是全局定义的，primeNumber只是我在程序执行过程中计算出来的一个数字。
我的程序执行得很好，没有问题。我可以在数组上执行各种进程。一切都很好。
我的问题是，Xcode 5在调试时没有显示numbersArray的内容。它只显示
浏览 4提问于2013-11-18得票数 2
回答已采纳
3回答
我有几个关于多维数组的问题。我知道如何为它们分配内存，但我不明白为什么需要(除了使内容更具可读性之外)。
数组的[]操作符是重载的，对吗？那么，为什么不能分配单个内存块并由1dArray[i*nInRow][offset]授予访问权限呢？
使用多维数组是否会进一步提高性能？另外，当内存被动态分配给2d数组时，它们是存储在连续的位置，还是分散在堆中？当请求数据时，我可以假设所有内容都是以块的形式从内存中拉出的吗？
我看到的大多数信息都只是解释了语法。任何答案或建议阅读都会很棒。
浏览 2提问于2012-11-08得票数 2
回答已采纳
1回答
如何清空动态数组
、、、
我需要多次重用动态数组，因为我认为它是一个更好的性能。因此，我不需要每次需要时都创建一个新的动态数组。
我想问一下，如果我在几条指令中使用相同的数组，然后清除并重用它，那么它是否会导致错误和效率低下呢？我怎样才能纠正我的程序，所以，它可能会接近我的需要。我的代码：
procedure Empty(local_array : array of Integer);
var
i : Integer;
begin
for i:= 0 to high(local_array) do
local_array[i]:= nil;
Setlength(loc
浏览 1提问于2020-10-04得票数 0
回答已采纳
1回答
我在某个地方看到了下面的代码，我有点困惑。
int**** m_ppppCoder;
m_ppppCoder = new int ***[10];
这是一个动态分配的三维int数组吗？有人能确切地解释一下它是怎么工作的吗？
在阅读了注释之后添加了这样的注释:上面的声明本身并不是一个完整的3d int数组，而是创建数组第一步的声明结构。根据这一点，使用下面的代码，您可以动态创建一个3d数组。是这样吗？
m_ppppCoder[0] = new int **[10];
m_ppppCoder[0][0] = new int *[10];
m_ppppCoder[0][0][0
浏览 1提问于2018-08-03得票数 3
回答已采纳
1回答
使用数组组件设计派生类型
、、、、
在设计派生类型时，我很难找到任何具体的信息。我认为讨论这个问题的最好方法是通过几个选项。我已经用派生类型的不同应用程序组成了一些代码部分。我更喜欢对nparts、index和refs使用动态数组。我省略了实际使用该结构的代码部分(没有任何部分，因为是我编出来的)，但是会显示一个示例，并且在例程中，我打算至少使用结构中的所有值一次。
选项A:在派生类型中使用静态数组。缺点是我必须在编译时猜测数组大小。
! Known before compile time.
nboxes = 5000
max_parts = 2000
packs = 10
Type Boxes
Sequence
浏览 4提问于2016-12-10得票数 3
回答已采纳
我正在解决一个问题，这个问题需要5维数组(动态分配)，步骤数至少为1000。该代码适用于50个步骤。然而，当步骤数增加时，它会给出一个错误'terminate called what()：std::bad_alloc Aborted (core dumped)‘。有什么建议吗？
浏览 14提问于2019-05-24得票数 0
2回答
我编写了一个32位程序，使用一个动态数组来存储一个具有未知计数的三角形列表。我目前的策略是估计大量三角形，然后在创建所有三角形时修剪列表。在某些情况下，我只会在其他情况下分配一次内存，我需要在分配中添加。
对于一个非常大的数据集，当我的应用程序是内存时，内存就会耗尽，内存使用量大约为1.2GB，而且由于分配步骤太大，我觉得自己可能正在分割内存。
看看FastMM (内存管理器)，我看到了这些常量，这表明其中一个是一个很好的增量大小。
ChunkSize = 64 * 1024;
MaximumSmallBlockSize = 32752;
LargeBlockGranularity = 64
浏览 6提问于2015-02-16得票数 2
回答已采纳
6回答
动态分配数组解释
、、、
这是我的老师教我们的示例代码“如何在C中动态分配数组？”但我不完全理解。以下是代码：
int k;
int** test;
printf("Enter a value for k: ");
scanf("%d", &k);
test = (int **)malloc(k * sizeof(int*));
for (i = 0; i < k; i++) {
test[i] = (int*)malloc(k * sizeof(int)); //Initialize all the values
}
我想，在C中，要定义一个数组，必须将[]放在名
浏览 7提问于2013-10-08得票数 4
回答已采纳
如何实现C++向量类以允许动态调整数组大小？
它是通过链表类型的实现完成的吗？是否每次添加或删除元素时都会从头开始创建一个新数组？
谢谢，R
浏览 4提问于2010-11-22得票数 0
回答已采纳
1回答
德克是不是连续的记忆容器？
斯科特·迈尔斯的著名著作“有效STL”如下所示
连续内存容器(也称为基于数组的容器)将它们的元素存储在一个或多个(动态分配)内存块中，每个块包含多个容器元素。如果插入新元素或删除现有元素，则必须上下移动同一内存块中的其他元素，以便为新元素腾出空间，或填补删除元素以前占用的空间。这种移动既会影响性能(见项目5和14)，也会影响异常安全(我们很快就会看到)。标准的连续内存容器是向量、字符串和deque。非标准绳索也是一个连续的内存容器.
但是你可以在cppreference.com中找到相反的解释
与std：：相比，deque的元素不是连续存储的:典型实现使用一系列单
浏览 6提问于2022-04-07得票数 4
回答已采纳
2回答
单链表是动态数组吗？
、、、
我试着在考试前更好地理解我的定义，有些问题会包含“动态数组”这个术语。因此，我害怕在这些情况下使用单链接列表，因为它们提供了简单的、高效的堆栈实现，但可能不被视为动态数组。
支持和反对单链列表是动态数组的参数是什么？
据我所知，动态数组只是一个数组，它根据其中的元素分配一些动态空间。在这种情况下，链接列表的大小与其中的元素对应1:1；因此是动态的。
另一方面，我的老师用过的例子，在我们的教科书中，动态数组是连续数组，或者更确切地说，数组被定义为连续序列。也就是说，arrayi是i'th元素，arrayi+1是i+1'th元素(如果f.ex命令数组的话)。但是单链表(两个键数组和
浏览 5提问于2022-03-16得票数 0
回答已采纳
3回答
我想用malloc声明一个二维数组。在互联网上查找时，所有网站都告诉声明一个int **指针，然后使用malloc首先将单个指针分配给一维数组，然后再次使用malloc为各个int分配空间。我怀疑以这种方式声明的数组并没有在连续的内存地址中保存它的元素。而下面的方式仅使用一条malloc语句，并且动态地分配2d数组，并且所有地址都是根据需要是连续的。那么，下面不应该是动态分配2d数组的正确方法吗？
#include <stdio.h>
int main(){
int (*p)[2] = malloc(3 * sizeof *p);
int i;
int j
浏览 1提问于2013-06-30得票数 8
回答已采纳
2回答
我一直试图找出一种有效的方法来管理动态数组，我可能偶尔会更改，但希望经常随机访问和迭代。
我希望能够：
将数组存储在连续数据块中(减少缓存丢失)
单独和独立于数组句柄访问每个元素(指针>索引)
调整数组的大小(动态)
为了实现这一点，我一直在使用std::vector<T>::iterator进行尝试，而且效果很好，直到最近，我调整了存储迭代器的向量(例如调用push_back())的大小。所有迭代器都变得无效，因为它们指向的是陈旧的内存。
是否有任何有效(可能是STL-)的方法来保持迭代器指针的最新信息？或者我必须手动更新每个迭代器吗？
这样的做法值得吗
浏览 3提问于2017-08-24得票数 6
回答已采纳
我正在学习C#，基本上知道数组和List之间的区别，最后一个是泛型，可以动态增长，但我想知道：
List元素是顺序地位于堆中的数组中，还是每个元素“随机”地位于不同的位置？
如果是这样的话，这会影响从内存中访问和数据检索的速度吗？
如果是这样的话，这是否使数组比List的速度更快呢？
浏览 2提问于2013-08-11得票数 5
回答已采纳
我对CS概念已经生疏了，正在看，大约9:00他们谈论数组是固定长度的。这是因为它们需要事先告诉堆栈分配给该结构多少内存，以便可以将其他内存位置分配到其他地方。
我目前是一名JavaScript开发人员，但过去曾使用过Java。为什么可以动态分配([].push(element)) JavaScript数组？
我从更深层次的角度来问这个问题-我知道JS中的数组是没有“长度”概念的对象，但是当你可以请求数组的长度并像数组一样通过索引访问它的值时，它就会变得令人困惑。
那么，这是否意味着JS对象只与堆内存交互？JS中有固定长度结构的概念吗？
浏览 1提问于2016-10-09得票数 0
1回答
我有一个关于字符串数组实现的问题。假设我有这样的数组：
string[] strings = new string[4];
我知道有4位数组。单元格之间的距离相同，因此数组知道如何到达每个单元格。
我的问题是关于单元格内部的引用，它们也必须具有相同的距离吗？每个元素都可以在任何地方吗？
浏览 0提问于2018-12-31得票数 0
int* ptr;
ptr=(int*)malloc(sizeof(int)); //(A)
ptr=(int*)malloc(5*sizeof(int)); //(B)
在第(A)行，将动态创建一个4字节的块。现在这没问题了。但我的问题是，在B行，它会创建一个20(5*4)字节的块吗？还是4字节大小的5个独立的块？如果它创建了一个单独的块，那么它们会是连续的吗？ptr=(int*)malloc(5*sizeof(int)); and ptr=(int*)calloc(5,sizeof(int));是等价的吗？
浏览 0提问于2017-08-17得票数 1
据我所知，每个计算机程序都使用虚拟内存，物理内存的处理方式取决于操作系统。
我正在参加一门算法工程课程，在某个时候有人提到，如果缓存内存是无限的，并且有一条缓存行是B大小的，那么如果您只想扫描一个N元素数组，那么所期望的缓存丢失量将是N/B。
理论上，我可以看到这是如何工作的，因为我们假设N元素在物理内存中一个接一个地被定位。
但是，在实践中，这是真的吗？如果虚拟内存是按顺序分配的，这是否也意味着物理内存也将按顺序分配？
在我看来，在实践中，假设N不大于缓存大小，如果物理内存( N )中没有顺序分配N元素，您将得到比N缓存丢失的更多信息。
也许我误解了虚拟记忆和物理记忆的区别，我不确定。
浏览 2提问于2015-03-25得票数 4
回答已采纳
这是一个包含一个名为"map“的字符的2d数组的类。首先，我将mapDimension char*s分配给char**。然后，我将mapDimension字符分配给每个字符*。我是这样做的，而不是静态的: char mapmapDimension，因为虽然这适用于小数字，但一旦mapDimension超过2500，它也会出现分段错误。我希望在堆上而不是堆栈上分配内存，这样我就可以容纳更多的内存。
构造函数中的最后两行是将2d数组中的每个字符初始化为0，然后将中心设置为5。
#define mapDimension 1000
class Field
{
private:
浏览 2提问于2015-07-15得票数 0
回答已采纳
许多80年代的计算机爱好者都听说过Infocom系列互动小说游戏，著名的有“卓克”、“银河系漫游指南”、“星球坠落”、“永远的心灵之旅”、。
这些游戏是在虚拟机上实现的。机器被实现为一个RAM块、一个堆栈和一个虚拟处理器。该进程执行可动态读取和写入RAM的指令。
我的问题是: VMs是动态的。什么是有效和合理的惯用方式来表示这个RAM (以及更全面的虚拟机结构)，以便我可以实现软件来运行这些游戏？例如，我应该使用Data.Array来表示内存和状态monad吗？
浏览 0提问于2011-01-17得票数 6
回答已采纳
3回答
在许多嵌入式系统中，内存碎片是一个令人担忧的问题。特别是对于长时间运行的软件(几个月，几年，等等)。对于许多项目，解决方案是简单地不使用动态内存分配，如malloc/free和new/delete。只要有可能，就使用全局内存，频繁分配和释放的类型的内存池是避免动态内存管理使用的好策略。
在嵌入式Linux中，如何解决这个问题？我看到很多库都使用动态内存。操作系统是否有防止内存碎片的机制？它会定期清理堆吗？或者应该避免在嵌入式环境中使用这些库？
浏览 1提问于2011-01-17得票数 2
回答已采纳
我正在尝试实现理解动态内存分配是如何发生的。所以我想用sbrk()系统调用来实现我自己的malloc。这里的问题是，当我试图分配动态内存时，sbrk()和malloc()返回不同的不连续地址。
这是我的密码
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char** argv)
{
printf("\nsbrk(0) %llu &#
浏览 3提问于2019-05-22得票数 2
回答已采纳
5回答
这个问题类似于
我理解，在增加数组指针后删除它是不可能的，因为它失去了要清除多少字节的跟踪。但是，我无法理解为什么动态数组的逐个删除/取消分配也不起作用。
int main()
{
int n = 5;
int *p = new int[n];
for(int i=0;i<n;++i){
delete &p[i];
}
}
我认为这是可行的，但是在clang12.0中，如果指针错误无效，它就会失败。有人能解释原因吗？
浏览 21提问于2022-09-08得票数 1
下面的代码通过嵌套的for循环输出动态分配数组的内存地址序列，然后输出常规的2D数组( ints)。
#include <iostream>
using namespace std;
int main()
{
int regArray[3][3]; //a normal 2d array
int **allocatedArray = new int*[3];
for (int i = 0; i < 3; i++)
allocatedArray[i] = new int[3]; //an allocated 2d array
浏览 4提问于2015-12-27得票数 0
回答已采纳
4回答
我试图创建一个动态的5x5 int数组。
int **data=malloc(5*5);
但我在试图访问它时会有分割错误。
浏览 3提问于2015-11-19得票数 4
回答已采纳
假设我不想使用向量和使用动态数组(只是学习的目的)。从我分配的这个动态数组中，我想删除特定的索引。
int * array = new int[10];
delete &array[3];
当我尝试这样做的时候，我得到了SIGSEGV，分割错误。
我如何删除特定的索引(比方说索引3，我知道它的连续内存，它会造成空洞，但只是为了学习目的)，就像我试图正确地做上面那样，如果这是我的记忆，为什么我会有分段错误呢？
浏览 4提问于2016-10-11得票数 0
回答已采纳
4回答
当使用数组时，我正试图了解原始内存在不同语言中的样子。
考虑以下Java代码：
String a = "hi";
String b = "there";
String c = "everyone";
String[] array = {a, b, c};
显然，数组保存的是引用，而不是对象；也就是说，内存中有一个连续的数组，每个数组都指向内存中对象所在的其他位置。因此，对象本身并不一定位于三个连续的桶中；相反，引用是。
现在考虑这一点：
String[] array = {"hi", "there", "e
浏览 11提问于2015-09-03得票数 7
回答已采纳
2回答
我正在Windows7上尝试在C中实现一些数学算法，我需要反复增加数组的大小。
有时，由于realloc不能分配内存，所以它失败了。但是，如果我一开始就分配了大量的内存，它就能正常工作。
内存管理器有问题吗？有人能解释一下吗？
浏览 0提问于2015-06-22得票数 2
回答已采纳
2回答
我有一个代码段，它生成一个动态的3D随机数组，并将其分配给一个内存块。我想我是正确的，但是我如何测试它是否都位于一个连续的内存块中呢？有什么办法吗？我有一个cout函数，它将每个元素的地址打印到屏幕上，它似乎是正确的，但我不能确定。我知道我也必须再次释放内存，但那将在稍后到来。
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <ctime>
using namespace std;
int main()
{
int ***dyn_array;
int **
浏览 0提问于2012-04-04得票数 0
回答已采纳
1回答
我有一个二维数组。第一个维度有固定的大小，我动态地创建第二个维度。e.g
int **arr;
*arr=( int * ) malloc ( X * sizeof ( int )) // X is input from user
我想做的是创建第二个维度，并在它的末尾写入值。
例如，我使用以下命令为arr创建第二维
arr[0]=( int * ) malloc ( 2 * sizeof ( int ))
然后我想在这个第二维中写入值，但不知道索引。许多编程语言都有array.push方法，该方法在不知道数组的索引或长度的情况下将项推入数组的末尾。我如何在C中实现这样的结果？
浏览 0提问于2015-12-02得票数 0
1回答
在mpir中创建大型数组
、、、
对于mpir中的小数组和浮点数，我没有收到错误消息，但是当我想要创建一个非常大的数组时。假设>100,000,000，我得到以下错误消息：
GNU :无法分配内存(size=16)按任意键继续。。。
不幸的是，我需要2个大的数组。一个是100,010,000号，另一个是1,000,100号。这在windows 64位机器上是可能的吗？
有没有一种方法可以从内存中清除部分数组，而不是整个数组(在MPIR上)来创建空间？
浏览 0提问于2013-03-28得票数 0
回答已采纳
可能是重复，因为有很多关于这个话题的问题，但我找不到我想要的东西。
我知道String是不变的，StringBuilder是可变的。我理解这两个术语的本质。当我创建StringBuilder实例时，我想知道内存中到底发生了什么。比如：
StringBuilder s = new StringBuilder();
内存中为s预留了多少空间？
我可以像使用s[0] = 'a';一样使用它，所以我们可以调用数组吗？
如果s是基于索引的，那么这是否意味着字符存储在连续位置的内存中？
如果对3的回答是肯定的。那么，如果我们使用s.Append("abc")
浏览 3提问于2016-05-12得票数 6
回答已采纳
我正在实现一种基于概率潜在语义索引的算法，本文采用的是，它需要一个四维数组，名为p_z_d_wt_wv，z是主题，d是文档，wt是文本字，wv是可视词，每个维度的个数约为12,7000,100,500，并且该数组是一个双数组，因此需要32G内存！我像下面这样分配这个内存，它只是为了演示，因为每个文档中wt和wv的数量是不同的。
p_z_d_wt_wv = new double[12][7000][][];
for( int t = 0; t < 12; ++t)
{
for( int d = 0; d < 7000; ++d )
{
p_z
浏览 4提问于2013-07-11得票数 1
2回答
函数参数分配？
、、、
char* foo(char* str)
{
return str;
}
int main()
{
printf("%s", foo(malloc(10)));
return 1;
}
我只是想知道这是否是一项适当的声明。输出是否为空字符串？
真的分配了吗？
作用域是否已扩展并保存到动态内存区域？
它会导致任何u/b或只是崩溃吗？
在我的测试充电器(佩列斯C)上，它崩溃了。
浏览 3提问于2014-06-30得票数 0
回答已采纳
3回答
异常的初始化故障
、、
全
我正在编写一个非常简单的动态二维数组声明的C代码，并用memset对其进行初始化，然后打印值。我的代码如下：
float **env;
int i,j,num;
printf("Enter a number : \n");
scanf("%d",&num);
env = (float **)malloc(num*sizeof(float *));
for(i=0;i<num;i++)
{env[i] = (float *)malloc(num*sizeof(float));}
memset(env, 0, sizeof(float)*n
浏览 0提问于2012-11-04得票数 0
回答已采纳
3回答
我想用C制作二维数组。
例如，我创建了一个名为place的int类型变量，如下所示：
int *place;
我有一个游戏，它有像行和列这样的变量。我希望place变量是一个二维数组，动态分配其行和列(用于数组的最大大小)，在“普通”声明中如下所示：
place[rows][columns];
但我不知道如何处理动态分配。
对于一维数组，我会这样做：
place = (int*) malloc (levels * sizeof(int));
但我不知道如何用二维数组来完成这个任务。
编辑：
我怎么才能重写这个字符而不是int呢？
我尝试过用字符覆盖it，但它不起作用。
浏览 7提问于2012-12-01得票数 4
2回答
在C#中，当使用值类型数组或引用类型数组时，数据将更加密集地打包在一起吗？
我的推理是，一个结构数组将所有数据放在一起，现在，虽然引用类型(所有引用都在一起)也是一样的，但是它们可以指向整个地方。
(我意识到，只要有可能，就鼓励使用C#的集合接口，而且可读的代码胜过过早的优化，但我只是好奇它是如何工作的。)
浏览 3提问于2014-10-30得票数 1
回答已采纳
5回答
用于实现堆栈的链表与动态数组
、、、、
在我的最后一年开始之前，我已经开始复习数据结构和算法，以确保我掌握了所有的东西。一个复习问题是“使用链表或动态数组实现一个堆栈，并解释为什么你做出了最佳选择”。
对我来说，使用带有尾指针的列表来实现堆栈似乎更直观，因为它可能需要经常调整大小。似乎对于大量数据，列表是更好的选择，因为动态调整数组大小是一项代价高昂的操作。此外，使用列表，您不需要分配比实际需要更多的空间，因此它的空间效率更高。
然而，动态数组绝对允许更快地添加数据(除非需要调整大小)。但是，我不确定是使用数组整体更快，还是只在不需要调整大小的情况下。
这本书的解决方案说“对于存储非常大的对象，列表是更好的实现”，但我不明白为什么。
浏览 2提问于2011-09-14得票数 30
我被告知，一般来说，在链表中添加和删除往往更好，因为内存永远不需要移动来容纳新元素。我不确定这是否真的适用于何时添加/删除可以位于列表中的任何位置。
如果我是正确的，链表将这样操作；它将在O(n)时间内找到需要添加/删除的节点的位置，然后在O(1)中添加/删除节点，总时间为O(n)。
在一个数组中，由于随机存取存储器，它会在O(1)时间内找到需要添加/删除的节点的位置，然后在O(n)时间内添加/删除该节点，因为可能需要移动该数组中的所有数据(假设删除意味着将它后面的所有节点移回1)。从而给出了O(n)的总运算时间
从这一点来看，这两种方法似乎都没有明显的优势。如果我看一下平均情况，链表平均需要
浏览 0提问于2019-06-02得票数 1
动态2D数组基本上是指向数组的指针数组。
哦，天哪，这完全是垃圾，这是完全错误的。这不是二维数组。“动态2D数组基本上是指向数组的指针数组。”- NOOOO，FFS！T (*ptr)M =新TN；是正确的解决方案…任何数量的数组指针都不可能与数组的指针相同。
new int*[rowCount];。
，星星表示什么？
二维数组是指向数组的指针数组吗？
浏览 8提问于2017-04-14得票数 1
回答已采纳
2回答
我理解Ruby数组是动态分配和动态调整大小的；但是，我似乎找不到任何关于它们是否是真正数组的明确信息；也就是说，它们在内存中是连续的(更具体地说，它们持有的引用在内存中是连续的)。
我的假设是，如果需要增加Ruby数组的大小，就需要将整个数组重新分配到更大的连续内存块中。
这是正确的，还是“数组”在这种情况下用词不当？
浏览 1提问于2014-02-27得票数 10
回答已采纳
我写了一段代码来擦除向量中的一个元素，但是在使用for循环中的迭代器进行擦除之后，我的程序崩溃了。即使通过迭代器在向量中插入一个元素也会产生相同的结果。以下是代码片段：
vector<int>v1;
v1.reserve(8);
v1.push_back(10);
v1.push_back(8);
v1.push_back(12);
v1.push_back(3);
v1.push_back(7);
v1.push_back(5);
v1.push_back(17);
v1.push_back(1);
int x=6;
std::vector<int>::iterato
浏览 0提问于2016-09-11得票数 0
2回答
最近，我参加了一次面试，要求我为一个问题选择两种数据结构，现在我的问题是：
如果唯一需要的操作是Stack和pop，那么在array上使用push的理由是什么？array为追加和弹出它的最后一个元素提供了固定的时间，与使用LinkedList实现Stack相比，它通常占用更少的内存。如果需要，它还提供随机访问。唯一的理由是因为一个array通常是固定大小的，所以我们需要动态地调整我们输入的每个元素的数组大小？这仍然是一个固定的时间，不是吗，除非处罚是不相称的？
浏览 2提问于2016-01-30得票数 0
回答已采纳
3回答
矢量中的动态内存分配
、、、
我对向量中的内存分配(STL- C++)有疑问.据我所知，每次向量的大小等于它的容量时，它的容量就会动态翻倍。如果是这样的话，为何分配是连续的？它如何仍然允许像数组一样为O(1)访问使用[] access运算符？有人能解释一下这种行为吗？(List也有动态内存分配，但我们不能使用[] access运算符访问它的元素，如何仍然可以使用向量？)
#include<iostream>
#include<vector>
using namespace std;
int main() {
// your code goes here
vector<int&
浏览 5提问于2017-06-13得票数 2
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
