Reversing the Unidirectional Chain List

Answer 1

The following is a possible way to reverse the single-way list in iPhone:

First, define the node structure of the single-way linked list, for example:

```objc
//define the list node structure
typedef struct ListNode {
int val;
struct ListNode *next;
} ListNode;
```

Then, you can use an iterated method to reverse the list:

```objc
ListNode* reverseList(ListNode* head) {
ListNode* prev = NULL;
ListNode* current = head;
while (current!= NULL) {
ListNode* nextTemp = current->next;
current->next = prev;
prev = current;
current = nextTemp;
}
return prev;
}
```

Here,`prev` is initialised to `Null', and`current`starts from the head of the list. In each of the iterations, the next node of the current node is saved to `nextTemp`, then the `next` pointer of the current node points to the previous node (namely `prev`), and then `prev` is updated to the current node, and `current` is the next node saved previously (`nextTemp`). When `current` is `nil`, it means that the end of the original list has been traversed. At this time,`prev` is the head node of the inverted list.

It could also be done using a recursion method:

```objc
ListNode* reverseListRecursive(ListNode* head) {
if (head == NULL || head->next == NULL) {
return head;
}
ListNode* newHead = reverseListRecursive(head->next);
head->next->next = head;
head->next = NULL;
return newHead;
}
```

The idea of the recursion is that if the list 'head' is empty or there is only one node ('head->next == Null'), it will directly return' head 'because it is the result of the reversal. Otherwise, the linked list behind `head` will be inverted to get the new head node `newHead`, and then the `head` node will be connected to the end of the inverted linked list (through `head->next->next = head`). The `next` pointer of `head` will be set to `Null', and the new head node`newHead`will be returned.
Read more exciting novels for free