力扣Day32

540、有序数组中的单一元素 

给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。你设计的解决方案必须满足 O(log n) 时间复杂度和 O(1) 空间复杂度。

 题目分析：1.有序数组 2.时间复杂度为O(logn）————二分查找

通过示例可以发现：单一数他的下标一定是偶数的。

class Solution {
    public int singleNonDuplicate(int[] nums) {
        //单一数的下标一定是偶数
        int left=0,right=nums.length-1;
        while(left<right){       //left<=right 会超出数组索引范围
            int mid=left+(right-left)/2;
            if(nums[mid]==nums[mid-1]){//中点跟左边的相等
                if((mid-left)%2==0){//mid的左边还有偶数个元素，而单一数的下标是偶数的，说明单一数可能存在在这里面
                    right=mid-2;//-2是排除掉nums[mid-1]这个元素，因为nums[mid]==nums[mid-1]
                }else{
                    left=mid+1;//如果mid左边只有奇数个元素，则直接去另外一侧去查找
                }
            }else if(nums[mid]==nums[mid+1]){//中点跟右边的相等
                if((right-mid)%2==0){//mid的右边有偶数个元素，说明单一数可能存在在这里面
                    left=mid+2;//+2是排除掉nums[mid+1]这个元素，因为nums[mid]=nums[mid+1]
                }else{
                    right=mid-1;
                }
            }else{
                return nums[mid];
            }
        }
        return nums[left];
    }
}

541、反转字符串 II

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

• 如果剩余字符少于 k 个，则将剩余字符全部反转。
• 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

1.字符串的字符反转要将字符串转成数组

2.从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。 使用下面for循环的思维，不要用

int count=1;
for(int i=0;i<2*k;i++){
    if(count==2*k){
        sb.reverse();
    }
    count=count*2;
    sb.append(s.charAt(i));
}

使用这个思路==>for (int i = 0; i < n; i =i + 2 * k) {          //学习这个for循环
                                    reverse(arr, i, Math.min(i + k, n) - 1);
                           }

3.这里的Math.min是为了判断    如果剩余字符少于 k 个，则将剩余字符全部反转。

class Solution {
    public String reverseStr(String s, int k) {
        int n = s.length();
        char[] arr = s.toCharArray();
        for (int i = 0; i < n; i =i + 2 * k) {//学习这个for循环
            reverse(arr, i, Math.min(i + k, n) - 1);
        }
        return new String(arr);
    }

    public void reverse(char[] arr, int left, int right) {
        while (left < right) {
            char temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
}

543、二叉树的直径

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

该二叉树的最长直径是4-2-1-3/5-2-1-3

 该二叉树的最长直径可以是8-7-5-2-1-3  返回5

 即：就出左右结点的最大深度，并相加就是最长直径

如果maxLength函数终止条件3返回的是return max；因为max取决于left+right，如果return max，那right和left只要有递归，他们就一直在变化（时刻在变化）【例子：4的left=1,9的left=0，那么闲return left=1，后面就变成left=0了】那max也一直在变化。应该是

return Math.max(left,right)+1，用max来固定住left和right的长度，这样max也就会固定住了。

如果return max，那么递归的时候就会把max的值赋给了int left和int right 。逻辑上是错的，因为max是left+right。left应该是左子树的长度，而不是左子树+右子树（left+right）的长度

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int max=0;
    public int diameterOfBinaryTree(TreeNode root) {
        if(root==null) return 0;
        maxLength(root);
        return max;
    }
    public int maxLength(TreeNode root){
        if(root==null) return 0;//终止条件1
        if(root.left==null&root.right==null) return 1;//终止条件2
        //单层逻辑的递归，结束递归的时候，return终止条件2,3都会用的到。
        //如果终止条件3的return是 return max，那就错了。外面说
        int left=maxLength(root.left);//通过递归算出根结点root的左子树的深度
        int right=maxLength(root.right);
        max=Math.max(left+right,max);
        return Math.max(left,right)+1;//终止条件3


    }
}