Leetcode Tags（1）Linked List

最新推荐文章于 2024-11-05 15:38:36 发布

weixin_30568715

最新推荐文章于 2024-11-05 15:38:36 发布

阅读量68

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/BigJunOba/p/9563813.html

版权

　　1.知识点回顾

　　https://www.cnblogs.com/BigJunOba/p/9174206.html

　　https://www.cnblogs.com/BigJunOba/p/9174217.html

　　2.典型例题（Easy）

　　（1）707 Design Linked List

Implement these functions in your linked list class:

    get(index) : Get the value of the index-th node in the linked list. If the index is invalid, return -1.
    addAtHead(val) : Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
    addAtTail(val) : Append a node of value val to the last element of the linked list.
    addAtIndex(index, val) : Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
    deleteAtIndex(index) : Delete the index-th node in the linked list, if the index is valid.

Example:

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1, 2);  // linked list becomes 1->2->3
linkedList.get(1);            // returns 2
linkedList.deleteAtIndex(1);  // now the linked list is 1->3
linkedList.get(1);            // returns 3

　　模型：Head→Node(0)→Node(1)→Node(2)→Node(3)→null（从第二题开始，都使用另外一种模型Head(0)→Node(1)→Node(2)→Node(3)）

package LinkedList;

public class E707DesignLinkedList {
    
    class Node{
        private int val;
        private Node next;
        
        public Node(int val, Node next) {
            this.val = val;
            this.next = next;
        }
        
        public Node(int val) {
            this(val, null);
        }
        
    }
    
    private Node head;

    /** Initialize your data structure here. */
    public E707DesignLinkedList() {
        head = new Node(0);
    }
    
    /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
    public int get(int index) {　　                 // 定位到Node(index)，判断Node(index)是否为null
        Node p = head;
        int i = -1;
        while (p != null && i < index) {
            i++;
            p = p.next;
        }
        if (p == null || index < 0) return -1;
        return p.val;
    }
    
    /** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
    public void addAtHead(int val) {
        Node p = new Node(val);
        p.next = head.next;
        head.next = p;
    }
    
    /** Append a node of value val to the last element of the linked list. */
    public void addAtTail(int val) {
        Node p = head;
        while (p.next != null) {
            p = p.next;
        }
        Node q = new Node(val);
        p.next = q;
    }
    
    /** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
    public void addAtIndex(int index, int val) {    // 定位到Node(index-1)，判断Node(index-1)是否为null
        Node p = head;
        int i = -1;
        while (p != null && i < index-1) {
            i++;
            p = p.next;
        }
        if (p == null) return;
        Node q = new Node(val);
        q.next = p.next;
        p.next = q;
    }
    
    /** Delete the index-th node in the linked list, if the index is valid. */
    public void deleteAtIndex(int index) {          // 定位到Node(index-2)，判断Node(index-1)是否为null
        Node p = head;
        int i = -1;
        while (p.next != null && i < index - 1) {
            i++;
            p = p.next;
        }
        if (p.next == null || index < 0) return;
        p.next = p.next.next;
    }


// 求长度 head-1-2-3-4-5-null：返回5
　　  public int getlength() {
        int length = 0;
        Node p = head;
        while (p.next != null) {
            length++;
            p = p.next;
        }
        return length;
    }
    
    public void traverse() {
        System.out.print("bianli: ");
        Node p = head.next;
        while (p != null) {
            System.out.print(p.val + " ");
            p = p.next;
        }
        System.out.println();
    }   
}

　　（2）206.反转单链表

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

　　堆栈方式（O(n) + O(n)）：

    public ListNode reverseList(ListNode head) {
        Stack<Integer> stack = new Stack<>();
        ListNode p = head;
        while (p != null) {
            stack.push(p.val);
            p = p.next;
        }
        ListNode result = head;
        while (!stack.isEmpty()) {
            result.val = stack.pop();
            result = result.next;
        }
        return head;
    }

　　迭代方式（O(n) + O(1)）：将1->2->3->4->5->NULL改成5->4->3->2->1->NULL

public ListNode reverseList(ListNode head) {
    ListNode prev = null;                   　　// 初始化当前结点（头结点）的前一个结点为null
    ListNode curr = head;　　　　　　　　　　　　  // 初始化当前结点为头结点
    while (curr != null) {　　　　　　　　　　　　// 如果当前结点如果不为空
        ListNode nextTemp = curr.next;        // 
        curr.next = prev;                     // 当前结点指向当前结点的前一个结点
        prev = curr;                          // 更新前一个结点为当前结点
        curr = nextTemp;                      // 更新当前结点为当前结点的下一个结点
    }
    return prev;                              // 最后一步：1结点不为null，nextTemp为null，1结点指向2结点，prev为2结点，curr为null，返回prev
}

　　递归方式（O(n) + O(n)）：

public ListNode reverseList(ListNode head) {
    if (head == null || head.next == null) return head;   // 出口条件，一直到5，才返回head为5结点
    ListNode p = reverseList(head.next);
    head.next.next = head;
    head.next = null;
    return p;
}
假设单链表的结构如下：
n₁ → … → n_k-1 → n_k → n_k+1 → … → n_m → Ø
假设n_k+1 → … → n_m已经被颠倒过来并且现在在n_k，那么必须n_k.next.next = n_k;也就是n_k.next是n_k+1，然后反向指就是n_k+1.next又是n_k，同时必须要使n_k.next=null，因为第一个结点的next必须为null。

　　分析递归过程：注意p不变，一直都是最后一个结点！！！为新链表的头结点。

0 Main：reverseList(1)
1 head：1，p=reverseList(2);
2 head：2，p=reverseList(3);
3 head：3，p=reverseList(4); 
4 head：4，p=reverseList(5);         ↑ →null                                        return p=5                                                    
5 head：3，p=reverseList(4);  1→2→3→ 4 ← 5      ↑→null                              return p=5
6 head：2，p=reverseList(3);               1→2→3←4←5    ↑→null                      return p=5
7 head：1，p=reverseList(2);                          1→2←3←4←5    ↑→null           return p=5
8 Main：reverseList(1)                                            1←2←3←4←5         return p=5

　　（3）876.求链表中间结点ListNode

Example 1:

Input: [1,2,3,4,5]
Output: Node 3 from this list (Serialization: [3,4,5])
The returned node has value 3.  (The judge's serialization of this node is [3,4,5]).
Note that we returned a ListNode object ans, such that:
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, and ans.next.next.next = NULL.

Example 2:

Input: [1,2,3,4,5,6]
Output: Node 4 from this list (Serialization: [4,5,6])
Since the list has two middle nodes with values 3 and 4, we return the second one.

　　注意：这里的头结点head是有数据的，以[1,2,3,4,5]为例，head.val的值是1

    public ListNode middleNode(ListNode head) {
        int length = 0;
        ListNode node = head;
        while(node != null){
            length++;
            node = node.next;
        }
        ListNode result = head;
        for(int i = 1; i <= length/2; i++){
            result = result.next;
        }
        return result;
    }

　　（4）删除当前ListNode node的两种方法

1.定位到node
node.val = node.next.val;
node.next = node.next.next;
2.定位到node的前一个结点
node.next = node.next.next;

　　（5）迭代方法删除单链表中val的值等于给定的val的结点

Input:  1->2->6->3->4->5->6, val = 6
Output: 1->2->3->4->5

　　迭代方法：

public ListNode removeElements(ListNode head, int val) {
        if (head == null) return null;
        head.next = removeElements(head.next, val);
        return head.val == val ? head.next : head;
}

　　非迭代方法：1->2->6->3->4->5->6, val = 6 Output: 1->2->3->4->5

　　总结，为了应对末尾的5→6→null，的问题，必须当curr为5时判断curr.next.val，然后才可以处理，也就是说定位到被删结点的前一个结点。

    public ListNode removeElements(ListNode head, int val) {
        if (head == null) return null;
        ListNode curr = head;
        while(curr.next != null){                        // 注意出口条件curr.next != null即可
            if(curr.next.val == val){　　　　　　　　　　　　// 注意在删完结点后，curr.next变成了被删结点的下一个结点，因此指针不用动
                curr.next = curr.next.next;　　　　　　　　// 如果出口条件是curr.next，那么循环内部最多只能多一个next，即curr.next.next
            } else{
                curr = curr.next; 
            }
        }
        return head.val == val ? head.next : head;      // 处理这种情况：[1，2，...], 1，因为开始判断的时候就是curr.next即head.next，没有从head开始
    }

　　（6）删除val值重复的Node

Input: 1->1->2->3->3
Output: 1->2->3

　　参考上面的（5）的非迭代方法可以很容易地写出来

   public ListNode deleteDuplicates(ListNode head) {
        if (head == null) return null;
        ListNode curr = head;
        int prev = curr.val;
        while (curr.next != null) {
            if (curr.next.val == prev) {
                curr.next = curr.next.next;
            } else {
                curr = curr.next;
                prev = curr.val;
            }
        }
        return head;
    }

　　迭代方法：

public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next == null)return head;
        head.next = deleteDuplicates(head.next);
        return head.val == head.next.val ? head.next : head;
}

　　（7）

　　（8）

　　（9）

　　3.典型例题（Medium）

　　4.典型例题（Hard）

转载于:https://www.cnblogs.com/BigJunOba/p/9563813.html