LeetCode链表（不断更新）

234. Palindrome Linked List

题意：判断链表是否是回文串

思路：
方法有三种，方法一空间复杂度O(n)，方法二O(n/2)，方法三O(1)，三种时间复杂度都是O(n)。
方法一：遍历链表将节点依次压入一个栈中，弹出栈时依次从链表头开始对比，都一样则说明链表是回文串，有一个不一样的就不是。
方法二：使用快慢两个指针从头遍历链表，快指针一次遍历两个节点，慢指针一次遍历一个节点并弹入栈中。当快指针遇到结尾时慢指针恰好处在中间节点上（如果是偶数个节点则处在中间偏前面的节点上），此时慢指针依然向后遍历，同时将栈中节点弹出依次和慢指针遍历的节点对比，一致则为回文串。
方法三：找到中间节点的部分和方法二相同，之后将后一半的节点反转，用两个指针分别从链表的最左边和最右边开始对比，向中间节点靠近，直到汇合在中间节点为止都一样的话则为回文串。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        if(head==NULL) return true;
        if(head->next==NULL) return true;
        ListNode* slow=head;
        ListNode* high=head;
        while(high->next!=NULL&&high->next->next!=NULL)
        {
            slow=slow->next;
            high=high->next;
            high=high->next;
        }
        ListNode* medium = slow;
        ListNode* pre = NULL;
        while (slow) {
            ListNode* next = slow -> next;
            slow -> next = pre;
            pre = slow;
            slow = next;
        }
        medium->next=NULL;
        while(pre!=NULL&&head!=NULL)
        {
            if(pre->val!=head->val)
                return false;
            pre=pre->next;
            head=head->next;
        }
        return true;
    }
};

141. Linked List Cycle

题意：判断链表是否有环
思路：
方法一：哈希表判断是否有节点重复，空间复杂度O(n)；
方法二：快慢指针遍历，如果快指针遇到NULL，则不存在环；若快慢指针相遇，则有环。空间复杂度O(1)。

142. Linked List Cycle II

题意：判断链表是否有环并返回入环节点
思路：
快慢指针相遇时，令快指针指向链表头开始遍历，一次遍历一个节点，慢指针依然从相遇的地方继续以原速度遍历，两个指针相遇的地方即是入环的地方。

109. Convert Sorted List to Binary Search Tree

题意：将升序链表转化为一棵平衡的二叉搜索树
思路：
找到链表中间的节点赋值给二叉树根节点，然后递归处理左右两半边的链表值，左半边的中间节点赋给二叉树根节点的左孩子，右半边的中间节点赋给二叉树的右孩子，以这种方式不断递归下去直到处理完所有链表节点。

/*some error exists in the code*/
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void trans(ListNode* head,TreeNode** ans) {
        TreeNode* ans1=*ans;
        if(head->next==NULL) 
        {
            ans1 = new TreeNode( head->val );
            return ;
        }

        ListNode* slow=head;
        ListNode* fast=head;

        while(fast->next!=NULL&&fast->next->next!=NULL) 
        {
            slow=slow->next;
            fast=fast->next;
            fast=fast->next;
        }

        ListNode* medium = slow->next;
        ans1 = new TreeNode( slow->val );
        slow->next=NULL;
        slow=slow->next;
        trans(head,&ans1->left);
        trans(medium,&ans1->right);
    }

    TreeNode* sortedListToBST(ListNode* head)
    {
        TreeNode* root=NULL;
        if(head==NULL) return root;
        trans(head,&root);
        return root;
    }
};

147. Insertion Sort List

题意：用插入排序法使一个链表变的有序
思路：
做法基本和用插入排序法使数组有序一样。