leetcode刷题-go（二）

leetcode21 合并两个有序链表

描述：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
此题为简单题，没什么需要讲的，主要是为了熟悉go的代码。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func mergeTwoLists(list1 *ListNode, list2 *ListNode) *ListNode {
	head := new(ListNode)
	head1 := head
	for list1 != nil && list2 != nil{
		if list1.Val >= list2.Val{
			node := list1
			list1 = list1.Next
			head1.Next = node
		}else{
			node := list2
			list2 = list2.Next
			head1.Next = node
		}
		head1 = head1.Next
	}
	
	for list1 != nil{
		node := list1
		list1 = list1.Next
		head1.Next = node
		head1 = head1.Next
	}
	
	for list2 != nil{
		node := list2
		list2 = list2.Next
		head1.Next = node
		head1 = head1.Next
	}
	
	head1.Next = nil
	return head.Next
}

leetcode94 二叉树的中序遍历

	给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

题意比较简单，采用递归的话也就几行代码。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */


func inorderTraversal(root *TreeNode) (res []int) {
    var inorder func(node *TreeNode)
	inorder = func(node *TreeNode) {
		if node == nil {
			return
		}
		inorder(node.Left)
		res = append(res, node.Val)
		inorder(node.Right)
	}
	inorder(root)
	return
}

leetcode 101 对称二叉树

	给你一个二叉树的根节点 root ， 检查它是否轴对称。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSymmetric(root *TreeNode) bool {
    if root == nil{
        return true
    }
    var _isSymmetric func(node1, node2 *TreeNode)bool

    _isSymmetric = func(node1, node2 *TreeNode)bool{
        if node1 == nil && node2 == nil{
            return true
        }else if node1 == nil || node2 == nil{
            return false
        }else if node2.Val != node1.Val{
            return false
        }else{
            return _isSymmetric(node1.Left, node2.Right) && _isSymmetric(node1.Right, node2.Left)
        }
    }
    return _isSymmetric(root.Left, root.Right)
}

leetcode 104 二叉树的最大深度

	给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

3 
/ \
9  20
	/  \
	15   7

返回它的最大深度 3 。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func max(a, b int)int{
    if a > b{
        return a
    }else{
        return b
    }
}

func maxDepth(root *TreeNode) int {
    if root == nil{
        return 0
    }else{
        return max(maxDepth(root.Left), maxDepth(root.Right)) + 1
    }
}

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

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func hasCycle(head *ListNode) bool {
    if head == nil || head.Next == nil{
        return false
    }else{
        slow, fast := head, head.Next
        for slow != nil && fast != nil && slow != fast{
            slow = slow.Next
            fast = fast.Next
            if fast!= nil{
                fast = fast.Next
            }
        }
        return slow == fast
    }
}