LeetCode 206. Reverse Linked List

https://leetcode.com/problems/reverse-linked-list/description/

Reverse a singly linked list.

Hint:

A linked list can be reversed either iteratively or recursively. Could you implement both?

---

• 链表题。思路要清晰，别弄混了。
• 迭代版。三个指针，previous, current, next。整体思路是从头往尾处理，把前一个指针赋给当前指针的next之后，把三个指针再右移，继续处理下次循环，直到当前指针为nullptr。首先保存pCur->next到pNext，然后反转previous和current，pCur->next = pPre。之后把previous和current指针往右移继续处理下一个循环，pPre = pCur, pCur = pNext。注意循环结束的判断条件是pCur != nullptr。因为最后一次循环到尾指针，则会把尾指针的next指针null赋值给pCur，pCur赋值给pPre，循环正好结束。此时pCur则为反转之后的头指针，因为前面的指针都已经在它的next里了。
• 递归版有两个。一个需要再借助一个函数，按照非递归版重写的；另一个比较tricky不需要额外函数。
• Reverse Linked List - LeetCode
  • https://leetcode.com/problems/reverse-linked-list/solution/

//
//  main.cpp
//  LeetCode
//
//  Created by Hao on 2017/3/16.
//  Copyright © 2017年 Hao. All rights reserved.
//

#include <iostream>
#include <vector>
#include <queue>
#include <set>
using namespace std;

/**
 * Definition for singly-linked list.
 */
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    // Iterative solution
    ListNode* reverseList(ListNode* head) {
        // corner case
        if (head == nullptr || head->next == nullptr)
            return head;
        
        ListNode *pPre = nullptr, *pCur = head;
        
        while (pCur != nullptr) {
            ListNode* pNext = pCur->next; // store the next pointer
            pCur->next = pPre; // reverse the previous and current pointer
            
            // move the previous and current pointer rightward for the next loop
            pPre = pCur;
            pCur = pNext;
        }
        
        return pPre;
    }
    
    // Recursive solution
    ListNode* reverseList2(ListNode* head) {
        ListNode *pPrevious = nullptr, *pCurrent = head;
        
        return reverse(pPrevious, pCurrent);
    }
    
    ListNode* reverse(ListNode* pPre, ListNode* pCur) {
        if (pCur == nullptr) return pPre;
        
        ListNode* pNext = pCur->next;
        pCur->next = pPre;
        
        return reverse(pCur, pNext);
    }
    
    // Tricky Recursive solution
    ListNode* reverseList3(ListNode* head) {
        if (head == nullptr || head->next == nullptr) return head;
        
        ListNode* p = reverseList3(head->next);
        
        head->next->next = head;
        head->next = nullptr;
        
        return p;
    }
    
    ListNode* createList() {
        ListNode    *pCur = nullptr, *pHead = nullptr;
        
        for (int i = 0; i < 10; i ++) {
            ListNode* pTemp = new ListNode(i);
            
            if (0 == i) {
                pHead = pCur = pTemp;
            } else {
                pCur->next = pTemp;
                pCur = pCur->next;
            }
        }
        
        return pHead;
    }
    
    void printList(ListNode* head) {
        if (head != nullptr) {
            cout << head->val << endl;
            printList(head->next);
        } else {
            cout << endl;
        }
    }
    
    void deleteList(ListNode** head) {
        ListNode* pDel = *head;
        
        while (pDel != nullptr) {
            ListNode* pNext = pDel->next;
            
            delete pDel;
            pDel = nullptr;
            
            pDel = pNext;
        }

        // neccessary?
        *head = nullptr;
    }
};

int main(int argc, char* argv[])
{
    Solution    testSolution;
    
    /*
     0
     1
     2
     3
     4
     5
     6
     7
     8
     9
     
     9
     8
     7
     6
     5
     4
     3
     2
     1
     0
     */
    // call reverseList()
    ListNode* pHead = testSolution.createList();
    
    testSolution.printList(pHead);
    
    ListNode* pRHead = testSolution.reverseList(pHead);
    
    testSolution.printList(pRHead);

    testSolution.deleteList(&pRHead);

    // call reverseList2()
    pHead = testSolution.createList();
    
    testSolution.printList(pHead);
    
    pRHead = testSolution.reverseList2(pHead);
    
    testSolution.printList(pRHead);
    
    testSolution.deleteList(&pRHead);

    // call reverseList3()
    pHead = testSolution.createList();
    
    testSolution.printList(pHead);
    
    pRHead = testSolution.reverseList3(pHead);
    
    testSolution.printList(pRHead);
    
    testSolution.deleteList(&pRHead);

    return 0;
}