CodeTop day3

class Solution {
    public int[] sortArray(int[] nums) {
        //这种方法超时【快速排序】
        for (int i=0;i<nums.length-1;i++){
            int minIndex = i;//假设当前开始下标为最小元素下标
            for (int j=i+1;j<nums.length;j++){
                //从i到nums。length-1区间里找到最小值下标
                if (nums[j]<nums[minIndex]) minIndex = j;
            }
            //交换i和真正的minIndex元素
            int temp = nums[i];
            nums[i] = nums[minIndex];
            nums[minIndex] = temp;
        }
        return nums;
    }
}

class Solution {
    public int[] sortArray(int[] nums) {
        //插入排序，但是效率比较低
        for (int i=1;i<nums.length;i++){
            int temp = nums[i];
            int tempIndex = i;
            //如过当前下标之前的元素大于当前值，则之前的元素后移，插入当前元素
            while(tempIndex>0 && nums[tempIndex-1]>temp){
                nums[tempIndex] = nums[tempIndex-1];
                tempIndex--;
            }
            nums[tempIndex] = temp;
        }
        return nums;
    }
}

class Solution {
    public int[] sortArray(int[] nums) {
        quickSort(nums,0,nums.length-1);
        return nums;

    }
    private void quickSort(int[] nums, int left, int right){
       //测试用例通过了，但是耗时太长，不应该选择最左边，应该随机选择
        if (right==left) return;
        //pivot[左边放小的，右边放大的，左右指标相等时放pivot]
        //int pIndex = rand(right-left+1) + left;
        int pivot = nums[left];
        int l = left;
        int r = right;
        while(l<r){

            //先看右边
            while(l<r && nums[r]>=pivot) r--;
            if (l<r && nums[r]<pivot){
                nums[l] = nums[r]; 
                l++;
            }
            //再看左边
            while(l<r && nums[l]<=pivot) l++;
            if (l<r && nums[l]>pivot){
                nums[r] = nums[l];
                r--;
            }
            if (l==r){
                nums[l] = pivot;
                break;
            }
        }
        if (left<l){
            quickSort(nums,left,l-1);
        }
        if (right>l){
            quickSort(nums,l+1,right);
        }
        
    }

}

class Solution {
    public int[] sortArray(int[] nums) {
        quickSort(nums,0,nums.length-1);
        return nums;

    }
    private void quickSort(int[] nums, int left, int right){
        if (right==left) return;
        //pivot[左边放小的，右边放大的，左右指标相等时放pivot]
        int pIndex = (right+left)/2;
        int pivot = nums[pIndex];
        int l = left;
        int r = right;
       do{
            //先看右边
            while(nums[r]>pivot) r--;
            //再看左边
            while(nums[l]<pivot) l++;
            //这是存在左右都不满足条件
            //交换两个元素位置
            if (l<=r){
                int temp = nums[r];
                nums[r] = nums[l];
                nums[l] = temp;
                l++;
                r--;
            }
        }while(l<=r);
        
            if (left<r) quickSort(nums,left,r);
            
            if (right>l) quickSort(nums,l,right);
    }

}

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if (list1==null){
            return list2;
        }else if (list2==null){
            return list1;
        }else if (list1.val<=list2.val){
            list1.next = mergeTwoLists(list1.next,list2);
            return list1;
        }else{
            list2.next = mergeTwoLists(list2.next,list1);
            return list2;
        }
    }
}

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];
        HashMap<Integer,Integer> map = new HashMap<>();
        for (int i=0;i<nums.length;i++){
            if (map.containsKey(target-nums[i])){
                result[0] = i;
                result[1] = map.get(target-nums[i]);
                return result;
            }
            map.put(nums[i],i);
        }
        return result;
    }
}

class Solution {
    public String longestPalindrome(String s) {
        int left = 0;
        int right = 0;
        int cur = 0;
        int len = 1;
        int result = 0;
        int maxStart = 0;
        for (int i=0;i<s.length();i++){
            left = i-1;
            right = i+1;
            while(left>=0 && s.charAt(left)==s.charAt(i)){
                len++;
                left--;
            }
            while(right<s.length() && s.charAt(i)==s.charAt(right)){
                len++;
                right++;
            }
            while(left>=0 && right<s.length() && s.charAt(right)==s.charAt(left)){
                len += 2;
                left--;
                right++;
            }
            if (len>result){
                result = len;
                maxStart = left;
            }
            len = 1;
        }
        return s.substring(maxStart+1,maxStart+result+1);
    }
}

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root==null) return result;
        Deque<TreeNode> que = new LinkedList<>();
        que.add(root);
        while(!que.isEmpty()){
            List<Integer> path = new ArrayList<>();
            int size = que.size();
            for (int i=0;i<size;i++){
                TreeNode node = que.poll();
                path.add(node.val);
                if (node.left!=null){
                    que.add(node.left);
                }
                if (node.right!=null){
                    que.add(node.right);
                }
            }
            result.add(path);
        }
        return result;
    }
}