链表反转

方法1. 迭代。 分别设置三个指针。第一个指针保持结果，第二个指针指向当前的节点，第三个指针保存下一个节点。
/* 反转单链表. 分别用3个指针，指向前一个，当前，下一个 */

static void reverse(struct node** head_ref)
{
    struct node* prev   = NULL;
    struct node* current = *head_ref;
    struct node* next;
    while (current != NULL)
    {
        next  = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    *head_ref = prev;
}

方法2：使用递归。
/* 使用递归的方法 */

static struct node * reverseRecall(struct node* head){
    //最后一个节点会返回 作为头部
    if(NULL == head || head->next == NULL) return head;
    //head->next 表示剩下的部分
    struct node * newHead = reverseRecall(head->next);
    head->next->next = head; //颠倒指针
    head->next = NULL;//原来的头节点 next 应该为空
    return newHead;
}

链表中倒数第k个结点

方法1.走到尾端后回溯（不推荐）。
方法2.两个指针，第一个先走k步，之后同时走。注意判断第一个走完的情况。

调整数组顺序使奇数位于偶数前面

方法
Step1.第一个指针初始化时指向数组的第一个数字，它只向后移动；
　 Step2.第二个指针初始化时指向数组的最后一个数字，它只向前移动。
　 Step3.在两个指针相遇之前，第一个指针总是位于第二个指针的前面。如果第一个指针指向的数字是偶数，并且第二个指针指向的数字是奇数，我们就交换这两个数字。

public static void ReorderOddEven(int[] datas)
    {
        if (datas == null || datas.Length <= 0)
        {
            return;
        }

        int begin = 0;
        int end = datas.Length - 1;
        int temp = -1;

        while (begin < end)
        {
            // 向后移动begin，直到它指向偶数
            while (begin < end && datas[begin] % 2 != 0)
            {
                begin++;
            }
            // 向前移动pEnd，直到它指向奇数
            while (begin < end && datas[end] % 2 == 0)
            {
                end--;
            }

            if (begin < end)
            {
                // 交换偶数和奇数
                temp = datas[begin];
                datas[begin] = datas[end];
                datas[end] = temp;
            }
        }
    }

未完待续。。。