代码随想录训练营day3打卡

问题一：设计链表

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

单链表中的节点应该具备两个属性：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]

思路：Leetcode内置了ListNode节点，也可以自己声明

type ListNode struct{
	Val int
    Next *ListNode
}

思路模拟题，主要核心抓住构造形式，ListNode是结构体变量，MyLinkedList是类以及一批类的属性方法

第一，这个类维护一个dummy 虚拟头指针 + 链表长度变量

其次，就是两个indexadd 和indexdelete的函数的实现，以及每次实现完毕后cnt要++ 或者-- 操作

最后，就是每次的add、delete操作需要判断是否超过cnt 或者小于cnt变量

代码：

//
type MyLinkedList struct {
    dummy *ListNode
    cnt int
}

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


func (this *MyLinkedList) Get(index int) int {
    	if index < 0 || index >= this.cnt {return -1}
        cur := this.dummy.Next
        for i:=0;i < index ;i++{
            cur = cur.Next
        }
        return cur.Val
}   


func (this *MyLinkedList) AddAtHead(val int)  {
	    this.AddAtIndex(0, val)
}


func (this *MyLinkedList) AddAtTail(val int)  {
	    this.AddAtIndex(this.cnt, val)
}


func (this *MyLinkedList) AddAtIndex(index int, val int)  {
	if index > this.cnt {return }
	pre := this.dummy
	for  i:=0;i < index ;i++{
		pre = pre.Next
	}
	pre.Next = &ListNode{val, pre.Next}
	this.cnt++
}


func (this *MyLinkedList) DeleteAtIndex(index int)  {
	if index < 0 || index >= this.cnt {return }
	pre := this.dummy
	for i:=0;i < index ;i++ {
		pre = pre.Next
	}
	pre.Next = pre.Next.Next
	this.cnt--
}


/**
 * Your MyLinkedList object will be instantiated and called as such:
 * obj := Constructor();
 * param_1 := obj.Get(index);
 * obj.AddAtHead(val);
 * obj.AddAtTail(val);
 * obj.AddAtIndex(index,val);
 * obj.DeleteAtIndex(index);
 */

问题二：203. 移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

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

思路：

迭代：这题的难点在于首节点，头节点如果是待删除元素的话即时知道删除下下一个元素也是不够的。

所以创建一个虚拟节点，判断当前节点的下一个元素是否是可操作元素就可以把头节点按照相同方式进行操作了，否则就得对头节点进行单独处理。

递归：递归的思路非常精巧，这也是我一直以来对递归了解的不够深刻的原因，递归的思想在于不断使用相同的操作，知道遇见终止条件，与其说递归式一个栈，更具体而言，递归是一个入栈到终止条件再不断出栈的过程。

也就是将所有的链表元素全部都压进栈中，直到nil，然后开始递归判断，如果当前的cur.val是等于val的，那么就跳过这个节点。

代码：

//递归
func removeElements(point *ListNode, val int) *ListNode {

    if point == nil{return point;}

    point.Next = removeElements(point.Next,val)
    if point.Val == val{ return point.Next}
    return point
}
//迭代
func removeElements(head *ListNode, val int) *ListNode {
    DummyNode:=&ListNode{Next:head}

    cur := DummyNode;
    for cur.Next !=nil{
        if cur.Next.Val == val{
            cur.Next = cur.Next.Next
        }else{
            cur = cur.Next      //切记是if else      
        }

    }
    return DummyNode.Next
}
*/

问题三：206. 反转链表

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

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

思路：巧用dummy节点，两个指针不断调节，再来一个tem指针进行暂存即可

代码：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
    if head == nil || head.Next ==nil { return head}
    dummyNode:= &ListNode{Next:head}
    cur := dummyNode.Next
    pre := dummyNode
    for cur.Next !=nil{
        tem:= cur.Next
        cur.Next = tem.Next
        tem.Next = pre.Next
        pre.Next = tem
    }
    return dummyNode.Next
}