Any point in using linked lists?

Except than being too lazy to use arrays? The amount of cache misses you are going to get overweights the other benefits.

Infrequent appending/removing, and/or random insertion with large objects (that didn't come out right...)

>>4
Yes.
struct Node {
int val;
int left;
int right;
} nodes[10];

>>5

Infrequent appending/removing

You mean frequent and in the middle or start.
Or else there is no use in linked lists.

And use size_t next time.

>>5

Yes.

here is a better one more fitting into the array spirit
struct Node
{
int val;
bool hasLeft, hasRight;
};

>>5
Now implement a self-balancing binary tree.

>>1
Cache misses are only a problem in garbage like C, where individual nodes stay their arbitrarily allocated location and don't dynamically congregate alongside their linked neighbors across GC passes.

The advantages of linked lists outweigh the extra cache pressure. If the list is small, it's negligible. If the list is large, it'll be optimized [if it doesn't already retain certain tail-sharing advantages of its listness].

>>8
Are you stupid? Of course you are.

>>5-chan's approach basically consists of using an array-backed allocator. Implementing a self-balancing binary tree would look exactly like it is with using genuine linked lists, only using her custom malloc/free-lookalikes that initialize and return a reference to a new array element or add it to the free list (that >>5-chan forgot to mention).

>>8, how do you find the index of the right subnode without iterating over the entire left subtree first?

>>10

her

lmao

>>9

Which advantages are those?

>>10
Are you intelligent? Of course you are.

>>9
Nice theoretical bullshitte

>>9
Google "advanced memory management|allocation for game engines". Don't blame C for your laziness and stupidity.

>>15

C
laziness

U MENA HASKAL

>>9-san is Haskal!!!1

>>9

congregate alongside their linked neighbors across GC passes.

Huh. That's an interesting point.

>>9 >>18
And the most copying GC does this fairly well. It's one of the most underrated and elegant algorithms, I think.