算法题18 逆序（字符串、整数、单向链表）

1、反转字符串

即使“abcdef”反转结果为“fedcba”。

可知，其实字符串反转就是交换i与n-i-1位置的字符。时间复杂度O(n/2)

代码如下：

    
    
    
    

     
     
     
     
     //
     
     
     
      反转字符串
     
     
     
      
     
     
     
     void
     
     
     
      ReverseString(
     
     
     
     char
     
     
     
     *
     
     
     
      pStr) { 
     
     
     
     int
     
     
     
      n 
     
     
     
     =
     
     
     
      strlen(pStr); 
     
     
     
     for
     
     
     
     (
     
     
     
     int
     
     
     
      i 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; i 
     
     
     
     <
     
     
     
      n
     
     
     
     /
     
     
     
     2
     
     
     
     ; i
     
     
     
     ++
     
     
     
     ) { 
     
     
     
     char
     
     
     
      t 
     
     
     
     =
     
     
     
      pStr[i]; pStr[i] 
     
     
     
     =
     
     
     
      pStr[n
     
     
     
     -
     
     
     
     i
     
     
     
     -
     
     
     
     1
     
     
     
     ]; pStr[n
     
     
     
     -
     
     
     
     i
     
     
     
     -
     
     
     
     1
     
     
     
     ] 
     
     
     
     =
     
     
     
      t; } }
    
    
    
    

PS:C#中StringBuffer类中有现成的函数

2、反转整数

    
    
    
    

     
     
     
     
     //
     
     
     
      反转整数
     
     
     
      
     
     
     
     int
     
     
     
      ReverseInt(
     
     
     
     int
     
     
     
      num) { 
     
     
     
     int
     
     
     
      res 
     
     
     
     =
     
     
     
      
     
     
     
     0
     
     
     
     ; 
     
     
     
     while
     
     
     
     (num) { res 
     
     
     
     =
     
     
     
      (res 
     
     
     
     *
     
     
     
      
     
     
     
     10
     
     
     
      
     
     
     
     +
     
     
     
      num
     
     
     
     %
     
     
     
     10
     
     
     
     ); num 
     
     
     
     /=
     
     
     
      
     
     
     
     10
     
     
     
     ; } 
     
     
     
     return
     
     
     
      res; }
    
    
    
    

3、反转单向链表

其实诀窍就是新建一个临时节点作为虚拟头节点，遍历每个节点，使之插入在临时节点之后

    
    
    
    

     
     
     
     
     struct
     
     
     
      ListNode { 
     
     
     
     int
     
     
     
      key; ListNode
     
     
     
     *
     
     
     
      pNext; }; 
     
     
     
     //
     
     
     
      反转单向链表
     
     
     
      
     
     
     
     void
     
     
     
      ReverseList(ListNode
     
     
     
     *
     
     
     
      pRoot) { 
     
     
     
     if
     
     
     
     (pRoot 
     
     
     
     ==
     
     
     
      NULL 
     
     
     
     ||
     
     
     
      pRoot
     
     
     
     ->
     
     
     
     pNext 
     
     
     
     ==
     
     
     
      NULL) 
     
     
     
     return
     
     
     
     ; ListNode temp; temp.pNext 
     
     
     
     =
     
     
     
      pRoot; ListNode
     
     
     
     *
     
     
     
      pCur 
     
     
     
     =
     
     
     
      pRoot
     
     
     
     ->
     
     
     
     pNext; pRoot
     
     
     
     ->
     
     
     
     pNext 
     
     
     
     =
     
     
     
      NULL; 
     
     
     
     //
     
     
     
      把每个节点均插入在temp后，pRoot始终指向反转链表后的头节点
     
     
     
      
     
     
     
      
     
     
     
     while
     
     
     
     (pCur) { temp.pNext 
     
     
     
     =
     
     
     
      pCur; temp.pNext
     
     
     
     ->
     
     
     
     pNext 
     
     
     
     =
     
     
     
      pRoot; pRoot 
     
     
     
     =
     
     
     
      temp.pNext; pCur 
     
     
     
     =
     
     
     
      pCur
     
     
     
     ->
     
     
     
     pNext; } }