leetcode总结——查找和排序

查找和排序：
二分查找：
旋转数组的最小值
旋转数组的索引值
累快速排序：三色旗：

树查找K，查找K个数
数组查找K，查找K哥数

旋转数组的最小值
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
你可以假设数组中不存在重复元素。

示例 1:
输入: [3,4,5,1,2]
输出: 1

示例 2:
输入: [4,5,6,7,0,1,2]
输出: 0

方法二O（logn）

class Solution {
    public int findMin(int[] nums) {
 
        if(nums[nums.length-1]>=nums[0])return nums[0];
        int mid=nums.length/2;
        int left=0,right=nums.length-1;
        if(nums[nums.length-1]>=nums[0])return nums[0];
        while(left<right){
            if(nums[mid]<nums[mid-1])return nums[mid];
            if(nums[mid]>nums[mid+1])return nums[mid+1];
            if(nums[0]>=nums[mid])right=mid;
            else left=mid+1;
            mid=(left+right)/2;
        }
        return nums[mid];
    }
}

三色旗：
给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
注意:
不能使用代码库中的排序函数来解决这道题。
示例:
输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

解析：三个指针，首尾和当前指针，通过当前指针的值来和首尾进行比较

class Solution {
    public void sortColors(int[] nums) {
        int left=0,right=nums.length,cur=0;
        while(cur<right&&cur<nums.length){
            if(nums[cur]==2){
                swap(nums,cur,--right);}
            else if(nums[cur]==0){
                swap(nums,cur,left);
                cur++;left++;
            }
            else if(nums[cur]==1)cur++;
        }
    }
    public void swap(int[]nums,int a,int b){
        int value=nums[a];
        nums[a]=nums[b];
        nums[b]=value;
    }
}

旋转数组的索引值
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。

示例 1:
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

示例 2:
输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

解析：基于两次比较的二分查找，通过两次比较，将区域分成三个区域

class Solution {
    public int search(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        int start = 0;
        int end = nums.length - 1;
        int mid;
        while (start <= end) {
            mid = start + (end - start) / 2;
            if (nums[mid] == target) {
                return mid;
            }
            //前半部分有序,注意此处用小于等于
            if (nums[start] <= nums[mid]) {
                //target在前半部分
                if (target >= nums[start] && target < nums[mid]) {
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            } else {
                if (target <= nums[end] && target > nums[mid]) {
                    start = mid + 1;
                } else {
                    end = mid - 1;
                }
            }

        }
        return -1;
    }

}

给定一个不为空的二叉搜索树和一个目标值 target，请在该二叉搜索树中找到最接近目标值 target 的数值。
注意：
给定的目标值 target 是一个浮点数
题目保证在该二叉搜索树中只会存在一个最接近目标值的数
示例：
输入: root = [4,2,5,1,3]，目标值 target = 3.714286

    4
   / \
  2   5
 / \
1   3

输出: 4
class Solution {
public int closestValue(TreeNode root, double target) {
double minlength=Double.MAX_VALUE;
int result=0;
while(root!=null){
result=minlength>Math.abs(target-root.val)?root.val:result;
minlength=Math.min(minlength,Math.abs(target-root.val));
if(root.val>target)root=root.left;
else if(root.val<target)root=root.right;
else return root.val;
}
return result;
}
}

给定一个不为空的二叉搜索树和一个目标值 target，请在该二叉搜索树中找到最接近目标值 target 的 k 个值。:
注意：
给定的目标值 target 是一个浮点数
你可以默认 k 值永远是有效的，即 k ≤ 总结点数
题目保证该二叉搜索树中只会存在一种 k 个值集合最接近目标值
示例：
输入: root = [4,2,5,1,3]，目标值 = 3.714286，且 k = 2
4
/
2 5
/
1 3

输出: [4,3]
272

public class Solution {
    public List<Integer> closestKValues(TreeNode root, double target, int k) {
        LinkedList<Integer> res = new LinkedList<>();
        inOrder(root, target, k, res);
        return res;
    }
    private void inOrder(TreeNode root, double target, int k, LinkedList<Integer> res) {
        if(root == null) {
            return;
        }
        inOrder(root.left, target, k, res);
        if(res.size() == k) {
            if(Math.abs(res.get(0) - target) >= Math.abs(root.val - target)) {
                res.removeFirst();
                res.add(root.val);
            } else {
                return;
            }
        } else {
            res.add(root.val);
        }
        inOrder(root.right, target, k, res);
    }
}