C/C++链表操作（面试）

1.为了反转这个单链表，我们先让头结点的next域指向结点2，再让结点1的next域指向结点3，最后将结点2的next域指向结点1，就完成了第一次交换，顺序就变成了Header-结点2-结点1-结点3-结点4-NULL，然后进行相同的交换将结点3移动到结点2的前面，然后再将结点4移动到结点3的前面就完成了反转，思路有了，就该写代码了：

 LinkedList ReverseSinglyLinkedList(LinkedList list)
 {
     LNode   *tmp = NULL;
     LNode   *p = NULL;

     if (list == NULL)
     {
         return NULL;
     }
     tmp = list->next;
     while (tmp->next != NULL)
     {
         p = tmp->next;
         tmp->next = p->next;
         p->next = list->next;
         list->next = p;
     }
     return list;
 }

2.链表排序
  相比较线性表的排序而言，链表排序的内容稍微麻烦一点。一方面，你要考虑数据插入的步骤；另外一方面你也要对指针有所顾虑。要是有一步的内容错了，那么操作系统会马上给你弹出一个exception。就链表的特殊性而言，适合于链表的排序有哪些呢？

（1）插入排序    （适合）

（2）冒泡排序    （适合）

（3）希尔排序    （适合）

（4）选择排序    （适合）

（5）快速排序    （不适合）

（6）合并排序    （不适合）

（7）基数排序     （不适合）

（8）堆排序         （不适合）

其实，一般来说。如果涉及到数据之间的相对关系调配，那么只适合线性排序；如果只是数据内容之间的相互交换，那么这种排序方法也比较适合链表的排序。快速排序、合并排序、堆排序都涉及到了中间值的选取问题，所以不大适合链表排序。

为了说明链表排序是怎么进行的，我们可以利用插入排序作为示例，描述链表是怎么进行插入排序的。

 a）首先遍历节点，一边是排序好的节点，一边是待排序的节点

 void sort_for_link_node(NODE** ppNode)
 {
     NODE* prev;
     NODE* curr;

     if(NULL == ppNode || NULL == *ppNode)
         return;

     curr = (*ppNode) ->next;
     (*ppNode) ->next = NULL;

     while(curr){
         prev = curr;
         curr = curr->next;
         insert_for_sort_operation(ppNode, prev);
     }

     return;
 }

b）对于待插入的节点，选择合适的位置插入即可 

 void insert_for_sort_operation(NODE** ppNode, NODE* pNode)
 {
     NODE* prev;
     NODE* cur;

     /* 在第一个数据之前插入pNode */
     if(pNode->data < (*ppNode)->data){
         pNode->next = *ppNode;
         *ppNode = pNode;
         return;
     }

     cur = *ppNode;
     while(cur){
         if(pNode->data < cur->data)
             break;

         prev = cur;
         cur = cur->next;
     }

     pNode->next = prev->next;
     prev->next = pNode;
     return;
 }

3.有序单链表的合并就是两个之前都已排好序的链表，将它们合并成一个链表。合并的过程中对于两个链表值相等的结点也要链到最终的链表中去。

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

 typedef struct Node Node;

 Node *Merge(Node *head1,Node *head2)
 {
     Node *p1 = NULL;
     Node *p2 = NULL;
     Node *head = NULL;

     //找出两个链表中第一个结点较小的结点，head记录较小结点的头结点
     if(head1->next->data < head2->next->data)
     {
         head = head1;
         p1 = head1->next;
         p2 = head2->next;
     }
     else
     {
         head = head2;
         p2 = head2->next;
         p1 = head1->next;
     }

     Node *pcur = head;

     //在两个链表中遍历比较，将值较小的结点链接到pcur结点后
     while(p1 != NULL && p2 != NULL)
     {
         if(p1->data <= p2->data)
         {
             pcur->next = p1;
             pcur = p1;
             p1 = p1->next;
         }
         else
         {
             pcur->next = p2;
             pcur = p2;
             p2 = p2->next;
         }
     }
     //将p1或p2剩余的结点链到pcur之后，完成整个合并的过程
     if(p1 != NULL)
         pcur->next = p1;
     if(p2 != NULL)
         pcur->next = p2;

     return head;
 }