22年32周

目录

1.螺旋矩阵II

2.移除链表元素

3.设计链表

4.反转链表

---

1.螺旋矩阵II

题目链接：螺旋矩阵Ⅱ

这道题并没有麻烦在算法上，而是麻烦在对代码的整体掌控上了，还有就是把整个螺旋矩阵的填充顺序要掌握好，不然就很容易乱套。

func generateMatrix(n int) [][]int {

    result := make([][]int,n)

    for k := range result {
        result[k] = make([]int,n)
    }
   
    left,top := 0,0
    right,bottom := n-1,n-1//左闭右开区间
    register := 1

    for register < n*n {

        for i:=left;i<right && register < n*n;i++ {
            result[top][i] = register
            register++
        }

        for i:=top;i<bottom && register < n*n;i++ {
            result[i][right] = register
            register++
        }

        for i:=right;i>left && register < n*n;i-- {
            result[bottom][i] = register
            register++
        }

        for i:=bottom;i>top && register < n*n;i-- {
            result[i][left] = register
            register++
        }
        top++
        left++
        bottom--
        right--  
    }
    result[top][right] = register

    return result
}

2.移除链表元素

题目链接：移除链表元素

思路：这道题大概有两个思路，实现起来还是第一个思路比较简单一些。第一个思路就是新建一个链表头，之后不等于val值的元素就给他往这个表头后面追加，等于的就不追加。

第二个思路就是，利用递归，其实链表本身我觉得就可以用递归对他进行定义，本身就是符合递归规律的，所以链表的题一般都可以用递归来写，不过思考起来可能没有第一个方案简单，下面是两个方案的代码：

//正常方式
func removeElements(head *ListNode, val int) *ListNode {
   result := &ListNode{}
   rear := result
   for head != nil {
       if head.Val == val {
           head = head.Next
       }else{
           rear.Next = head
           rear = rear.Next
           head = head.Next
           rear.Next = nil
           
       }
   }
   return result.Next
}

//递归方式

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func removeElements(head *ListNode, val int) *ListNode {

    if head == nil {
        return head
    }

    head.Next = removeElements(head.Next,val)//递归到末尾

    if head.Val == val {
        return head.Next
    }
    return head
}

3.设计链表

题目：设计链表

思路：这道题其实思路不难，还是要追求细节，很考验逻辑思维能力

type MyLinkedList struct {
    Val int
    next *MyLinkedList
}


func Constructor() MyLinkedList {
    head := MyLinkedList{0,nil}
    return head//设立头节点
}


func (this *MyLinkedList) Get(index int) int {
    ptr := this
    for index >= 0 {//大于等于零，最终指向的就是第index元素
        index--
        if ptr != nil {
            ptr = ptr.next
        }else {
            return -1
        }
    }
    if ptr == nil {
        return -1
    }
    return ptr.Val
}


func (this *MyLinkedList) AddAtHead(val int)  {

    insert := MyLinkedList{val,this.next}
    this.next = &insert
}


func (this *MyLinkedList) AddAtTail(val int)  {


    ptr := this
    for ptr.next != nil {
        ptr = ptr.next
    }

    ptr.next = &MyLinkedList{val,nil}
}


func (this *MyLinkedList) AddAtIndex(index int, val int)  {

    if index <= 0 {
        this.AddAtHead(val)
    }

    ptr := this
    for index > 0 {//大于零，指向的是第index前面的元素
        index--
        if ptr != nil {
            ptr = ptr.next
        }else {
            return
        }
    }
    
    if ptr == nil {
        this.AddAtTail(val)
        return
    }

    insert := MyLinkedList{val,ptr.next}
    ptr.next = &insert
}


func (this *MyLinkedList) DeleteAtIndex(index int)  {
    if index < 0 || this.next == nil{
        return
    }

    ptr := this
    for index > 0 {
        index--
        if ptr != nil {
            ptr = ptr.next
        }else {
            return
        }
    }

    if ptr.next == nil {
        return
    }

    ptr.next = ptr.next.next
}


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

4.反转链表

题目：反转链表、​​​​​​​

思路：这道题有三个思路

1.利用头插法新建链表，这个链表自然而然就倒置了

2.双指针法，两个两个的进行倒置

3.递归法，只不过是把双指针法进行了一下递归，

具体看代码：

//头插法
func reverseList(head *ListNode) *ListNode {
    newHead := &ListNode{0,nil}
    pre := head
    for head != nil {
        head = head.Next
        pre.Next = newHead.Next
        newHead.Next = pre
        pre = head
    }
    return newHead.Next
}

//双指针法
func reverseList(head *ListNode) *ListNode {
    
    if head == nil {
        return head
    }

    ptr := head
    ptrNext := head.Next
    ptr.Next = nil
    for ptrNext != nil {
        temp := ptrNext.Next
        ptrNext.Next = ptr
        ptr = ptrNext
        ptrNext = temp
    }
    return ptr

}



//递归
func reverseList(head *ListNode) *ListNode {
    return help(nil, head)
}

func help(pre, head *ListNode)*ListNode{
    if head == nil {
        return pre
    }
    next := head.Next
    head.Next = pre
    return help(head, next)
}