将字符串转化成整数

题目描述

实现函数 atoi 。函数的功能为将字符串转化为整数

提示：仔细思考所有可能的输入情况。这个问题没有给出输入的限制，你需要自己考虑所有可能的情况。

示例1

输入

1
"123"

返回值

1
123

输入

1
"123a4"

返回值

1
123
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import java.util.*;


public class Solution {

    public int atoi (String str) {
        // 处理空字符串
        // 忽略前置空格
        // 保存符号
        // 处理非法输入
        // 处理溢出
        if (str == null || str.trim().length() < 1)
            return 0;
        //处理掉前后空格
        char[] arr = str.trim().toCharArray();
 
        int sign = 1, index = 0;
        //判断正负号
        if (arr[0] == '+'){
            index++;
        }else if (arr[0] == '-') {
            sign = -1;
            index++;
        }
 
        int num = 0;
        for (int i = index; i < arr.length; i++) {
            if (Character.isDigit(arr[i])) {
                //如果当前运算会越界的时候，直接输出结果
                if(Integer.MAX_VALUE/10 - num < arr[i]-'0'){
                    if (sign > 0)
                        return Integer.MAX_VALUE;
                    else
                        return Integer.MIN_VALUE;
                }
                // 没有溢出
                num = 10 * num + arr[i] - '0';
            } else
                //如果是字母，跳出循环,不再继续算
                break;
        }
 
        return num * sign;
    }
}

展开全文 >>

字符串相乘

43. 字符串相乘

难度中等631

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

示例 1:

1
2
输入: num1 = "2", num2 = "3"
输出: "6"

示例 2:

1
2
输入: num1 = "123", num2 = "456"
输出: "56088"

说明：

  1. num1 和 num2 的长度小于110。
  2. num1 和 num2 只包含数字 0-9。
  3. num1 和 num2 均不以零开头，除非是数字 0 本身。
  4. 不能使用任何标准库的大数类型（比如 BigInteger）或直接将输入转换为整数来处理。

Imgur

优雅写法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public String multiply(String num1, String num2) {
    int m = num1.length(), n = num2.length();
    int[] pos = new int[m + n];
   
    for(int i = m - 1; i >= 0; i--) {
        for(int j = n - 1; j >= 0; j--) {
            int mul = (num1.charAt(i) - '0') * (num2.charAt(j) - '0'); 
            int p1 = i + j, p2 = i + j + 1;
            int sum = mul + pos[p2];

            pos[p1] += sum / 10;
            pos[p2] = (sum) % 10;
        }
    }  
    
    StringBuilder sb = new StringBuilder();
    for(int p : pos) if(!(sb.length() == 0 && p == 0)) sb.append(p);
    return sb.length() == 0 ? "0" : sb.toString();
}

展开全文 >>

问号和星号通配符匹配

题目描述

请实现支持’?’and’*’.的通配符模式匹配

‘?’ 可以匹配任何单个字符。
‘*’ 可以匹配任何字符序列（包括空序列）。

返回两个字符串是否匹配

函数声明为：

bool isMatch(const char *s, const char *p)

下面给出一些样例：

isMatch(“aa”,”a”) → false
isMatch(“aa”,”aa”) → true
isMatch(“aaa”,”aa”) → false
isMatch(“aa”, “*”) → true
isMatch(“aa”, “a*”) → true
isMatch(“ab”, “?*”) → true
isMatch(“aab”, “dab”) → false

示例1

输入

1
"ab","?*"

返回值

1
true

动态规划

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class Solution {
    public boolean isMatch(String s, String p) {
        //初始化
        int m = s.length();
        int n = p.length();
        boolean[][] dp = new boolean[m + 1][n + 1];
   		// 当p和s都为空的时候
        dp[0][0] = true;
        
        
        for (int j = 1; j <= n; j++) {
            if (dp[0][j - 1]) {
                if (p.charAt(j - 1) == '*') {
                    dp[0][j] = true;
                } else {
                    break;
                }
            }
        }
 
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                // 如果当前的字符匹配或者当前p的字符是？那么问题转化为子问题dp[i-1][j-1]
                if (s.charAt(i - 1) == p.charAt(j - 1) || p.charAt(j - 1) == '?')
                    dp[i][j] = dp[i - 1][j - 1];
                if (p.charAt(j - 1) == '*')
                    //也可以这么写，但其实只要dp[i][j]为真，那么dp[i+1][j]一定为真，也就说dp[i][j]其实已经被dp[i+1][j]包含了
                    //dp[i + 1][j + 1] = dp[i][j] || dp[i + 1][j] || dp[i][j + 1];
                    // 如果当前匹配串的字符是*          "aa", "a*"
                    // 如果匹配第一个字符串的一个到多个字符,转移到dp[i-1][j]
                    // 如果匹配第一个字符串的0个字符,转移到dp[i][j-1]
                    dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
            }
        }
        return dp[m][n];
    }
}

展开全文 >>

设计getMin功能的栈

题目描述

实现一个特殊功能的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作。

示例1

输入

1
[[1,3],[1,2],[1,1],[3],[2],[3]]

返回值

1
[1,2]

备注:

1
2
3
4
5
有三种操作种类，op1表示push，op2表示pop，op3表示getMin。你需要返回和op3出现次数一样多的数组，表示每次getMin的答案

1<=操作总数<=1000000
-1000000<=每个操作数<=1000000
数据保证没有不合法的操作

双栈

  • 普通栈保存所有的数字

  • 最小栈保存当前最小的数字

最小栈入栈规则：

如果当前的栈为空，那么入栈

  • 如果当前的数字大于栈顶元素，不入栈

  • 如果当前的数字小于等于栈顶元素，入栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.*;
public class Solution {
    public int[] getMinStack (int[][] op) {
        Deque<Integer> minStack = new LinkedList<>();
        Deque<Integer> stack = new LinkedList<>();
        List<Integer> res = new ArrayList<>();
        for(int []operate:op){
            if(operate[0]==1){
                int val = operate[1];
                stack.push(val);
                if(!minStack.isEmpty()&&minStack.peek()>=val){
                    // 注意哦,这里一定是大于等于,不然就会导致最小值获取不正确
                    minStack.push(val);
                }else if(minStack.isEmpty()){
                    minStack.push(val);
                }
            }else if(operate[0]==2){
                int val=stack.pop();
                if(!minStack.isEmpty()&&minStack.peek()==val){
                    minStack.pop();
                }
            }else{
                res.add(minStack.peek());
            }
        }
        return res.stream().mapToInt(Integer::intValue).toArray();
    }
}

155. 最小栈

难度简单893

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

  • push(x) —— 将元素 x 推入栈中。
  • pop() —— 删除栈顶的元素。
  • top() —— 获取栈顶元素。
  • getMin() —— 检索栈中的最小元素。

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

提示：

  • pop、top 和 getMin 操作总是在 非空栈 上调用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class MinStack {
    Deque<Integer> minStack = null;
    Deque<Integer> stack = null;
    /** initialize your data structure here. */
    public MinStack() {
        minStack = new LinkedList<>();
        stack = new LinkedList<>();
    }
    
    public void push(int val) {
        stack.push(val);
        if(!minStack.isEmpty() && minStack.peek() >= val){
            minStack.push(val);
        }else if(minStack.isEmpty()){
            minStack.push(val);
        }
    }
    
    public void pop() {
        int val=stack.pop();
        if(!minStack.isEmpty()&&minStack.peek()==val){
            minStack.pop();
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

展开全文 >>

最长有效括号

32. 最长有效括号

难度困难1288

给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

示例 1：

1
2
3
输入：s = "(()"
输出：2
解释：最长有效括号子串是 "()"

示例 2：

1
2
3
输入：s = ")()())"
输出：4
解释：最长有效括号子串是 "()()"

示例 3：

1
2
输入：s = ""
输出：0

提示：

  • 0 <= s.length <= 3 * 104
  • s[i] 为 '(' 或 ')'

栈

遇到左括号入栈，遇到右括号出栈，

  • 如果出栈后栈为空了就将当前的index入栈
  • 如果出栈后栈不为空，计算当前的index到栈顶的index之间的差值即为当前的有效括号的长度
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Solution {
    public int longestValidParentheses(String s) {
        int n = s.length();

        Deque<Integer> stack = new LinkedList<>();
        stack.push(-1);
        int max = 0;
        for(int i=0;i<n;i++){
            if(s.charAt(i)=='('){
                stack.push(i);
            }else{
                stack.pop();
                if(stack.isEmpty()){
                    stack.push(i);
                }else{
                    max = Math.max(max,i-stack.peek());
                }
            }
        }
        return max;
    }
}

动态规划

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Solution {
    public int longestValidParentheses(String s) {
        int maxans = 0;
        int[] dp = new int[s.length()];
        for (int i = 1; i < s.length(); i++) {
            if (s.charAt(i) == ')') {
                if (s.charAt(i - 1) == '(') {
                    dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
                } else if (i - dp[i - 1] > 0 && s.charAt(i - dp[i - 1] - 1) == '(') {
                    dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
                }
                maxans = Math.max(maxans, dp[i]);
            }
        }
        return maxans;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/longest-valid-parentheses/solution/zui-chang-you-xiao-gua-hao-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

不需要额外空间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class Solution {
    public int longestValidParentheses(String s) {
        int left = 0, right = 0, maxlength = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                left++;
            } else {
                right++;
            }
            if (left == right) {
                maxlength = Math.max(maxlength, 2 * right);
            } else if (right > left) {
                left = right = 0;
            }
        }
        left = right = 0;
        for (int i = s.length() - 1; i >= 0; i--) {
            if (s.charAt(i) == '(') {
                left++;
            } else {
                right++;
            }
            if (left == right) {
                maxlength = Math.max(maxlength, 2 * left);
            } else if (left > right) {
                left = right = 0;
            }
        }
        return maxlength;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/longest-valid-parentheses/solution/zui-chang-you-xiao-gua-hao-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

展开全文 >>

汇总各个部门当前员工的title类型的分配数目

题目描述

有一个部门表departments简况如下:

img

有一个，部门员工关系表dept_emp简况如下:

img

有一个职称表titles简况如下:

img

汇总各个部门当前员工的title类型的分配数目，即结果给出部门编号dept_no、dept_name、其部门下所有的员工的title以及该类型title对应的数目count，结果按照dept_no升序排序

img

当group by 一个字段无法显示所有的列的时候使用多个关键字

1
2
3
4
5
6
7
8
9
10
select 
de.dept_no,d.dept_name,t.title,count(t.title)
from
departments d,dept_emp de,titles t
where 
d.dept_no = de.dept_no
and
de.emp_no = t.emp_no
GROUP BY de.dept_no, t.title
order by de.dept_no

显式连接方法

1
2
3
4
5
6
7
8
9
select 
de.dept_no,d.dept_name,t.title,count(t.title)
from
departments d join dept_emp de
on d.dept_no = de.dept_no
join titles t
on de.emp_no = t.emp_no
GROUP BY de.dept_no, t.title
order by de.dept_no

展开全文 >>

获取员工当前的薪水比其manager薪水还高的员工的薪水和manager的薪水

题目描述

有一个，部门关系表dept_emp简况如下:

img

有一个部门经理表dept_manager简况如下:

img

有一个薪水表salaries简况如下:

img

获取员工其当前的薪水比其manager当前薪水还高的相关信息，

第一列给出员工的emp_no，
第二列给出其manager的manager_no，
第三列给出该员工当前的薪水emp_salary,
第四列给该员工对应的manager当前的薪水manager_salary

以上例子输出如下:

img

多表连接

1
2
3
4
5
6
7
SELECT de.emp_no,dm.emp_no manager_no,
sa.salary emp_salary,sal.salary manager_salary
FROM dept_emp de,salaries sa,dept_manager dm,salaries sal
WHERE de.emp_no=sa.emp_no
AND dm.emp_no=sal.emp_no
AND de.dept_no=dm.dept_no
AND sa.salary>sal.salary

查询员工工资、经理工资再对两个结果进行连接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
**查询员工当前工资表 emp_sal**
select de.emp_no,de.dept_no,s1.salary as emp_salary
    from dept_emp de,salaries s1
    where de.emp_no=s1.emp_no
    and s1.to_date='9999-01-01'
    and de.to_date='9999-01-01'
**查询经理当前工资表mag_sal**
 select dm.emp_no as manager_no,dm.dept_no,s2.salary as manager_salary
    from dept_manager dm,salaries s2
    where dm.emp_no=s2.emp_no
    and s2.to_date='9999-01-01'
    and dm.to_date='9999-01-01'
**联结表emp_sal和表mag_sal，连接条件部门编号相等，要求：员工工资>经理工资**
select emp_sal.emp_no,mag_sal.manager_no,
emp_sal.emp_salary,mag_sal.manager_salary
from (
    select de.emp_no,de.dept_no,s1.salary as emp_salary
    from dept_emp de,salaries s1
    where de.emp_no=s1.emp_no
    and s1.to_date='9999-01-01'
    and de.to_date='9999-01-01'
)as emp_sal
inner join(
    select dm.emp_no as manager_no,dm.dept_no,s2.salary as manager_salary
    from dept_manager dm,salaries s2
    where dm.emp_no=s2.emp_no
    and s2.to_date='9999-01-01'
    and dm.to_date='9999-01-01'
)as mag_sal
on emp_sal.dept_no=mag_sal.dept_no
where mag_sal.manager_salary<emp_sal.emp_salary;

展开全文 >>

对所有员工的薪水按照salary进行排序

题目描述

有一个薪水表salaries简况如下:

img

对所有员工的薪水按照salary进行按照1-N的排名，相同salary并列且按照emp_no升序排列：

img

不要忘了加group by关键字

不加group by查出来只有一条数据

1
2
3
4
5
SELECT s1.emp_no, s1.salary, COUNT(DISTINCT s2.salary) AS t_rank
FROM salaries AS s1 join salaries AS s2
on s1.salary <= s2.salary
GROUP BY s1.emp_no
ORDER BY s1.salary DESC, s1.emp_no ASC

展开全文 >>

删除并获得点数

740. 删除并获得点数

难度中等257收藏分享切换为英文接收动态反馈

给你一个整数数组 nums ，你可以对它进行一些操作。

每次操作中，选择任意一个 nums[i] ，删除它并获得 nums[i] 的点数。之后，你必须删除每个等于 nums[i] - 1 或 nums[i] + 1 的元素。

开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。

示例 1：

1
2
3
4
5
输入：nums = [3,4,2]
输出：6
解释：
删除 4 获得 4 个点数，因此 3 也被删除。
之后，删除 2 获得 2 个点数。总共获得 6 个点数。

示例 2：

1
2
3
4
5
6
输入：nums = [2,2,3,3,3,4]
输出：9
解释：
删除 3 获得 3 个点数，接着要删除两个 2 和 4 。
之后，再次删除 3 获得 3 个点数，再次删除 3 获得 3 个点数。
总共获得 9 个点数。

提示：

  • 1 <= nums.length <= 2 * 10^4
  • 1 <= nums[i] <= 10^4

解题思路

通过预处理数组将该问题转换成打家劫舍问题

哈希表+动态规划

若选择了 $x$，则可以获取$ \textit{sum}[x]$ 的点数，且无法再选择 $x-1$ 和 $x+1$。这与打家劫舍中的描述是一样的（相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。）的意思是一样的。 所不同的是：这个题目里面是对数字的相邻做了要求，可以使用哈希表来实现数字的相邻的判断，这样就可以将原先的问题转换到打家劫舍问题上来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
    public int deleteAndEarn(int[] nums) {
        int n = nums.length;
        // 找数据的最大值，即哈希表的大小
        int max = 0;
        for(int i=0;i<n;i++){
            max = Math.max(nums[i],max);
        }
        // 将相同的数字合并到一块，因为选择一个数字的时候可以选择这个数字的所有值
        int [] hash = new int [max+1];
        for(int val:nums){
            hash[val] += val;
        }
		// 打家劫舍问题通解
        int [] dp = new int[max+1];
        dp[0] = hash[0];
        dp[1] = Math.max(hash[0],hash[1]);
        for(int i=2;i<=max;i++){
            dp[i] = Math.max(dp[i-1],dp[i-2]+hash[i]);
        }
        return dp[max];
    }
}

动态规划优化空间复杂度

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public int deleteAndEarn(int[] nums) {
        int []cnt=new int[10001];
        int []dp=new int[10001];
        for (int i : nums) ++cnt[i];// 统计每个数字出现的次数
        dp[0] = 0;
        dp[1] = 1*cnt[1];
        for (int i = 2; i <= 10000; ++i) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + i * cnt[i]);   	 
        }
        return dp[10000];
    }
}

动态规划

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
    public int deleteAndEarn(int[] nums) {
        int []cnt=new int[10001];
        int [][]dp=new int[10001][2];

        for (int i : nums) ++cnt[i];// 统计每个数字出现的次数

        for (int i = 1; i <= 10000; ++i) {
            dp[i][0] = Math.max(dp[i - 1][1], dp[i - 1][0]); // 0 代表不取
            dp[i][1] = dp[i - 1][0] + i * cnt[i];       	 // 1 代表取
        }
        return Math.max(dp[10000][0], dp[10000][1]);
    }
}

排序+动态规划

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class Solution {
    public int deleteAndEarn(int[] nums) {
        int n = nums.length;
        int ans = 0;
        Arrays.sort(nums);
        List<Integer> sum = new ArrayList<Integer>();
        sum.add(nums[0]);
        int size = 1;
        for (int i = 1; i < n; ++i) {
            int val = nums[i];
            if (val == nums[i - 1]) {
                sum.set(size - 1, sum.get(size - 1) + val);
            } else if (val == nums[i - 1] + 1) {
                sum.add(val);
                ++size;
            } else {
                ans += rob(sum);
                sum.clear();
                sum.add(val);
                size = 1;
            }
        }
        ans += rob(sum);
        return ans;
    }

    public int rob(List<Integer> nums) {
        int size = nums.size();
        if (size == 1) {
            return nums.get(0);
        }
        int first = nums.get(0), second = Math.max(nums.get(0), nums.get(1));
        for (int i = 2; i < size; i++) {
            int temp = second;
            second = Math.max(first + nums.get(i), second);
            first = temp;
        }
        return second;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/delete-and-earn/solution/shan-chu-bing-huo-de-dian-shu-by-leetcod-x1pu/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

回溯超时

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class Solution {
    Map<Integer,Integer> map;
    List<Integer> keyList;
    Map<Integer,Boolean> visMap;
    public int deleteAndEarn(int[] nums) {
        int n = nums.length;
        map = new HashMap<>();
        visMap = new HashMap<>();
        for(int i=0;i<n;i++){
            map.put(nums[i],map.getOrDefault(nums[i],0)+nums[i]);
            visMap.put(nums[i],false);
        }
        keyList=new ArrayList<>(map.keySet());

        dfs(0,0);
        return max;
    }
    int max = 0;
    public void dfs(int index,int sum){
        if(index==keyList.size()){
            max = Math.max(sum,max);
            return;
        }
        for(int i=index;i<keyList.size();i++){
            int key = keyList.get(i);
            if(!visMap.get(key)){
                visMap.put(key,true);
                if(map.containsKey(key+1)){
                    visMap.put(key+1,true);
                }
                if(map.containsKey(key-1)){
                    visMap.put(key-1,true);
                }
                dfs(i+1,sum+map.get(key));
                visMap.put(key,false);
                if(map.containsKey(key+1)){
                    visMap.put(key+1,false);
                }
                if(map.containsKey(key-1)){
                    visMap.put(key-1,false);
                }
            }else {
                dfs(i + 1, sum);
            }
        }
    }
}

参考文献

https://leetcode-cn.com/problems/delete-and-earn/solution/shan-chu-bing-huo-de-dian-shu-by-leetcod-x1pu/923701

展开全文 >>

MySQL基本查询语法 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
SELECT
    [ALL | DISTINCT | DISTINCTROW ]
    [HIGH_PRIORITY]
    [STRAIGHT_JOIN]
    [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
    [SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
    select_expr [, select_expr] ...
    [into_option]
    [FROM table_references
      [PARTITION partition_list]]
    [WHERE where_condition]
    [GROUP BY {col_name | expr | position}, ... [WITH ROLLUP]]
    [HAVING where_condition]
    [WINDOW window_name AS (window_spec)
        [, window_name AS (window_spec)] ...]
    [ORDER BY {col_name | expr | position}
      [ASC | DESC], ... [WITH ROLLUP]]
    [LIMIT {[offset,] row_count | row_count OFFSET offset}]
    [into_option]
    [FOR {UPDATE | SHARE}
        [OF tbl_name [, tbl_name] ...]
        [NOWAIT | SKIP LOCKED]
      | LOCK IN SHARE MODE]
    [into_option]

into_option: {
    INTO OUTFILE 'file_name'
        [CHARACTER SET charset_name]
        export_options
  | INTO DUMPFILE 'file_name'
  | INTO var_name [, var_name] ...
}

排序自连接

排序自连接1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
select
e.emp_no,s.salary,e.last_name,e.first_name
from 
salaries s join employees e 
on s.emp_no = e.emp_no
where e.emp_no = 
(
    select 
    s1.emp_no
    from
    salaries s1 join salaries s2 
    on s1.salary < s2.salary
    group by s1.salary
    having count(distinct s2.salary)=1
)

排序自连接2

注意: 在排序自连接中，如果有count并且不加group by 关键字只能查出来一条数据，如果加上group by关键字，那么可以查出来多条数据

错误示范

1
2
3
4
SELECT s1.emp_no, s1.salary, COUNT(DISTINCT s2.salary) AS t_rank
FROM salaries AS s1 join salaries AS s2
on s1.salary <= s2.salary
ORDER BY s1.salary DESC, s1.emp_no ASC

正确写法

1
2
3
4
5
SELECT s1.emp_no, s1.salary, COUNT(DISTINCT s2.salary) AS t_rank
FROM salaries AS s1 join salaries AS s2
on s1.salary <= s2.salary
GROUP BY s1.emp_no
ORDER BY s1.salary DESC, s1.emp_no ASC

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

我是一只<br>又水又笨又菜的<br>菜狗子<br>希望有一天被领走