Ok, there is no difference between lists, maps, grids, etc in terms of what can and can't cause a memory leak. If you create multiple data structures, with them all being stored in the same variable, then you will have a leak, i.e.:
Code:
list = ds_list_create(); // Create the first data structure and store it in list
list = ds_list_create(); // Now you've overwritten the pointer to the original data structure with a new one and can no longer access the original list
That will cause a memory leak as you've lost the ability to refer to the original data structure and therefore it will exist until you close down the game, you cannot destroy it anymore. You can also get a memory leak by changing rooms if you are storing the data structure in an instance variable for a non-persistent object, i.e.:
Create Event
If you now change rooms, that list is no longer accessible (as the variable storing it's pointer is getting destroyed, but the list itself does not get destroyed) and you will get a memory leak, as you are unable to destroy the list anymore. Finally, as TheouAegis mentioned, using game_restart or room_restart can create a memory leak if you are not using the Clean Up event to destroy your data structures, i.e.:
Code:
list = ds_list_create();
game_restart();
That will cause a memory leak for the same reasons outlined above in the example above.
It sounds to me like you are creating more lists than are necessary (or forgetting to destroy an old list before you create a duplicate "version" of it). Can you post some code so we can see how you are handling the lists, as it seems clear that you are misunderstanding how data structures themselves work. The only way you can have a memory leak is to create data structures and then neglect to destroy them before you lose access to the pointer OR to be creating multiple data structures unnecessarily. The memory you are "leaking" will NOT increase unless you are creating more data structures. So if you are forgetting to destroy a single list but you only actually create that list once, you will have a memory leak but it very likely will not be noticeable and it will not "grow" in size (i.e. the amount of memory that the program is using up will not increase beyond the original creation of the list). If, however, you are forgetting to destroy a list and also creating that list multiple times (for instance, perhaps you have an alarm that creates a list every 60 steps or something) then the memory leak will grow. A memory leak is simply memory being put aside for a something that you cannot clear. If you only create a single data structure, the memory put aside for that data structure will never grow beyond what you are adding into that data structure, so sometimes I think the term "leak" is confusing.
If you need a list for the entire time you are in a room, that is fine, as long as you remember to add the destroy command to the Clean Up event of the instance you are creating the list in, like so:
Clean Up Event
This will trigger when the instance is destroyed or the room is ended (or the game ends, but clean up of data structures happens automatically on game end). So make sure that the instance that holds the list that you are interested in keeping is around for as long as you need the list to be kept.