【手撕算法】设计链表

1. 设计链表分步解析

1. 自定义链表节点类与初始化
2. 获取指定节点值
3. 链表头插入
4. 链表尾插入
5. 插入指定位置
6. 删除指定节点

• 自定义节点类与初始化

  • Java中自定义节点类的定义：

  public class ListNode {
      int val;
      ListNode next;
      ListNode(){}
  
      ListNode(int val)
      {
          this.val=val;
      }
  }
  

• 链表初始化

      public MyLinkedList() {
          //初始化的链表长度
          size=0;
          //声明链表头
          head=new ListNode(0);
  
      }
  

• 获取指定值

  • 先判断索引是否在合法区间 [0,size]
  • 符合条件，遍历搜索

   public int get(int index) {
  
          if(index<0||index>=size)
          {
              return -1;
          }
          ListNode cur=head;
          for(int i=0;i<=index;i++)
          {
              cur=cur.next;
          }
          return cur.val;
  
      }
  

• 链表的表间插入

  • 这里我们考虑三种插入位置，即头，间，尾

  • 头插入：也就是index索引小于0的情况，视为头插

  • 表间插入：链表size扩容

  • 尾插入：在循环遍历处控制 i<index防止链表越界

        public void addAtIndex(int index, int val) {
            if(index<0)
            {
                index=0;
            }
            if(index>size)
            {
                return;
            }
            
            size++;
            ListNode pre=head;
            
            for(int i=0;i<index;i++)
            {
                pre=pre.next;
            }
            ListNode cur=new ListNode(val);
    
            cur.next=pre.next;
            pre.next=cur;
    
        }
    

• 表头插入

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

• 表尾插入

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

• 删除指定元素

  • 规定索引区间

  • 链表长度减短

  • 执行删除操作

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

2. 完整代码

public class ListNode {
    int val;
    ListNode next;
    ListNode(){}

    ListNode(int val)
    {
        this.val=val;
    }
}
class MyLinkedList {
    int size;
    ListNode head;

    /** Initialize your data structure here. */
    public MyLinkedList() {
        size=0;
        head=new ListNode(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) {

        if(index<0||index>=size)
        {
            return -1;
        }
        ListNode cur=head;
        for(int i=0;i<=index;i++)
        {
            cur=cur.next;
        }
        return cur.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) {
        addAtIndex(0,val);
    }

    /** Append a node of value val to the last element of the linked list. */
    public void addAtTail(int val) {
        addAtIndex(size,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. */
    public void addAtIndex(int index, int val) {
        if(index<0)
        {
            index=0;
        }
        if(index>size)
        {
            return;
        }
        size++;
        ListNode pre=head;
        for(int i=0;i<index;i++)
        {
            pre=pre.next;
        }
        ListNode cur=new ListNode(val);

        cur.next=pre.next;
        pre.next=cur;

    }

    /** Delete the index-th node in the linked list, if the index is valid. */
    public void deleteAtIndex(int index) {

        if(index<0||index>=size)
        {
            return;
        }
        size--;
        ListNode cur=head;
        for(int i=0;i<index;i++)
        {
            cur=cur.next;
        }
        cur.next=cur.next.next;

    }
}