这道题和三数之和非常相似，稍微修改一下中间的逻辑就可以直接过了。

    题目：

    1. 给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
    5. 示例：
    7. 输入：nums = [-1,2,1,-4], target = 1
    8. 输出：2
    9. 解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
    12. 提示：
    14. 3 <= nums.length <= 10^3
    15. -10^3 <= nums[i] <= 10^3
    16. -10^4 <= target <= 10^4

    思路：
    与三数之和一样，先对数组进行排序，接着把三个数中的一个固定，然后双指针移动另外两个数，不断的向target靠近，最后就能得出答案；当然，中间也要考虑去重，这里的去重主要是考虑到执行时间，理论上不进行去重对最终结果也没有影响。

    1. /*
    2.  * @lc app=leetcode.cn id=16 lang=golang
    3.  *
    4.  * [16] 最接近的三数之和
    5.  */
    7. // @lc code=start
    8. func threeSumClosest(nums []int, target int) int {
    9.     var index int
    10.     n := len(nums)
    11.     minDiff := math.MaxInt32
    12.     quickSort(nums) //先进行排序，固定一个值
    13.     // fmt.Println(nums)
    14.     update := func(cur int) {
    15.         if abs(cur-target) < abs(minDiff-target) {
    16.             minDiff = cur
    17.         }
    18.     }
    19.     for index = 0; index < n; index++ { //这里要从0开始,与三数之和不同
    20.         // head, tail := 0, len(nums)-1 //每次都从0到length-1
    21.         if index > 0 && nums[index] == nums[index-1] {
    22.             continue
    23.         }
    24.         left, right := index+1, n-1
    25.         for left < right {
    26.             sum := nums[index] + nums[left] + nums[right]
    27.             if sum == target {
    28.                 return target
    29.             }
    30.             update(sum)
    31.             if left > index+1 && left < n && nums[left] == nums[left-1] {
    32.                 left++
    33.                 continue
    34.             }
    35.             if right < n-1 && right > left && nums[right] == nums[right+1] {
    36.                 right--
    37.                 continue
    38.             }
    39.             if sum > target {
    40.                 right--
    41.             } else {
    42.                 left++
    43.             }
    44.         }
    45.     }
    46.     return minDiff
    47. }
    49. func quickSort(nums []int) {
    50.     if len(nums) < 2 {
    51.         return
    52.     }
    53.     head, tail := 0, len(nums)-1
    54.     reference := nums[0]
    55.     i := 1
    56.     for head < tail {
    57.         if nums[i] < reference {
    58.             nums[i], nums[head] = nums[head], nums[i]
    59.             i++
    60.             head++
    61.         } else {
    62.             nums[i], nums[tail] = nums[tail], nums[i]
    63.             tail--
    64.         }
    65.     }
    66.     quickSort(nums[:head])
    67.     quickSort(nums[head+1:])
    68. }
    70. func abs(x int) int {
    71.     switch {
    72.     case x == 0:
    73.         return 0
    74.     case x < 0:
    75.         return -1 * x
    76.     }
    77.     return x
    78. }
    80. // @lc code=end