Changes

Jump to: navigation, search

Linked List

4,727 bytes added, 05:55, 4 December 2009
no edit summary
This page is aimed at giving a conceptual overview of the uses and design elements of a linked list. Linked lists are flexible and powerful and can prove to be very useful tools in the arsenal of a UI designer or implementer. Therefore, having a linked list handy would make most hackers' lives a whole lot better :)<br/><br/>
With that being said, '''read on!'''
== DESIGN: What is a "linked List"? ==
 
https://cs.senecac.on.ca/~btp300/pages/content/linkl.html (On Stacks and Queues and a General Linked List)
 
 
http://en.wikipedia.org/wiki/Linked_list (A more in depth definition)
 
[http://www.ljubomirgorscak.com/recordings/fardad_linked_list_intro.mp3] (Intro to linked lists)
== ADVANTAGES: So, what's so good about a linked list? ==
Linked Lists are large sprawling entities and can be extremely useful.=== Non-incomplete-Sequential Element Map ===Linked Lists are like arrays except that where the elements of an array are laid out in sequential order in memory, the elements of a Linked List are all over the place with one element pointing to the next. This design is more flexible in that it allows the list to dynamically grow over time as opposed to being locked into a certain number of elements since the time of initialization.=== Dynamic Insertion ===Linked Lists also handle insertion at the midpoint much more gracefully and efficiently than an array. In order for an array to insert an element at the middle of it, it has to shift every subsequent element down the line by one. But what if the array is full? Then even worse, a whole new bigger array must be allocated! The exact sequence goes something like this:# The first part of the old array must be copied into the new bigger array.# Then the element to be inserted must be added to the current tail of the bigger array.# Then finally, the second part of the old array must be added to the bigger array.<br/>This is a very taxing process. With a linked list on the other hand, a node containing the data (or a reference to it) must be created then the two nodes that surround the required position must set their <code>next</code> and <code>previous</code> references to it, respectively. That's all! There is much less processing and much less brute force. However, this process entails considerable amounts of thought and overhead as we will see soon. 
== DISADVANTAGES: Well there has to be a downside! ==
-incomplete-Most of a linked list's disadvantages consist of speed issues.== DESIGN: What = Seek By Traversal ===As opposed to a sequential array, linked lists cannot be randomly accessed. In computer science, we say that a linked list has access time O(n) where n is the number of elements in the array. This means that in the worst case, every single element of a "linked List"? list must be accessed before the desired index is reached. Compare this with the constant access time of a sequential array. In computer science, we say that an array has access time O(1); this means that regardless of which index you desire, the access time for it will ''always'' be the same. The reason for this is that arrays are laid out sequentially in memory which allows computers to access any one of their elements nearly instantaneously. The reason for this is that modern computers are built with the ability to read any given memory address at the exact same speed as reading any other memory address; we call this type of memory Random Access Memory.=== Overhead ===-incomplete-As well, linked lists can be a headache to implement (although very simple implementations can take no time at all!). As opposed to an array which is very simple to work with (trivial access, trivial assignment, trivial allocation, etc...), linked lists require a lot of processor overhead. This is mainly due to the fact that linked lists must be dynamically allocated piecemeal (ie one element at a time) and the fact that dynamic memory allocation itself isn't very fast. On top of that, every single action that a linked list can perform must be programmed. Linked lists are absolutely not trivial/native which is why they are '''always''' slower than sequential arrays when it comes to access, search, initialization/destruction, etc. 
== ELEMENTS: Nodes are everything! ==
-incomplete-
-incomplete-
== FLEXIBILITY: Data Types ==
=== Custom Functionality ===Linked lists tend to be very flexible. Due to the fact that they are written by hand, all kinds of functionality can be added to them. Things such as:* Automatic allocation/de-incompleteallocation of objects* Custom linking structures* Custom index operators* Unique search algorithms* Automatic update of external code* Automatic logging/reporting* Future extensibility* Etc, etc, etc... === Data Type Hiding ===Since the implementation of a linked list is custom, the programmer may very well implement the list in any way that they may see fit. This effectively hides the data being stored from the watchful eyes of the calling program. As well, the actual location of the data is effectively random (as opposed to being sequential) which means that the data is that much harder to find. This adds a simple layer of security that arrays simply do not afford. == AUTHOR: Word From The Author ==Thanks for reading my page, now go and write yourself up a neat little linked list (well... page isn't quite complete enough for that just yet >.>) :)<br/><br/>-this message brought to you by: '''northWind87'''
1
edit

Navigation menu