707. 设计链表

Posted 2022-04-09 yangbocsu

707. 设计链表

• 一、题目
• 二、单链表
• • 复杂度分析
• 三、双链表

---

一、题目

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。 addAtIndex(index,val)：在链表中的第
• index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index
  大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。 deleteAtIndex(index)：如果索引 index
  有效，则删除链表中的第 index 个节点。

二、单链表

// 单链表
class ListNode
    int val;
    ListNode next;
    ListNode()
    ListNode(int val)
        this.val = val;
    


class MyLinkedList 
    int size;       // 存储链表元素的个数
    ListNode head;  // 虚拟头结点

    // 初始化链表
    MyLinkedList() 
        size = 0;
        head = new ListNode(0);
    

    public int get(int index) 
        // 异常处理
        if(index < 0 || index >= size)
            return -1;
        
        ListNode currentNode = head;
        // 包含一个虚拟头节点，所以查找第 index+1 个节点
        for(int i = 0; i <= index; i++)
            currentNode = currentNode.next;
        
        return currentNode.val;
    

    public void addAtHead(int val) 
        addAtIndex(0,val);
    

    public void addAtTail(int val) 
        addAtIndex(size,val);
    

  public void addAtIndex(int index, int val) 

    if (index > size) return;
    if (index < 0) index = 0;

    ++size;

    ListNode pred = head;
    for(int i = 0; i < index; ++i) pred = pred.next;

    // node to be added
    ListNode toAdd = new ListNode(val);
    // insertion itself
    toAdd.next = pred.next;
    pred.next = toAdd;
  


    public void deleteAtIndex(int index) 
        if(index < 0 || index >=size)
            return ;
        
        size --;
        ListNode pre = head;
        for(int i = 0; i < index; i++)
            pre = pre.next;
        
        pre.next = pre.next.next;

    




/**
 * 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);
 */

复杂度分析

时间复杂度:
空间复杂度：

---

三、双链表

// 双链表
class ListNode
    int val;
    ListNode next;
    ListNode pre;
    // ListNode()
    ListNode(int val)
        this.val = val;
    


class MyLinkedList
    int size;
    ListNode head,tail;
    MyLinkedList()
        size = 0;
        head = new ListNode(0);
        tail = new ListNode(0);
        head.next = tail;
        tail.pre = head;
    

    // 获取指定index上的值
    public int get(int index)
        if (index < 0 || index >= size)
            return -1;
        
        ListNode curr = head;
        // 通过比较 index 和 size - index 的大小判断从头开始较快还是从尾巴开始较快
        if (index + 1  < size - index)  
            for (int i = 0; i < index +1; i++)      // 从头开始遍历比较快
                curr = curr.next;
            
        else  // 从尾开始遍历比较快
            curr = tail;
            for (int i = 0; i < size - index; i++) 
                curr = curr.pre;
            
        
        return curr.val;
    
    // 头部插入
    public void addAtHead(int val)
        size ++;

        ListNode pred = head;
        ListNode succ = head.next;

        ListNode tmp = new ListNode(val);
        tmp.next = succ;
        tmp.pre = pred;
        pred.next = tmp;
        succ.pre = tmp;
    

    // 尾部插入
    public void addAtTail(int val)
        
        ListNode succ = tail;
        ListNode pred = tail.pre;

        ListNode tmp = new ListNode(val);
        tmp.next = succ;
        tmp.pre = pred;
        pred.next = tmp;
        succ.pre =tmp;
        size++;
    

    // 在指定index 上插入
    public void addAtIndex(int index,int val)
        if (index > size)
            return;
        
        if (index < 0)
            index = 0;
        

        ListNode pred = head;
        ListNode succ = tail;
        if (index  < size -index)//通过比较 index 和 size - index 的大小判断从头开始较快还是从尾巴开始较快。
            for (int i = 0; i < index ; i++) //从头部开始插入
                pred = pred.next;
            
            succ = pred.next;       //先找到前继，再通过前继.next = 后继
        else                                  //从尾部开始插入
            succ = tail;
            for (int i = 0; i < size - index; i++) 
                succ = succ.pre;
            
            pred = succ.pre;
        
        ListNode tmp = new ListNode(val);
        tmp.next = succ;
        tmp.pre = pred;
        pred.next = tmp;
        succ.pre = tmp;
        ++size;
    

    // 从指定的index 删除
    public void deleteAtIndex(int index)
        if (index < 0 || index >= size)
            return;
        

        ListNode pred = head;
        ListNode succ = tail;
        // 找到index 位置的前
        if (index < size - index)
            for (int i = 0; i < index; i++) 
                pred = pred.next;
            
            succ = pred.next.next;
        else
            for (int i = 0; i < size - index - 1; i++) 
                succ = succ.pre;
            
            pred = succ.pre.pre;
        

        // 开始删除元素
        pred.next = succ;
        succ.pre = pred;
        size --;