class MyLinkedList {
    private ListNode head;
    int size;
    private static class ListNode{
        int val;
        ListNode next;
        ListNode(int val){
            this.val =val;
            this.next = null;
        }
        ListNode(){}
    }
    public MyLinkedList() {
        size=0;
        head =new ListNode(-1);
    }

    public int get(int index) {
        if(index>=size|| index<0){
            return -1;
        }
        ListNode current=head;
        int i=0;

        while(i<=index){
            current = current.next;
            i++;
        }
        return current.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;
        }
         index = Math.max(0, index);
        int i=0;
        size++;
        ListNode newNode=new ListNode(val);
        ListNode current=head;
        while(i<index){
           i++;
            current=current.next;
       }
       newNode.next=current.next;
       current.next=newNode;
    }

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

    }
}

type ListNode struct {
	Val  int
	Next *ListNode
}

type MyLinkedList struct {
	head *ListNode
	size int
}

func Constructor() MyLinkedList {
	return MyLinkedList{&ListNode{}, 0}
}

func (l *MyLinkedList) Get(index int) int {
	if index < 0 || index >= l.size{
		return -1
	}
	current := l.head
	for i:=0;i<=index;i++{
		current = current.Next
	}
	return current.Val
}
func (l*MyLinkedList)AddAtHead(val int){
	l.AddAtIndex(0,val)
}
func (l*MyLinkedList)AddAtTail(val int){
	l.AddAtIndex(l.size,val)
}
func (l*MyLinkedList)AddAtIndex(index, val int){
	if index > l.size{
		return 
	}
	index =max(index,0)	
	//if index < 0 {
	//	index = 0
	//}
	current :=l.head
	for i:=0;i<index;i++{
		current = current.Next
	}
	l.size++
	 toAdd := &ListNode{val, current.Next}
	//toAdd.Next=current.Next
	current.Next=toAdd
}
func (l*MyLinkedList) DeleteAtIndex(index int){
	if index >=l.size || index <0{
		return 
	}
	current :=l.head
	for i:=0;i<index;i++{
		current=current.Next
	}
	l.size--
	current.Next=current.Next.Next
}

func max(a, b int) int {
    if b > a {
        return b
    }
    return a
}

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeNthFromEnd(head *ListNode, n int) *ListNode {
    demmyHead := &ListNode{0,head}
    fast,slow := demmyHead,demmyHead
    f :=0
    for f < n {
        f++
        fast=fast.Next
    }
    for fast.Next!=nil {
        fast=fast.Next
        slow=slow.Next
    }
    slow.Next=slow.Next.Next
    return demmyHead.Next
}

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。