链表是最为常见，并且经常需要使用到的数据结构之一。对于单链表的基本操作，例如创建链表、插入、删除等都不是特别复杂，但是其实对于链表的操作实际上很多的操作还是有一定的难度，例如上次给出的单链表的逆转，以及这里的单链表交换两个节点。

单链表的交换节点的含义是：给定一个单链表，要求交换其中的任意两个节点。注意这里链表的头节点是不参与节点交换的。这个看上去是比较简单，但是实现起来却还是需要一定的基本功。

对于这个问题，关键是要用4个指针来保存两个交换的节点的前后节点位置，具体实现请参见实现源码。实际上，还有一个逻辑更加清晰的实现：只要用两个指针保存当前的两个交换节点的前一个节点，然后依次删除待交换节点，再在记录的前一个节点后交替插入删除的两个节点，也就是实际上将这个过程转化为了对于链表的两个基本操作就可以完成了。但是要注意的是，这个实现中当两个交换节点是相邻节点的时候会出现问题，要单独处理，具体原因手工操作一次即可得知。后一种方法这里就不给出了。

实现代码中要说明的是，交换链表节点传入的是两个交换节点指针，但是为了测试简单实现，将这两个节点换成了待交换节点的关键字（值域），再到链表中定位。

   1: void ExchLinkNode(const LinkNode head,const LinkNode node1,const LinkNode node2)

   2: {

   3:       //head不准被交换

   4:        LinkNode prenode1 = NULL;  //保存待交换节点node1的前一个节点

   5:  

   6:        LinkNode postnode1 = NULL; //保存待交换节点node1的后一个节点

   7:  

   8:        LinkNode prenode2 = NULL;  //保存待交换节点node2的前一个节点

   9:  

  10:        LinkNode postnode2 = NULL; //保存待交换节点node2的后一个节点

  11:  

  12:        LinkNode tmp = head;

  13:  

  14:        //不得和头节点交换

  15:        if (node1 == head)

  16:        {

  17:              return ;

  18:        }

  19:        else if (node2 == head)

  20:        {

  21:               return ;

  22:        }

  23:  

  24:        //自己和自己就不必交换了

  25:        if (node1 == node2)

  26:        {

  27:               return ;

  28:        }

  29:  

  30:        //节点相邻情况处理

  31:        if (node1->_next == node2)

  32:        {

  33:               tmp = head;

  34:  

  35:               while (tmp->_next != node1)

  36:               {

  37:                      tmp = tmp->_next;

  38:               }

  39:               prenode1 = tmp;

  40:  

  41:               postnode2 = node2->_next;

  42:  

  43:               prenode1->_next = node2;

  44:  

  45:               node2->_next = node1;

  46:  

  47:               node1->_next = postnode2;

  48:  

  49:               return ;

  50:        }

  51:  

  52:        if (node2->_next == node1)

  53:        {

  54:               tmp = head;

  55:  

  56:               while (tmp->_next != node1)

  57:               {

  58:                      tmp = tmp->_next;

  59:               }

  60:  

  61:               prenode2 = tmp;

  62:               postnode1 = node1->_next;

  63:  

  64:               prenode2->_next = node1;

  65:  

  66:               node1->_next = node2;

  67:  

  68:               node2->_next = postnode1;

  69:               return ;

  70:        }

  71:        tmp = head;

  72:  

  73:        while (tmp->_next != node1)

  74:        {

  75:               tmp = tmp->_next;

  76:        }

  77:  

  78:        prenode1 = tmp;

  79:  

  80:        tmp = head;

  81:  

  82:        while (tmp->_next != node2)

  83:        {

  84:               tmp = tmp->_next;

  85:        }

  86:        prenode2 = tmp;

  87:  

  88:        postnode1 = node1->_next;

  89:  

  90:        postnode2 = node2->_next;

  91:  

  92:        //交换节点

  93:        prenode1->_next = node2;

  94:  

  95:        node2->_next = postnode1;

  96:  

  97:        prenode2->_next = node1;

  98:  

  99:        node1->_next = postnode2;

 100: }

测试测序：

   1: /* Test program */

   2: //main.cpp

   3:  

   4: #include "Link.h"

   5:  

   6: #include <iostream>

   7:  

   8: using namespace std;

   9:  

  10: int main(int argc,char* argv[])

  11: {

  12:        LinkNode head = CreateLink(10);

  13:  

  14:        Print(head,"before exchanging....");

  15:  

  16:        ExchLinkNode (head,3,8);

  17:  

  18:        Print(head,"after exchanging....");

  19:  

  20:        return 0;

  21: }