设计链表（单链表、双链表）

//单链表
class ListNode{
	int val;
	ListNode next;
	public ListNode(int val) {
		this.val=val;
	}
}
class MyLinkedList {
      int size;//链表长度
      ListNode head;//虚拟头节点：这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点

      //初始化链表
    public MyLinkedList() {
      size=0;
      head=new ListNode(0);
    }
    
    //获取链表中第 index 个节点的值
    public int get(int index) {
      //如果索引无效，则返回-1
      if(index<0 || index>=size) {
          return -1;
      }
      ListNode cur=head;//辅助节点，因为头节点不能移动
      //包含一个虚拟头节点，所以查找第 index+1 个节点
      for(int i=0;i<index+1;i++) {
           cur=cur.next;
      }
      return cur.val;
    }
    
    //在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点
    public void addAtHead(int val) {
      addAtIndex(0,val);
    }
    
    //将值为 val 的节点追加到链表的最后一个元素
    public void addAtTail(int val) {
      addAtIndex(size,val);
    }

    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {
      //如果 index 大于链表的长度，则返回空
      if(index>size) {
        return;
      }
      if(index<0) {
        index=0;
      }
      size++;

      //查找要添加的节点的前置节点
       ListNode temp=head;
       for(int i=0;i<index;i++) {
         temp=temp.next;
       }
      
      //此时有三种情况：
      //1.例如index为0，那么新插入的节点为链表的新头节点（头部插入） 
      //2.在链表的中间某一位置插入
      //3.在链表的尾部插入
      
      // 插入到链表中，temp的后面
	  //假如temp后面是6号，temp.next指向6号，
	  //现在node要插入，则node.next指向6号,所以node.next=temp.next;
      ListNode toAdd = new ListNode(val);
        toAdd.next = temp.next;
        temp.next = toAdd;
    }
    public void deleteAtIndex(int index) {
          if (index < 0 || index >= size) {
              return;
          }
          size--;
          ListNode temp= head;
          for (int i = 0; i < index; i++) {
              temp = temp.next;
          }
          temp.next = temp.next.next;
    }
}


//双链表
class ListNode {
	int val;
	ListNode next;// 指向下一个节点的指针
	ListNode prev;// 指向前一个节点的指针

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

class MyLinkedList {
	int size;
	ListNode head, tail;

	// 链表初始化
	public MyLinkedList() {
		size = 0;// 链表长度
		head = new ListNode(0);// 创建虚拟头结点
		tail = new ListNode(0);// 创建虚拟尾节点

		// 将头尾节点相连
		head.next = tail;
		tail.prev = head;
	}

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

		// 选择最快的方法:
		ListNode cur = head;// 设置临时节点
		if (index + 1 < size - index) {// 从头部移动
			for (int i = 0; i < index + 1; i++) {// 因为有头节点，因此i<index+1
				cur = cur.next;
			}
		} else {// 或者从尾部移动
			cur = tail;// 将临时节点等于尾节点
			for (int i = 0; i < size - index; i++) {
				cur = cur.prev;
			}
		}
		return cur.val;
	}

	// addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。
	// 插入后，新节点将成为链表的第一个节点。
	public void addAtHead(int val) {
		ListNode pred = head;// 设置临时节点
		ListNode succ = head.next;// 假设succ是链表的第一个元素

		size++;// 添加一个元素，数组长度+1
		ListNode toAdd = new ListNode(val);// 要添加的节点
		toAdd.prev = pred;
		toAdd.next = succ;
		pred.next = toAdd;
		succ.prev = toAdd;
	}

	// addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
	public void addAtTail(int val) {
		ListNode succ = tail;// 设置临时节点
		ListNode pred = tail.prev;// 假设succ是链表的最后一个元素

		size++;// 添加一个元素，数组长度+1
		ListNode toAdd = new ListNode(val);// 要添加的节点
		toAdd.prev = pred;
		toAdd.next = succ;
		pred.next = toAdd;
		succ.prev = toAdd;
	}

	// addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。
	// 如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。
	// 如果index小于0，则在头部插入节点。
	public void addAtIndex(int index, int val) {
		if (index > size) {
			return;
		}
		if (index < 0) {
			index = 0;
		}
		ListNode pred, succ;// 设置临时节点，pred最后成为要加入节点的前置节点，succ最后成为要加入节点的后置节点
		// 选择最快的方法:
		if (index < size - index) {// 从头部移动
			pred = head;
			for (int i = 0; i < index; i++) {
				pred = pred.next;// 要加入节点的前置节点
			}
			succ = pred.next;// 要加入节点的后置节点

		} else {// 或者从尾部移动
			succ = tail;
			for (int i = 0; i < size - index; i++) {
				succ = succ.prev;// 要加入节点的后置节点
			}
			pred = succ.prev;// 要加入节点的前置节点
		}

		size++;// 添加一个元素，数组长度+1
		ListNode toAdd = new ListNode(val);// 要添加的节点
		toAdd.prev = pred;
		toAdd.next = succ;
		pred.next = toAdd;
		succ.prev = toAdd;

	}

	// deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
	public void deleteAtIndex(int index) {
		if (index < 0 || index >= size) {
			return;
		}

		// 如果索引 index 有效
		ListNode pred, succ;// 设置临时节点，pred最后成为要加入节点的前置节点，succ最后成为要加入节点的后置节点
		// 选择最快的方法:
		if (index < size - index) {// 从头部移动
			pred = head;
			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.prev;// 要加入节点的后置节点
			}
			pred = succ.prev.prev;// 要加入节点的前置节点
		}
		size--;
		pred.next = succ;
		succ.prev = pred;

	}

}