算法题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;
    }
}