chapter_array_and_linkedlist/list/

[giscus[bot]]

chapter_array_and_linkedlist/list/

Your first book to learn Data Structure And Algorithm.

https://www.hello-algo.com/chapter_array_and_linkedlist/list/

[qualifier1024]

仿照大佬Java写了个c++本地运行没啥问题，不会上传

[krahets]

谢谢你的代码！可否请你根据 一起参与创作 中的教程步骤来提交代码？还是蛮简单的～ Git 工具比较常用，花一些时间学习的话还是很值得哒

[Blackcat308]

介绍数组缺点一项，在数组中插入或删除元素效率低下课题下，丢失元素或是否是语病？

[krahets]

谢谢您的指正，将改为 丢失元素： 由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会被丢失。
（对于笔误，您也可以直接点击页面右上角的 铅笔 图标直接修改，谢谢哇～）

[mao888]

线性表的顺序存储，就是您这章所讲的列表吗？

[krahets]

哈喽，本章中的数组和列表，都属于线性表的顺序存储

[yuelinxin]

在列表末尾添加元素是不是也不严格为O(1)，比如某些情况下列表正好需要先扩容再添加，这时候时间复杂度就会是O(N)。请问Python中的list是否也会存在这种问题？

[krahets]

是的，遇到需要扩容时，系统会申请一块新的内存，并将原列表的所有元素搬运过去，此时会很慢。Python 也一样，应该没有语言能避开这个问题。

[ZZhenF]

如果创建多线程，并发的情况下，对同一个List操作，它怎么判断size的执行顺序

[yuelinxin]

多线程操作同一块内存应该是需要线程锁的，为了避免线程冲突，正常情况下所有对这个list的增删查改操作都需要在当前线程获取到了对这个list的控制权的情况下进行，因为size函数是对list的一个读取操作，所以执行size函数的顺序应该就是取决于哪个线程先获取到控制权，就先执行哪个线程中的size，也就是first come first serve（先到先得）了。

[zjy-coder]

这里只牵扯算法。多线程就别说了...

[is-liu]

如果需要线程安全的话在Java中是可以通过集合类包装一下
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
这样下面的就是一个线程安全的列表，至于其他语言就不大清楚了
List<Integer> syncList = Collections.synchronizedList(list);

[Gonglja]

cpp 中，vector 成员函数 size 的返回值类型为 size_type
在实际实践中，大多数 size_type 被转为 unsigned type，std::size_t unsigned int 或者 std::size_t unsigned long，祥见c-vector-size-types

vector<int> list = { 1, 3, 2, 5, 4 };
...
int count = 0;
- for (int i = 0; i < list.size(); i++) {
+ for (size_t i = 0; i < list.size(); i++) 
    count++;
}

[Gonglja]

还有其它地方使用 vector、unordered_map 的地方，类型都是 size_type，
vector size
unordered_map size

size_type 通常被定义为 std::size_t

[krahets]

确实，不过用 int 问题也不大，做题时比较方便

[PhiFever]

在最后的my_list.cpp中的 void extendCapacity() 方法似乎没有考虑整型溢出的风险（int newCapacity = capacity() * extendRatio;），由于extendRatio和numsCapacity都是int型，我认为这个风险还是蛮大的。或者说在这部分针对初学者的内容中暂时不用考虑这么细致？

[krahets]

确实！由于是简易实现，考虑到简洁性，没有考虑到那么细致～暂且假定本实现中列表最长仅支持 int 最大值。

[Teamsaa]

大佬，C语言版本的动态数组没有嘛，我记得C primer plus 有讲

[krahets]

Hi 抱歉暂时没有 C 代码，仍在开发中

[pasionfru]

大佬牛逼，这对新手很友好

[ThreeAurora]

这行太棒了，直接补充了我几个知识点~
List list1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));

[ThreeAurora]

我打错了，是
List<Integer> list1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 }));
这行好像可以移除显示数组创建
List<Integer> list1 = new ArrayList<>(Arrays.asList(6, 8, 7, 10, 9));

[highlineee]

写得好好啊！看了一堆课都不如大佬清清爽爽的梳理，但知识点又很全面了~新手老手都友好！

[lavamooncake-816]

不好意思我想请问一下，在列表类实现中，“# 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组”是否应该为“新建一个长度为 self.__nums 的数组“？

[krahets]

不是的，新数组的长度是 self.capacity() * (self.__extend_ratio - 1) ，为原数组的 self.__extend_ratio 倍

[jiangyigithub]

/* 列表扩容 */
void extendCapacity() {
    // 新建一个长度为原数组 extendRatio 倍的新数组
    int newCapacity = capacity() * extendRatio;
    int *tmp = nums;
    nums = new int[newCapacity];
    // 将原数组中的所有元素复制到新数组
    for (int i = 0; i < size(); i++) {
        nums[i] = tmp[i];
    }
    // 释放内存
    delete[] tmp;
    numsCapacity = newCapacity;
}

could you give me some explanation about the "new" and "delete[]" operator? why we double "new" int[] for nums,why need delete[] tmp?

the below is comment by CHATGPT:
"
However, there is a potential issue with this code. Since tmp is assigned the address of the original nums array, deleting tmp will free the memory associated with that array. But after that, nums will still point to the new array, leaving the original nums array undeleted and causing a memory leak.

To fix this, you can simply remove the line delete[] tmp;, as it is unnecessary and could lead to issues if you intend to continue using the nums array.
"

[krahets]

The delete[] tmp is for releasing the memory of the original array. The overall process is as follows:

1. Creating a new array with a bigger capacity.
2. Move the elements from the original array to the new array.
3. Release the memory of the original array to avoid memory leaks.

[yzWHS]

/* 中间插入元素 */
    void insert(int index, int num) {
        if (index < 0 || index >= size())
            throw out_of_range("索引越界");
        // 元素数量超出容量时，触发扩容机制
        if (size() == capacity())
            extendCapacity();
        // 索引 i 以及之后的元素都向后移动一位
        for (int j = size() - 1; j >= index; j--) {
            nums[j + 1] = nums[j];
        }
        nums[index] = num;
        // 更新元素数量
        numsSize++;
    }

里面的注释，索引i应该是j。

[krahets]

这里不是 j 哈，原文的 i 指的是 index

[qualifier1314]

看评论就学到了很多

[hpfish]

func (l *myList) remove(index int) int {
    if index < 0 || index >= l.arrSize {
        panic("索引越界")
    }
    num := l.arr[index]
    // 将索引 index 之后的元素都向前移动一位
    for j := index; j < l.arrSize - 1; j++ {
        l.arr[j] = l.arr[j+1]
    }
    // 更新元素数量
    l.arrSize--
    // 返回被删除的元素
    return num
}

这样删不掉最后一个元素吧？

[AmbitiousJun]

l.arrSize 更新了就代表删掉了吧

[a2635814919]

@hpfish 我们是通过arrSize来访问列表中的元素的，所以虽然最后一个元素没有在物理上删除，但是arrSize的更新使得之前的最后一个元素变得不合法了，从而在逻辑上把最后一个元素删除了

[Alan-Luo-maker]

为什么我在vscode中使用vector<int> nums = { 1, 3, 2, 5, 4 };终端会闪退啊
把这个删掉就立马好了

[BrianChen666]

void delMyList(MyList *nums){
     free(nums->arr);
     free(nums);
}

中free(nums->arr)不是包含在free(nums)中吗？只用后者可以吗？

[krahets]

不可以，free(nums)只会释放结构体nums的内存。如果你不先调用free(nums->arr)来释放数组的内存，那么一旦你释放了结构体本身的内存，你将失去对那部分动态分配数组内存的引用，导致内存泄露。

[Mike23v3]

// C 未提供内置动态数组
这是什么情况

[errorMan0125]

C语言的数组大小是编译时固定长度的，而不是“动态”的

[WalkerInAI]

你好，这句话：
“链表天然可以看作一个列表，其支持元素增删查改操作，并且可以灵活动态扩容。”
会让我感到有歧义，我认为如果链表可以看作是列表，那么链表应可以实现列表的功能。但是在2, 3, 4小点中让我觉得链表并不能实现列表的功能，比如二者访问元素的时间复杂度不一样。
请问是我没有正确理解这句话的含义吗？我的思路错在哪儿？

[Autumn00air]

我的理解是：
链表可以访问元素吗？可以
链表可以增删改查元素吗？可以
最重要的是，链表支持动态扩容。
这些都是列表的功能，也都实现了，你说的访问元素的时间复杂度不一样，但是你要注意的是列表是一种抽象的数据结构概念，它只是定义了有序存储，并且支持增删改查，并没有规定具体实现，更加没有规定时间复杂度，列表不是数组。
数组和链表只是具体的实现结构罢了。
我不知道你是什么语言的，但我看js，作者这里写了用数组来实现列表的过程，实际上，还有一种用链表来实现列表的写法，只是他没写而已。
所以作者说”列表可以基于链表或数组实现。“
（个人理解，欢迎指正~）

[krahets]

Hi，“可以实现”和“高效实现”是两个层面上的概念。从“可以实现”的角度看，数组和链表都可以用来实现列表；从效率上看，数组和链表实现的列表的“增删查改”的效率是不同的，呈现互补的特点。

[WalkerInAI]

感谢回复。
抱歉我没有交代清楚这边的情况，我正在学习的编程语言是Python，现阶段水平刚过新手村（刚学完《Python编程：从入门到实践第2版》），刚刚接触GitHub。
我是否应该这样理解，因为链表都具备列表对应的功能，例如有序存储，可访问元素，可增删差改元素，因此链表 可以实现 列表这类数据结构。（如果我理解正确，请无需回复我；如果我的理解还是存在问题，恳请再次回复）

[niaidaye]

链表也能实现列表的功能，对于2、3、4点，底层使用数组，还是链表来实现，他们都有各自的优势，我是学Java的，不太清楚Pyhon是怎么来实现，列表的，感觉也跟Java一样吧，可以有，链表和数组两种实现方式，使用数组来实现，随机访问的效率以及空间上都有优势，链表来说，就不会存在初始化空间不够用，触发扩容机制，理论上，可以做无界列表，一点点，小小的心得，🤣

[estarpro1022]

Java列表的实现中，是不是没有做缩容的操作(doge

[krahets]

没有做。实际上，Java 的 ArrayList 也不会自动缩容，但可以通过调用 ArrayList 的 trimToSize() 方法来实现缩容

[ruomu007]

c++ sort函数的区间是左闭右开的， sort(nums.begin(), nums.end()) ， nums.end()指向的最后一个元素外的一个地址，所以是对nums的所有元素排序。 但是 sort(nums.begin(), nums.begin()+8)，因为左闭右开，取不到第8个元素，应该只是对前7个元素排序吧，可是运行的结果是对前8个元素排序了。 请问如何理解这个左闭右开

[errorMan0125]

nums.begin() + 8 这个是&nums[0]偏移了8个元素了也就是&nums[8]，可以打印下nums.end()跟nums.begin() + 8对比下？

[ruomu007]

sort(nums.begin(), nums.begin()+8) 能取到8个。 但是sort(nums.begin(), nums.end()) 只是取到了最一个元素，但实际上 nums.end()表示的是 最有一个元素外的元素。 这样 就不一致了， 照理说sort(nums.begin(), nums.end()) 应能取到最后一个元素外的一个元素，但是实际没有。

[errorMan0125]

但实际上 nums.end() 表示的是 最右一个元素外的元素
照理说sort(nums.begin(), nums.end()) 应能取到最后一个元素外的一个元素 但是实际没有

我这里的nums.end()是可以取到 数组最后一个元素再偏移一位的，这边是拿官方的代码改了下

[linzha0]

十分感谢！我在手动敲打每行代码学习。好像发现一个无关紧要的小问题，my_list.cpp, line159,这个注释里，好像应该是在 i = 4会导致容量超出。

[linzha0]

list nums = [1, 3, 2, 5, 4]
capacity = 10 ，size = 5
at index 3 insert 6 , get nums = [1, 3, 2, 6, 5, 4]
remove at index=3 element, get nums = [1, 3, 2, 5, 4]
index=1, size: 5access index = 1 element, get num = 3
update element at index = 1 to 0, get nums = [1, 0, 2, 5, 4]
extened list nums = [1, 0, 2, 5, 4, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
capacity = 20 , size = 15

[SEELE0]

大佬好，可否在这里添加 C语言通过malloc 申请分配内存的 方式作为动态数组实现呢

[SEELE0]

抱歉看书不仔细 没看到最后已经提供了

[BobLiu21]

这个章节不是list吗？不是标准库中的std::list吗？这个std::vector，这个中文不是应该翻译成向量，或者动态数组可变数组吗？我一开始看到说list可以实现快速访问，中括号都用上了，我还以为我 std::list一直用错了呢

[lazysnail1024]

List nums = new ArrayList<>(Arrays.asList(numbers));
请问 这里的 new ArrayList<> 有什么意义呢 Arrays.asList 不就是new list 吗

[YHDAO]

ChatGPT的回答：
Arrays.asList(numbers) 确实会返回一个 List，但这个 List 是由 Arrays 内部的一个静态类创建的，实际上是一个固定大小的列表。它并不是一个真正的 ArrayList，而是一个 Arrays 类中的内部类 ArrayList，这个类只提供了对原始数组的一个视图。因此，用 Arrays.asList() 创建的列表无法改变大小（例如，不能添加或删除元素），只能修改已有元素。

new ArrayList<>(Arrays.asList(numbers)) 的意义在于：

创建一个可变大小的列表： Arrays.asList(numbers) 返回的列表是固定大小的，无法添加或删除元素。通过 new ArrayList<>(...) 将其转换为一个真正的 ArrayList，使得我们可以对这个列表进行添加、删除等操作。

深拷贝： Arrays.asList(numbers) 返回的列表是对原始数组的直接引用，如果对其进行修改，原始数组也会受到影响。而通过 new ArrayList<>(...)，我们创建了一个新的 ArrayList，其中包含了原始列表的元素。这是一个浅拷贝，但对于基本数据类型而言，相当于深拷贝，因此修改新列表不会影响原始数组。

[GuanmingBao]

vector nums = { 1, 3, 2, 5, 4 };
C++还可以这样初始化吗？

[xiaos2021]

https://blog.csdn.net/qq_33944628/article/details/134425676

[Kruogu]

链接我看过了，就没见过这种写法啊，vector vec(size());

[xiaos2021]

此处的 size() 是当前的自定义类 class MyList 的成员函数，跟 std::vector 没关系。

std::vector<Elem> c(n); // 调用元素的默认构造函数生成一个大小为n的vector， 如果Elem 是基础类型，那么每个元素会初始化为随机值，如果是对象，那么调用默认构造函数

[TanZiDong]

请问列表实现中的构造函数newMyList里，malloc前面为什么不用强转类型？

[PlusPEI]

在 C 语言中，malloc 函数的返回类型是 void *，它是一个通用指针类型，可以指向任何类型的数据。由于 void * 可以隐式转换为任何类型的指针，因此你可以直接将其赋值给一个特定类型的指针，而不需要强制类型转换。

在你的代码中，MyList *nums = malloc(sizeof(MyList)); 这行代码，malloc 返回的是 void * 类型，它会被自动转换为 MyList * 类型，因为 nums 已经声明为 MyList * 类型。C 编译器允许这种隐式类型转换，因此在 malloc 语句中不需要强制转换类型。

在 C++ 中，malloc 返回的是 void *，但为了类型安全，通常需要强制类型转换。但是在 C 语言中，这种强制类型转换是可选的，实际上也不推荐使用强制类型转换来处理 malloc 返回值，因为这可能会引入不必要的冗余代码。

总结：在 C 中，malloc 返回 void * 类型，可以直接赋值给任何类型的指针，因此不需要强制类型转换。

[PasserbyLin]

请问列表实现的c++代码那里，最后为什么是将列表转换为 Vector 用于打印 ，而不是和其他语言一样转换为数组打印？

[krahets]

hi 转换为数组或者 vector 都行的～

[Gyj918]

TS实现List中
public toArray(): Array {
let size = this._size;
const arr = new Array(size);
for (let i = 0; i < size; i++) {
arr[i] = this.arr[i];
}
return arr;
}
写成这样会不会更好
public toArray(): Array {
return this.arr.slice(0, this._size);
}