程序员成长之路(Day 27)

学习内容：

LintCode刷题：

·查询课程创建时间和教师国籍

        延伸->（SQL的inner join）

Select courses.created_at as course_date,
 teachers.country as teacher_country 
from courses inner join teachers on courses.teacher_id = teachers.id;

·两两交换链表中的节点

        把头拿进来当头或者下一个为空的时候直接返回这个头,注意这里得先写检验头是不是空,因为||是当左边条件为错误时直接跳过右边的,所以当head为空时,head.next是会有异常的，定义一个新头，把原来旧头的next赋值给它,并定义一个新的next,这个next是新链表(调换前两个顺序完)的第三个，这个next也是原第三第四个的旧头，所以把它放到方法里,返回新头连在第二个后面即可。

/**
 * Definition for ListNode
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */

public class Solution {
    
    public ListNode swapPairs(ListNode head) {
        // if(head.next==null||head==null)     报异常
        if(head==null||head.next==null){
            return head;
        }
        ListNode newhead = head.next;
        ListNode next = swapPairs(newhead.next);
        newhead.next=head;
        head.next=next;
        return newhead;
    }
}

·区间最小数

        首先需要创建线段树的节点,然后创建线段树的构造方法,root的min用Integer.Max_VALUE,然后将这个数组不停的放入到这个线段树当中,root的min取左节点和右节点min的最小值(在start和end不相等的时候),在相等时直接等于A中的元素。创建一个查找方法,可以查找到左节点start,和右节点end的root的min值,先定义mid为root的中点,用mid的值在那个范围来进行查询方法的递归,最后利用类Interval拿到start和end值,来遍历传入的queries,用传入的数组A来创建根节点，调用查找方法即可。

import java.util.ArrayList;
import java.util.List;

class Interval {
    int start, end;

    Interval(int start, int end) {
        this.start = start;
        this.end = end;
    }
}

class TreeNode {
    public int start, end, min;
    public TreeNode left, right;

    public TreeNode(int start, int end, int min) {
        this.end = end;
        this.start = start;
        this.min = min;
        this.left=this.right=null;
    }
}

public class Solution {
    public TreeNode build (int start,int end,int[]A){
        if (start>end){
            return null;
        }
        TreeNode root = new TreeNode(start,end,Integer.MAX_VALUE);
        if (start!=end){
            int mid =(start+end)/2;
            root.left =build(start,mid,A);
            root.right=build(mid+1,end,A);
            root.min =Math.min(root.left.min,root.right.min);
        }else{
            root.min =A[start];
        }
        return root;
    }
    public int query(TreeNode root,int start ,int end){
        if (start == root.start && root.end == end){
            return root.min;
        }
        int leftMin =Integer.MAX_VALUE;
        int rightMin =Integer.MAX_VALUE;
        int mid = (root.start+root.end)/2;
        if (start<=mid){
            if (mid<end){
                leftMin =query(root.left,start,mid);
            }else
                leftMin=query(root.left,start,end);
        }
        if (mid<end){
            if (mid>=start){
                rightMin =query(root.right,mid+1,end);}
            else{
                rightMin =query(root.right,start,end);
            }
        }
            return Math.min(leftMin,rightMin);
    }
    public List<Integer> intervalMinNumber(int[] A, List<Interval> queries) {
        TreeNode root = build(0,A.length-1,A);
        List<Integer> ans = new ArrayList<>();
        for (Interval interval:queries){
            ans.add(query(root,interval.start,interval.end));
        }
        return ans;
    }
}

 ·最大值在界内的子数组个数

        定义一个左指针,一个结果,一个拿来数组中符合条件的位置,用右指针++遍历数组,当这个数组中的元素在[L,R]中就可以把结果+=右指针-左指针+1，因为当元素连续的符合[L,R]这个集合,那么，他们满足子数组个数=1+2+3+4+...+n，并且把当前位置记下来,因为如果下个元素小于这个集合,那么它只能单独的加在上一个元素后面,子数组个数只能+1，当元素大于这个集合时，那么就需要重置windows，把左指针指向当前元素的后一个元素即可。

public class Solution {
    public int numSubarrayBoundedMax(int[] A, int L, int R) {
        int left = 0;
        int resultint = 0;
        int windows = 0;
        for(int right =0;right<A.length;right++){
            if (A[right]>=L&&A[right]<=R){
                resultint +=right-left+1;
                windows =right-left+1;
            }else if (A[right]<L)
                resultint+=windows;
            else {
                windows=0;
                left=right+1;
            }
        }
        return resultint;
    }
}

 ·车队

         根据TreeMap的定义会按照传入的Key值自动排序,按照距离终点的距离来实现排序,所以只要统计速度大于上一个速度时,就可以知道有几个车队。

public class Solution {

    public int carFleet(int target, int[] position, int[] speed) {
        // Write your code here
        TreeMap<Integer, Double> m = new TreeMap<>();
        for (int i = 0; i < position.length; ++i) {
            m.put(-position[i], (double)(target - position[i]) / speed[i]);
        }
        int res = 0; double cur = 0;
        for (double time : m.values()) {
            if (time > cur) {
                cur = time;
                res++;
            }
        }
        return res;
    }
}

 

---

学习时间：

2021-9-11 14：00-17：00、19：30-20：10

---

学习产出：

刷题*6

学习博客*1