链表问题汇总

##Abstract

This document reviews basic linked list code techniques and then works through 18 linked list problems covering a wide range of difficulty. Most obviously, these problems are a way to learn about linked lists. More importantly, these problems are a way to develop your ability with complex pointer algorithms. Even though modern languages and tools have made linked lists pretty unimportant for day-to-day programming, the skills for complex pointer algorithms are very important, and linked lists are an excellent way to develop those skills.

The problems use the C language syntax, so they require a basic understanding of C and its pointer syntax. The emphasis is on the important concepts of pointer manipulation and linked list algorithms rather than the features of the C language. For some of the problems we present multiple solutions, such as iteration vs. recursion, dummy node vs. local reference. The specific problems are,in rough order of difficulty: Count GetNth DeleteList Pop InsertNth SortedInsert InsertSort Append FrontBackSplit RemoveDuplicates MoveNode AlternatingSplit ShuffleMerge SortedMerge SortedIntersect Reverse and RecursiveReverse.

Contents ####Section 1 — Review of basic linked list code techniques ####Section 2 — 18 list problems in increasing order of difficulty ####Section 3 — Solutions to all the problems ####Appendix

#Why Linked Lists Are Great To Study

Linked lists hold a special place in the hearts of many programmers. Linked lists are great to study because…

Nice Domain The linked list structure itself is simple. Many linked list operations such as “reverse a list” or “delete a list” are easy to describe and understand since they build on the simple purpose and structure of the linked list itself.
Complex Algorithm Even though linked lists are simple, the algorithms that operate on them can be as complex and beautiful as you want (See problem #18). It’s easy to find linked list algorithms that are complex, and pointer intensive.
Pointer Intensive Linked list problems are really about pointers. The linked list structure itself is obviously pointer intensive. Furthermore, linked list algorithms often break and re-weave the pointers in a linked list as they go. Linked lists really test your understanding of pointers.
Visualization Visualization is an important skill in programming and design. Ideally, a programmer can visualize the state of memory to help think through the solution. Even the most abstract languages such as Java and Perl have layered, reference based data structures that require visualization. Linked lists have a natural visual structure for practicing this sort of thinking. It’s easy to draw the state of a linked list and use that drawing to think through the code.

Not to appeal to your mercenary side, but for all of the above reasons, linked list problems are often used as interview and exam questions. They are short to state, and have complex, pointer intensive solutions. No one really cares if you can build linked lists, but they do want to see if you have programming agility for complex algorithms and pointer manipulation. Linked lists are the perfect source of such problems.

#Section 1 — Linked List Review

This section is a quick review of the concepts used in these linked list problems. For more detailed coverage, see Link List Basics (http://cslibrary.stanford.edu/103/) where all of this material is explained in much more detail. Linked List Ground Rules

All of the linked list code in this document uses the “classic” singly linked list structure: A single head pointer points to the first node in the list. Each node contains a single .next pointer to the next node. The .next pointer of the last node is NULL. The empty list is represented by a NULL head pointer. All of the nodes are allocated in the heap.

For a few of the problems, the solutions present the temporary “dummy node” variation (see below), but most of the code deals with linked lists in their plain form. In the text, brackets {} are used to describe lists — the list containing the numbers 1, 2, and 3 is written as {1, 2, 3}. The node type used is…

struct node {
int data;
struct node* next;
};

To keep thing ssimple, we will not introduce any intermediate typedefs. All pointers to nodes are declared simply as struct node*. Pointers to pointers to nodes are declared as struct node**. Such pointers to pointers are often called “reference pointers”.

##Basic Utility Functions

In a few places, the text assumes the existence of the following basic utility functions…

int Length(struct node* head);

Returns the number of nodes in the list.

struct node* BuildOneTwoThree();

Allocates and returns the list {1, 2, 3}. Used by some of the example code to build lists to work on.

void Push(struct node** headRef, int newData);

Given an int and a reference to the head pointer (i.e. a struct node** pointer to the head pointer), add a new node at the head of the list with the standard 3-step-link-in: create the new node, set its .next to point to the current head, and finally change the head to point to the new node. (If you are not sure of how this function works, the first few problems may be helpful warm-ups.)

This sample code demonstrates the basic utility functions being used. Their implementations are also given in the appendix at the end of the document.

void BasicsCaller()
{
    struct node* head;
    int len;
    head = BuildOneTwoThree(); // Start with {1, 2, 3}
    Push(&head, 13); // Push 13 on the front, yielding {13, 1, 2, 3}
    Push(&(head->next), 42); //push 42 into the second position yielding {13, 42, 1, 2, 3} 
    len = Length(head); // Computes that the length is 5.
}

#Linked List Code Techniques

The following list presents the most common techniques you may want to use in solving the linked list problems. The first few are basic. The last few are only necessary for the more advanced problems.

##1. Iterate Down a List

A very frequent technique in linked list code is to iterate a pointer over all the nodes in a list. Traditionally, this is written as a while loop. The head pointer is copied into a local variable current which then iterates down the list. Test for the end of the list with current!=NULL. Advance the pointer with current=current->next.

// Return the number of nodes in a list (while-loop version)
int Length(struct node* head) {
int count = 0;
struct node* current = head;
while (current != NULL) {
count++;
current = current->next;
}
return(count);
}

Alternately, some people prefer to write the loop as a for which makes the initialization, test, and pointer advance more centralized, and so harder to omit…

for (current = head; current != NULL; current = current->next) {

##2. Changing a Pointer Using a Reference Pointer

Many list functions need to change the caller’s head pointer. In C++, you can just declare the pointer parameter as an & argument, and the compiler takes care of the details. To do this in the C language, pass a pointer to the head pointer. Such a pointer to a pointer is sometimes called a “reference pointer”. The main steps for this technique are…

Design the function to take a pointer to the head pointer. This is the standard technique in C — pass a pointer to the “value of interest” that needs to be changed. To change a struct node*, pass a struct node**.
Use ‘&’ in the caller to compute and pass a pointer to the value of interest.
Use ‘*’ on the parameter in the callee function to access and change the value of interest.

The following simple function sets a head pointer to NULL by using a reference parameter….

// Change the passed in head pointer to be NULL
// Uses a reference pointer to access the caller's memory
void ChangeToNull(struct node** headRef) {
// Takes a pointer to
// the value of interest
*headRef = NULL;
// use '*' to access the value of interest
}
void ChangeCaller() {
struct node* head1;
struct node* head2;
ChangeToNull(&head1);
// use '&' to compute and pass a pointer to
ChangeToNull(&head2);
// the value of interest
// head1 and head2 are NULL at this point
}

Here is a drawing showing how the headRef pointer in ChangeToNull() points back to the variable in the caller…

Many of the functions in this document use reference pointer parameters. See the use of Push() above and its implementation in the appendix for another example of reference pointers. See problem #8 and its solution for a complete example with drawings. For more detailed explanations, see the resources listed on page 1.

##3. Build — At Head With Push()

The easiest way to build up a list is by adding nodes at its “head end” with Push(). The code is short and it runs fast — lists naturally support operations at their head end. The disadvantage is that the elements will appear in the list in the reverse order that they are added. If you don’t care about order, then the head end is the best.

struct node* AddAtHead() {
struct node* head = NULL;
int i;
for (i=1; i<6; i++) {
Push(&head, i);
}
// head == {5, 4, 3, 2, 1};
return(head);
}

##4. Build — With Tail Pointer

What about adding nodes at the “tail end” of the list? Adding a node at the tail of a list most often involves locating the last node in the list, and then changing its .next field from NULL to point to the new node, such as the tail variable in the following example of adding a “3” node to the end of the list {1, 2}…

This is just a special case of the general rule: to insert or delete a node inside a list, you need a pointer to the node just before that position, so you can change its .next field. Many list problems include the sub-problem of advancing a pointer to the node before the point of insertion or deletion. The one exception is if the operation falls on the first node in the list — in that case the head pointer itself must be changed. The following examples show the various ways code can handle the single head case and all the interior cases…

##5. Build — Special Case + Tail Pointer

Consider the problem of building up the list {1, 2, 3, 4, 5} by appending the nodes to the tail end. The difficulty is that the very first node must be added at the head pointer, but all the other nodes are inserted after the last node using a tail pointer. The simplest way to deal with both cases is to just have two separate cases in the code. Special case code first adds the head node {1}. Then there is a separate loop that uses a tail pointer to add all the other nodes. The tail pointer is kept pointing at the last node, and each new node is added at tail->next. The only “problem” with this solution is that writing separate special case code for the first node is a little unsatisfying. Nonetheless, this approach is a solid one for production code — it is simple and runs fast.

struct node* BuildWithSpecialCase() {
struct node* head = NULL;
struct node* tail;
int i;
// Deal with the head node here, and set the tail pointer
Push(&head, 1);
tail = head;
// Do all the other nodes using 'tail'
for (i=2; i<6; i++) {
Push(&(tail->next), i); // add node at tail->next
tail = tail->next;
// advance tail to point to last node
}
return(head);
// head == {1, 2, 3, 4, 5};
}

##6. Build — Temporary Dummy Node

This is a slightly unusual technique that can be used to shorten the code: Use a temporary dummy node at the head of the list during the computation. The trick is that with the dummy, every node appears to be added after the .next field of some other node. That way the code for the first node is the same as for the other nodes. The tail pointer plays the same role as in the previous example. The difference is that now it also handles the first node as well.

struct node* BuildWithDummyNode() {
struct node dummy;
// Dummy node is temporarily the first node
struct node* tail = &dummy; // Start the tail at the dummy.
// Build the list on dummy.next (aka tail->next)
int i;
dummy.next = NULL;
for (i=1; i<6; i++) {
Push(&(tail->next), i);
tail = tail->next;
}
// The real result list is now in dummy.next
// dummy.next == {1, 2, 3, 4, 5};
return(dummy.next);
}

Some linked list implementations keep the dummy node as a permanent part of the list. For this “permanent dummy” strategy, the empty list is not represented by a NULL pointer. Instead, every list has a heap allocated dummy node at its head. Algorithms skip over the dummy node for all operations. That way the dummy node is always present to provide the above sort of convenience in the code. I prefer the temporary strategy shown here, but it is a little peculiar since the temporary dummy node is allocated in the stack, while all the other nodes are allocated in the heap. For production code, I do not use either type of dummy node. The code should just cope with the head node boundary cases.

##7. Build — Local References

Finally, here is a tricky way to unify all the node cases without using a dummy node at all. For this technique, we use a local “reference pointer” which always points to the last pointer in the list instead of to the last node. All additions to the list are made by following the reference pointer. The reference pointer starts off pointing to the head pointer. Later, it points to the .next field inside the last node in the list. (A detailed explanation follows.)

struct node* BuildWithLocalRef() {
struct node* head = NULL;
struct node** lastPtrRef= &head; // Start out pointing to the head pointer
int i;
for (i=1; i<6; i++) {
Push(lastPtrRef, i);
// Add node at the last pointer in the list
lastPtrRef= &((*lastPtrRef)->next); // Advance to point to the
// new last pointer
}
// head == {1, 2, 3, 4, 5};
return(head);
}

This technique is short, but the inside of the loop is scary. This technique is rarely used, but it’s a good way to see if you really understand pointers. Here’s how it works…

At the top of the loop, lastPtrRef points to the last pointer in the list. Initially it points to the head pointer itself. Later it points to the .next field inside the last node in the list.
Push(lastPtrRef, i); adds a new node at the last pointer. The new node becomes the last node in the list. 3.lastPtrRef= &((*lastPtrRef)->next); Advance the lastPtrRef to now point to the .next field inside the new last node — that .next field is now the last pointer in the list.

Here is a drawing showing the state of memory for the above code just before the third node is added. The previous values of lastPtrRef are shown in gray…

This technique is never required to solve a linked list problem, but it will be one of the alternative solutions presented for some of the advanced problems. The code is shorter this way, but the performance is probably not any better.

Unusual Techniques

Both the temporary-stack-dummy and the local-reference-pointer techniques are a little unusual. They are cute, and they let us play around with yet another variantion in pointer intensive code. They use memory in unusual ways, so they are a nice way to see if you really understand what’s going on. However, I probably would not use them in production

# Section 2 — Linked List Problems

Here are 18 linked list problems arranged in order of difficulty. The first few are quite basic and the last few are quite advanced. Each problem starts with a basic definition of what needs to be accomplished. Many of the problems also include hints or drawings to get you started. The solutions to all the problems are in the next section.

It’s easy to just passively sweep your eyes over the solution — verifying its existence without lettings its details touch your brain. To get the most benefit from these problems, you need to make an effort to think them through. Whether or not you solve the problem, you will be thinking through the right issues, and the given solution will make more sense.

Great programmers can visualize data structures to see how the code and memory will interact. Linked lists are well suited to that sort of visual thinking. Use these problems to develop your visualization skill. Make memory drawings to trace through the execution of code. Use drawings of the pre- and post-conditions of a problem to start thinking about a solution.

“The will to win means nothing without the will to prepare.” - Juma Ikangaa, marathoner

##1 — Count()

Write a Count() function that counts the number of times a given int occurs in a list. The code for this has the classic list traversal structure as demonstrated in Length().

void CountTest() {
List myList = BuildOneTwoThree();
int count = Count(myList, 2);
// build {1, 2, 3}
// returns 1 since there's 1 '2' in the list
}
/*
Given a list and an int, return the number of times that int occurs
in the list.
*/

int Count(struct node* head, int searchFor) {
// Your code