当前位置：首页 > news >正文

leetcode_707. 设计链表_java

news 2025/7/7 0:05:32

707. 设计链表https://leetcode.cn/problems/design-linked-list/

1、题目

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例：

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

提示：

0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

2、题解

题解1

单链表

class MyLinkedList {

    // 定义链表节点的内部类
    class ListNode {
        int val;       // 节点的值
        ListNode next; // 下一个节点的引用

        // 构造函数，用于初始化节点的值
        ListNode(int val) {
            this.val = val;
        }
    }

    private int size;     // 链表的大小
    private ListNode head; // 虚拟头节点，方便边界处理

    // 构造函数，初始化链表为空链表
    public MyLinkedList() {
        this.size = 0;              // 初始大小为0
        this.head = new ListNode(0); // 创建一个虚拟头节点，方便插入和删除操作
    }
    
    // 获取链表中指定索引位置的值，如果索引无效，返回-1
    public int get(int index) {
        // 如果索引小于0或者大于等于链表的大小，返回-1
        if(index < 0 || index >= size) {
            return -1;
        }
        // 从头节点开始遍历链表，找到指定索引的节点
        ListNode cur = head;
        for(int i = 0; i <= index; i++) {
            cur = cur.next;
        }
        // 返回找到节点的值
        return cur.val;
    }
    
    // 在链表头部添加一个新节点
    public void addAtHead(int val) {
        // 创建新节点
        ListNode newNode = new ListNode(val);
        // 新节点指向当前头节点的下一个节点
        newNode.next = head.next;
        // 头节点指向新节点
        head.next = newNode;
        size++; // 更新链表大小
    }
    
    // 在链表尾部添加一个新节点
    public void addAtTail(int val) {
        // 创建新节点
        ListNode newNode = new ListNode(val);
        ListNode cur = head;
        // 遍历到链表的最后一个节点
        while(cur.next != null) {
            cur = cur.next;
        }
        // 将最后一个节点的 next 指向新节点
        cur.next = newNode;
        size++; // 更新链表大小
    }
    
    // 在指定索引位置插入新节点
    public void addAtIndex(int index, int val) {
        // 如果索引小于0或大于链表的大小，插入失败
        if (index < 0 || index > size) {
            return;
        }
        
        // 创建新节点
        ListNode newNode = new ListNode(val);
        ListNode cur = head;
        // 遍历到指定索引位置
        for(int i = 0; i < index; i++) {
            cur = cur.next;
        }
        // 新节点的 next 指向 cur.next
        newNode.next = cur.next;
        // 当前节点的 next 指向新节点
        cur.next = newNode;
        size++; // 更新链表大小
    }
    
    // 删除指定索引位置的节点
    public void deleteAtIndex(int index) {
        // 如果索引无效，删除失败
        if (index < 0 || index >= size) {
            return;
        }
        ListNode cur = head;
        // 遍历到指定索引位置
        for(int i = 0; i < index; i++) {
            cur = cur.next;
        }
        // 删除指定位置的节点
        cur.next = cur.next.next;
        size--; // 更新链表大小
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

题解2

双链表

class MyLinkedList {

    // 定义链表节点的内部类
    class ListNode {
        int val;         // 节点的值
        ListNode next;   // 下一个节点
        ListNode prev;   // 上一个节点
        
        // 构造函数，初始化节点的值
        ListNode(int val) {
            this.val = val;
        }
    }

    private int size;        // 链表的大小
    private ListNode head;   // 虚拟头节点
    private ListNode tail;   // 虚拟尾节点

    // 构造函数，初始化链表为空链表
    public MyLinkedList() {
        this.size = 0;
        this.head = new ListNode(0); // 创建虚拟头节点
        this.tail = new ListNode(0); // 创建虚拟尾节点
        this.head.next = tail; // 头节点的下一个是尾节点
        this.tail.prev = head; // 尾节点的前一个是头节点
    }

    // 获取链表中指定索引位置的节点的值
    public int get(int index) {
        // 如果索引无效，返回-1
        if (index < 0 || index >= size) {
            return -1;
        }

        ListNode cur = head; // 从头节点开始
        // 判断从头开始遍历还是从尾开始遍历，取决于索引的位置
        if (index >= size / 2) {
            // 如果索引大于链表的中间，逆向从尾部遍历
            cur = tail;
            for (int i = 0; i < size - index; i++) {
                cur = cur.prev;
            }
        } else {
            // 从头节点开始，正向遍历
            for (int i = 0; i <= index; i++) {
                cur = cur.next;
            }
        }
        // 返回节点的值
        return cur.val;
    }

    // 在链表头部添加一个节点
    public void addAtHead(int val) {
        addAtIndex(0, val); // 调用 addAtIndex 方法，在头部插入
    }
    
    // 在链表尾部添加一个节点
    public void addAtTail(int val) {
        addAtIndex(size, val); // 调用 addAtIndex 方法，在尾部插入
    }
    
    // 在指定索引位置插入一个节点
    public void addAtIndex(int index, int val) {
        // 如果索引无效，直接返回
        if (index < 0 || index > size) {
            return;
        }

        ListNode pre = head; // 从头节点开始遍历
        // 遍历到指定位置的前一个节点
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }

        // 创建新节点并插入
        ListNode newNode = new ListNode(val);
        newNode.next = pre.next;       // 新节点的 next 指向 pre 节点的 next
        pre.next.prev = newNode;       // pre 节点的 next 的 prev 指向新节点
        newNode.prev = pre;            // 新节点的 prev 指向 pre
        pre.next = newNode;            // pre 节点的 next 指向新节点

        size++; // 更新链表大小
    }

    // 删除指定索引位置的节点
    public void deleteAtIndex(int index) {
        // 如果索引无效，直接返回
        if (index < 0 || index >= size) {
            return;
        }
        
        ListNode pre = head; // 从头节点开始遍历
        // 遍历到指定位置的前一个节点
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        
        // 删除指定位置的节点
        pre.next.next.prev = pre;      // 删除节点后，更新下一个节点的 prev 指针
        pre.next = pre.next.next;      // 将 pre 节点的 next 指向下一个节点的下一个节点

        size--; // 更新链表大小
    }
}
/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

查看全文

http://www.dtcms.com/a/122662.html