链表逆序

    （1）普通连续内存数据的反转分析

[cpp]  view plain copy

1. STATUS normal_revert(int array[], int length)  
2. {  
3.     int* pData ;  
4.     int index = length - 1;  
5.     if(NULL == array || 0 == length)  
6.         return FALSE;  
7.   
8.     pData = (int*)malloc(sizeof(int) * length);  
9.     assert(NULL != pData);  
10.     memset(pData, 0, sizeof(int) * length);  
11.   
12.     while(index >= 0)  
13.         pData[length - 1 - index] = array[index], index --;  
14.   
15.     memmove(array, pData, length * sizeof(int));  
16.     free(pData);  
17.     return TRUE;  
18. }  

我们看到连续内存反转函数主要做了下面几个工作：

    1）分配和原来数据一样大的内存

    2）从原来数据末尾开始拷贝 

    3）利用pData获取的数据对原来的数据进行拷贝覆盖，释放内存

    （2）链表数据的反转

[cpp]  view plain copy

1. STATUS link_revert(NODE** pNode)  
2. {  
3.     NODE* pPrevNode;  
4.     NODE* pNextNode;  
5.     if(NULL == pNode || NULL == *pNode)  
6.         return FALSE;  
7.   
8.     pNextNode = (*pNode)->next;  
9.     (*pNode) ->next = NULL;  
10.   
11.     while(pNextNode){  
12.         pPrevNode = pNextNode;  
13.         pNextNode = pNextNode->next;  
14.         pPrevNode->next = *pNode;  
15.         *pNode = pPrevNode;  
16.     }  
17.   
18.     return TRUE;  
19. }  

和连续内存不同，链表节点的反转需要进行下面一些操作：

    1） 判断指针是否为空，判断指针的指针是否为空

    2） 将指针分成两个部分，一个是已经反转成功的链表，即pNode；另外一个是待反转的链表，即pPrevNode

    3） 对2）进行循环迭代处理，直到所有的节点都已经接受反转