频率最高的手写代码面试题--链表类型(上)

1、奇偶链表

给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。

请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数

示例1
输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL

示例2
输入: 2->1->3->5->6->4->7->NULL
输出: 2->3->6->7->1->5->4->NULL

错误思路：两个指针连接在一起，最后隔一个删除节点，很明显这种思路失败了！

因为如果尾节点直接指向头指针，这样会造成循环链表，导致无法退出循环.

如果不考虑空间复杂度，复制一个一样的指针，这种思路其实也是可以的.但题目要求空间复杂度为O（1），案例中一个链表如果有很多个节点，那么就都需要复制，这显然是很不ok的解法

更好的思路：定义两个指针，一个是奇数指针，一个是偶数指针，两个指针螺旋式地解开链表

    def oddEvenList(self, head: ListNode) -> ListNode:
        if not head:
            return head
        even = head.next
        odd = head
        head_even = even
        while odd.next and even.next:
            odd.next = even.next
            odd = even.next

            even.next = odd.next
            even = odd.next
        odd.next = head_even
        return head

2、删除链表中的节点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点

现有一个链表 – head = [4,5,1,9]，它可以表示为:

示例 1:
输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2:
输入: head = [4,5,1,9], node = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

说明:
链表至少包含两个节点。
链表中所有节点的值都是唯一的。
给定的节点为非末尾节点并且一定是链表中的一个有效节点。
不要从你的函数中返回任何结果。

方法一：通过遍历，找到 node 的上一个节点，时间复杂度为O(N)

ListNode* deleteNode(ListNode* head, int val) {
   
        if(head == nullptr){
   
            return head;
        }
        ListNode* res = head;
        if(head->val==val){
   
            return head->next;
        }
        while(head && head->next){
   
            if(head->next->val == val){
   
                head->next = head->next->next;
            }
            head = head->next;
        }
        return res;
    }

方法二：递归写法

    ListNode* deleteNode(ListNode* head, int val) {
   
        if(head == nullptr){
   
            return head;
        }
        if(head->val == val){
   
            return head->next;
        }
        head->next = deleteNode(head->next,val);
        return head;
    }

方法三：使用 O(1) 的时间复杂度完成操作. 但是需要注意的是，如果可以确定 node 不是最后一个节点，这种方法是可行的，但是如果是最后一个节点，无法删除通过 node = None 的方式删除节点

def deleteNode(self, node):
	if node.next:
		node.val = node.next.val
	    node.next = node.next.next
	else:
		node = None

3、移除链表元素

删除链表中等于给定值 val 的所有节点

示例
输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5

方法一：先申请出一个节点，然后进行连接判断操作

    ListNode* removeElements(ListNode* head, int val) {
   
        if(head == nullptr){
   
            return head;
        }
        ListNode* dumpy = new ListNode(-1);
        dumpy->next = head;
        ListNode* cur = dumpy;
        while(head){
   
            if(head->val != val){
   
                cur->next = head;
                cur = cur->next;
            }
            head = head->next;
        }
        cur->next = nullptr;
        return dumpy->next;
    }

当然写法不唯一，但大致思路都是一样的

    ListNode* removeElements(ListNode* head, int val) {
   
        if(head == nullptr){
   
            return head;
        }
        ListNode* dumpy = new ListNode(-1);
        dumpy->next = head;
        ListNode*