学习目标：
每天2-3到简单sql（刷完即止），每天复习代码随想录上的题目3道算法（时间充足可以继续），背诵的八股的问题也在这里记录了
今日碎碎念：
1）偶尔还是贪玩游戏，但是进度有在往前，八股计划准备这些，计网，JVM，JUC，Java基础与集合，MySQL，Redis，Spring和Spring Boot，整体下来，热门的能准备到70%就开投。
2）明天是MySQL和Redis的八股部分。
3）哎还有科三科四没考，只能约到3月15号的，刚好一边准备面试。
4）项目还得优化一两道，简历还会再修改几次。
力扣刷题
SQL
力扣1789：1789. 员工的直属部门
解答思路：
1）这道题很有意思啊，我觉得也是练习分组和子查询很好的一道题，咱看注释就好了
java
# 值得注意的就是题目中提到的如果只加了一个部门，虽然primary_flag是N但是也是直属部门
# 也就是说，当count(department_id) = 1 的时候表示是直属部门
# 因此需要先找到primary_id为Y的
# 然后按照员工id分组，我们得查出哪些只加入了一个部门的员工，很明显这是一个子查询
select employee_id,department_id
from Employee
where
primary_flag = 'Y'
or
employee_id in (
select employee_id
from Employee
group by employee_id
having count(department_id) = 1
)力扣607：607. 销售员
解答思路：
1）本道题别给那么多张表吓到就好了，其实理清楚思路就行，反推着写
2）要找没有向RED公司销售过的员工名字，就得先找到员工ID
3）要找到符合的员工ID，就得先找到在Orders表里面的和RED的ID有关的员工ID
4）要找到Orders表里面的和RED的ID，就得先对着RED这个公司名字去找ID
java
# 多表查询，要求我们查出没有向RED公司销售过的员工名字
# 因此得先解决如何查询到向RED公司销售过的员工的名字，我这里命名为结果集A
# 但是再大前提就是，得先找到RED的com_id是什么
# 然后拿着SalesPerson表中的sales_id来判别即可，即不在结果集A中的就是答案
select SalesPerson.name
from SalesPerson
where SalesPerson.sales_id not in(
select sales_id
from Orders
where com_id = (
select Company.com_id
from Company
where Company.name = 'RED'
)
)算法
力扣707：707. 设计链表
解答思路：
1）看注释即可
java
class MyLinkedList {
class ListNode{
int val;
ListNode next;
ListNode(){};
ListNode(int val){
this.val = val;
}
}
//记录元素个数
int size;
//虚拟头节点
ListNode head;
//初始化链表
public MyLinkedList() {
size = 0;
head = new ListNode(0);
}
public int get(int index) {
//如果下标无效就返回-1
if(index >= size || index < 0){
return -1;
}
//查找指定下标的元素
ListNode tmp = head;
//因为是获取下标的元素，超过下标后的无需再查找了
//等于是因为我们有虚拟头节点
for(int i = 0 ; i <= index ; i++){
tmp = tmp.next;
}
return tmp.val;
}
//头插法
public void addAtHead(int val) {
//调用addAtIndex
addAtIndex(0,val);
}
//尾插法
public void addAtTail(int val) {
//调用addAtIndex
addAtIndex(size,val);
}
//在这里实现头插，尾插，普通插入
public void addAtIndex(int index, int val) {
//过滤不符合位置的下标
if(index > size){
return;
}
//index小于0
if(index<0){
index = 0;
}
//插入后，数量增加
size++;
//我们通过前驱节点来插入元素(利用虚拟头节点)
ListNode pre = this.head;
//找到指定位置
for(int i = 0;i < index;i++){
pre = pre.next;
}
//new新节点
ListNode newNode = new ListNode(val);
//插入节点就是将原来的节点往后移
newNode.next = pre.next;
pre.next = newNode;
}
public void deleteAtIndex(int index) {
//过滤无效下标
if (index < 0 || index >= size) {
return;
}
//数量1
size--;
if (index == 0) {
head = head.next;
return;
}
//移动到指定位置
ListNode pre = head;
for(int i = 0; i < index ; i++){
pre = pre.next;
}
pre.next = pre.next.next;
}
}
/**
* Your MyLinkedList object will be instantiated and called as such:
* MyLinkedList obj = new MyLinkedList();
* int param_1 = obj.get(index);
* obj.addAtHead(val);
* obj.addAtTail(val);
* obj.addAtIndex(index,val);
* obj.deleteAtIndex(index);
*/力扣206：206. 反转链表
解答思路：
双指针做法
1）我自己在做这些链表题目的时候，都会画图（脑子里也可以），画图之后就不一定会那么抽象了，我个人感觉，链表题目的核心的就是，搞清楚指向问题，即搞清楚当前节点的下一个节点，前一个节点，到底是什么内容，我们需要将这两个节点变成啥才能达到我们想要的结果
java
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode reverseList(ListNode head) {
//这里通过双指针来实现
ListNode pre = null;
ListNode cur = head;
//涉及到交换，这里得再定义中间变量
ListNode tmp = null;
//从原链表来获取节点，拼接到新头节点上
while(cur != null){
//保存下一个节点
tmp = cur.next;
cur.next = pre;
//移动指针
pre = cur;
cur = tmp;
}
return pre;
}
}递归做法
java
// 递归
class Solution {
public ListNode reverseList(ListNode head) {
return reverse(null, head);
}
private ListNode reverse(ListNode prev, ListNode cur) {
if (cur == null) {
return prev;
}
ListNode temp = null;
temp = cur.next;// 先保存下一个节点
cur.next = prev;// 反转
// 更新prev、cur位置
// prev = cur;
// cur = temp;
return reverse(cur, temp);
}
}力扣24：24. 两两交换链表中的节点
解答思路：
1）这道题跟反转链表其实也是一样的思路，推荐画出来做，做这种交换的题目你就这样想：
给你一个空瓶子，一瓶雪碧，一瓶可乐，要你把雪碧放到可乐瓶子里面，可乐放到雪碧瓶子里面去，那么肯定是将其中一个倒到空瓶子中先才可以
java
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
//不太擅长写递归，所以使用虚拟头节点 + 迭代来做
public ListNode swapPairs(ListNode head) {
ListNode dum = new ListNode(-1);
dum.next = head;
ListNode cur = dum;
ListNode tmp = null;
ListNode firstNode = null;
ListNode secondNode = null;
//要交换必须要保证有两个节点
while(cur.next != null && cur.next.next != null){
//先记录第三个节点
tmp = cur.next.next.next;
//记录第一个节点
firstNode = cur.next;
//记录第二个节点
secondNode = cur.next.next;
//交换
cur.next = secondNode;
secondNode.next = firstNode;
firstNode.next = tmp;
//指针移动
cur = firstNode;
}
return dum.next;
}
}