Can a linkedlist store different data types?

Question

My question is very general. I just started studying data structures and I came by linked-lists. I understood they are a sequence of nodes. Each node can store some data and it knows the next node in the list.

So one node has an object O and a pointer to the next object called object B which in turn has another pointer .. until we get to the node which has a pointer to null.

But say I am storing integers in a node in a Linked-list that is pointing to another node holding a string. First, is it allowable? And second, how would this be ever useful?

Also, what are the most common operations done on a linkedlist? getSize(), remove(), insert(), getElement(), concatenate()

If I were to store a million mobile number, would it be efficient to use a linkedlist? If not, where would the optimal use of a linkedlist appear?

Since a LinkedList is stored randomly in memory(using pointers from one node to another) not like an array adjacent, would this make it harder in NON- auto garbage collection languages like C++/C in terms of memory allocation and free-ing?

Answer 1

But say I am storing integers in a node in a Linked-list that is pointing to another node holding a string. First, is it allowable? And second, how would this be ever useful?

Yes, it's allowed as long as the list is declared as List<Object> or List<Serializable>, which both String and Integer extend/implement.

In this particular case, it wouldn't be very useful. But consider a List<Vehicle>. It could store instances of Car, Bike, Truck or any other kind of Vehicle.

what are the most common operations done on a linkedlist?

Those that are documented in the javadoc. I would say that adding and iterating are probably the most common. But I haven't make any statistical measurement.

If I were to store a million mobile number, would it be efficient to use a linkedlist?

It depends on the operation you need to do on the list. If you just need to add at the beginning or the end, it will be O(1). Iterating is not a problem. Finding the index of a phone would be O(n). Accessing at a given index in the list would also be O(n).

In general, an ArrayList is much faster than a LinkedList for almost every use-case. The only use-case where a LinkedList is faster is when it always inserts at the biginning, or when it removes/inserts elements while iterating using its Iterator.

would this make it harder in NON- auto garbage collection languages like C++/C in terms of memory allocation and free-ing?

I'm not experiences enough in those languages to answer, but yes, since you have to manage the memory, it's harder.