More in depth references: – Essential C: An introduction. • rd. edu// – Programming in C (4th Edition). The original document is available at The Essential C document was last updated in , which is one reason why this. The original document is available at The Essential C document was last updated in , which is the main reason this text.

Author: Fenrikree Zulunris
Country: Armenia
Language: English (Spanish)
Genre: Literature
Published (Last): 14 August 2014
Pages: 165
PDF File Size: 7.45 Mb
ePub File Size: 18.78 Mb
ISBN: 231-4-79210-196-8
Downloads: 10418
Price: Free* [*Free Regsitration Required]
Uploader: Nikinos

The material is useful if you want to understand linked lists or if you want to see a realistic, applied example of pointer-intensive code. A separate document, Linked List Problems presents 18 practice problems covering a wide range of difficulty.

Linked lists are useful to study for two reasons. Most obviously, linked lists are a data structure which you may want to use in real programs.

Seeing the strengths and weaknesses of linked lists will give you an appreciation of the some of the time, space, and code issues which are useful to thinking about any data structures in general. Somewhat less obviously, linked lists are great way to learn about pointers. In fact, you may never use a linked list in a real calibrary, but you are certain to use lots yttp pointers.

Linked list problems are a nice combination of algorithms and pointer manipulation. Traditionally, linked lists have been the domain where beginning programmers get the practice to really understand pointers. Audience The article assumes a basic understanding of programming and pointers. Ewsentialc article uses C syntax for its examples where necessary, but the explanations avoid C specifics as much as possible really the discussion is oriented towards the important concepts of pointer manipulation and linked stanforc algorithms.

Other Resources Link List Problems Lots of linked list problems, with explanations, answers, and drawings. The “problems” article is a companion to this “explanation” article. Pointers and Memory Explains all about how pointers and memory work. You need some understanding of pointers and memory before you can understand linked lists.

Stanford CS Ed Library

Essential C features of the C programming language. This and other free educational materials are available at This document is free to be used, reproduced, or sold so long as this notice is clearly reproduced at its beginning. Init got split into two documents: This edition represents minor edits on the edition. Dedication This document is distributed for free for the benefit and education of all. That a person seeking knowledge should have the opportunity to find it.

Thanks to Stanford and my boss Eric Roberts for calibrary me in this project. Linked lists and arrays are similar since they both store collections of data. The terminology is that arrays clibrary linked lists store “elements” on behalf of esesntialc code. The specific type of element is not important since essentially the same structure works to store elements of any type.

One way to think about linked lists is to look at how arrays work and think about alternate approaches. Array Review Arrays are probably the most common data structure used to store collections of elements.

In most languages, eud are convenient to declare and the provide the handy [ ] syntax to access any element by its index number. The following example shows some typical array code and a drawing of how the array might look in memory. The code allocates an array int scores[], sets the first three elements set to contain the numbers 1, 2, 3 and leaves the rest of the array uninitialized The key point is that the entire array is allocated as one block of memory.


Uttp element in the array gets its own space in the array. Any element can be accessed directly using the [ ] syntax. Extra for experts Array access with expressions such as scores[i] is almost always implemented using fast address arithmetic: The stanfod of arrays are Most often this size is specified at compile time with a simple declaration such as in the example above.

With a little extra effort, the size of the array can be deferred until the array is created at runtime, but after that it remains fixed. Although convenient, this strategy has two disadvantages: A surprising amount of commercial stabford has this sort of naive array allocation which wastes space most of the time and crashes for special occasions.

Extra for experts For relatively large arrays larger than 8k bytesthe virtual memory atanford may partially compensate for this problem, since the “wasted” elements are never touched.

Linked lists have their own strengths and weaknesses, but they happen to be strong where arrays are weak. The array’s features all follow from its strategy of allocating the memory for all its elements in one block of memory. Linked lists use an entirely different strategy. As we will see, linked lists allocate memory for each element separately and only when necessary.

Pointer Refresher Here is a quick review of the terminology and rules for pointers. The linked list code to follow will depend on these rules. For much more detailed coverage of pointers and memory, see Pointers and Memory. Alternately, a pointer may be set to the value NULL which encodes that it does not currently refer to a pointee.

Dereference The dereference operation on a pointer accesses its pointee. A pointer may only be dereferenced after it has been set to refer to a specific pointee.

A pointer which does not have a pointee is “bad” below and should not be dereferenced. Bad Pointer A pointer which does not have an assigned a pointee is “bad” and should not be dereferenced.

That sort of random bug is difficult to track down. Correct code sets each pointer to have a good value before using it. Accidentally using a pointer when it is bad is the most common bug in pointer code. In Java and other runtime oriented languages, pointers automatically start out with the NULL value, so dereferencing one is detected immediately. Java programs are much easier to debug for this reason.

Reference (All Levels)

It does not copy the pointee memory. After the assignment both pointers will point to the same pointee memory which is known as a “sharing” situation. The prototype for malloc and other heap functions are in stdlib. The argument to malloc is the integer size of the block in bytes. Unlike local “stack” variables, heap memory is not automatically deallocated when the creating function exits.

Most modern programming systems will throw an exception or do some other automatic error handling in their memory allocator, so it is becoming less common that source code needs to explicitly check for allocation failures. Call free on a block of heap memory to indicate to the system that you are done with it. The argument to free is a pointer to a block of memory in the heap a pointer which some time earlier was obtained via a call to malloc. What Linked Lists Look Like An array allocates memory for all its elements lumped together as one block of memory.

In contrast, a linked list allocates space for each element separately in its own block of memory called a “linked list element” or “node”. The list gets is overall structure by using pointers to connect all its nodes together like the links in a chain.


Each node contains two fields: Each node is allocated in the heap with a call to mallocso the node memory continues to exist until it is explicitly deallocated with a call to free. The front of the list is a.

Here is what a list containing the numbers 1, 2, and 3 might look like The nodes are all allocated in the heap A head pointer local to BuildOneTwoThree keeps the whole list by storing a pointer to the first node.

Each node stores one data element int in this example. Each node stores one next pointer. The next field of the last node is NULL. This drawing shows the list built in memory by the function BuildOneTwoThree the full source code for this function is below. The beginning of the linked list is stored in a “head” pointer which points to the first node. The first node contains a pointer to the second node.

The second node contains a pointer to the third node, The last node in the list has its. Code can access any node in the list by starting at the head and following the. Operations towards the front of the list are fast while operations which access node farther down the list take longer the further they are from the front.

This “linear” cost to access a node is fundamentally more costly then the constant time [ ] access provided by arrays. In this respect, linked lists are definitely less efficient than arrays.

Stanford CS Education Library

Drawings such as above are important for thinking about pointer code, so most of the examples in this article will associate code with its memory drawing to emphasize the habit. In this case the head pointer is an ordinary local pointer variable, so it is drawn separately on the left to show that it is in the stack.

The list nodes are drawn on the right to show that they are allocated in the heap.

The Empty List NULL The above is a list pointed to by head is described as being of “length three” since it is made of three nodes with the. There needs to be some representation of the empty list the list with zero nodes.

The most common representation htgp for the empty list is a NULL head pointer. The empty list case is the one common weird “boundary case” for linked list code. All of the code presented in this article works correctly for the empty list case, stangord that was not without some 011.

When working on linked list code, it’s a good habit to remember to check the empty list case to verify that it works too. Sometimes the empty list case works the same as all the cases, but sometimes it requires some special case code.

No matter what, it’s a good cslibeary to at least think about. Node and Pointer Before writing the code to build the above list, we need two data types Node The type for the nodes which will make up the body of the list. These are allocated in the heap.