1月27日报
作者：互联网
MySQL
10 创建和管理表
DDL：Data Definition Languages （数据定义语言）
Alter
将表的一个列排到另一个表的后面：After
ALTER TABLE employees MODIFY mobile VARCHAR(25) AFTER officeCode;
字段改名: change
ALTER TABLE dept80
CHANGE department_name dept_name varchar(15);
删除一个列
ALTER TABLE 表名 DROP 【COLUMN】字段名
13 约束 Constraints
- 外键约束:
- 在表创建时建立外键约束
15 存储过程和存储函数
创建一个存储过程，实现输入ID，返回姓名和手机号
在SQLyog中，Delimiter在前面和后面写，还有Begin
delimiter //
create procedure get_phone(in u_id INT , out b_name varchar(15), out b_phone varchar(15))
begin
select b.`NAME`, b.phone into b_name, b_phone
from beauty b
where u_id = id;
end //
delimiter;
16 变量、流程控制与游标
1. 变量
变量分为系统变量和用户自定义变量
1.1 系统变量
1.1.1系统变量分类
- 服务器层面
- 全局系统变量 (global) 和会话系统变量（local）
- 全局变量不能跨重启
1.1.2 查看系统变量
- show global variables;
- show session variables
- show variables //默认查询的是会话系统变量
- 如何查看和修改系统变量
这里是引用
1.2 用户变量
- 会话用户变量和局部变量
- 会话用户变量：作用域和会话变量一样，只对当前连接会话有效。
- 局部变量：只在 BEGIN 和 END 语句块中有效。局部变量只能在
存储过程和函数中使用。
面向对象
OOP (Object-oriented programing)
JAVA类Class以及类的成员
- 属性，class里的一些变量，比如name, id…，成员变量
- 方法，method
- 构造器
public TreeNode() {}
public TreeNode(int n) {
this.val = val;
}
- 代码块
- 内部类，子类，一个class里再接一个class
类：是对一类事物的描述，是抽象的，概念上的定义 class，比如狗
对象：是实际存在的该类事物的个体，比如狗里的柯基
面向对象的重点就是设计类
设计类，其实就是设计类的成员
面向对象的三大特性
- 封装: Encapsulation
- 继承: Inheritance
- 多态: Polymorphism
算法:
二分法
- 搜索旋转排序
参考九日集训第三日的帖子
https://bbs.csdn.net/topics/604505141?spm=1001.2014.3001.6377
递归
- 70 Climbing Stairs
You are climbing a staircase. It takes n steps to reach the top.
Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
这道题的巧妙之处在于利用f这样数列去代替函数，免去了递归，而是直接用数组去算。
class Solution {
public int climbStairs(int n) {
int[] f = new int[50];
f[0] = f[1] = 1;
for (int i = 2; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2];
}
return f[n];
}
}
BFS宽度优先算法
- 102 Binary Tree Level Order Traversal & 102 Reverse（反转前面的结果）
Given the root of a binary tree, return the level order traversal of its nodes values. (From left to right, level by level)
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res= new ArrayList<>();
if (root == null) {
return res;
}
//解题关键在于这个Queue能储存的是个节点
Queue<TreeNode> store = new LinkedList<>();
store.add(root);
//第一层while的触发，就是这一层开始被遍历
while (store.size() > 0) {
int tempSize = store.size();
List<Integer> toAdd = new ArrayList<>();
//第二层while就是对这一层中的所有节点进行处理，把节点的children添加到Queue
//然后把自己的值添加到当前List中
while (tempSize > 0) {
TreeNode cur = store.poll();
toAdd.add(cur.val);
if (cur.left != null) {
store.add(cur.left);
}
if (cur.right != null) {
store.add(cur.right);
}
tempSize--;
}
//必须copy一份新的，防止传递
List<Integer> copy = new ArrayList<>();
for (int i = 0; i < toAdd.size(); i++) {
copy.add(toAdd.get(i));
}
res.add(copy);
}
return res;
}
}
并查集 Union Find
对于并查集来说，最主要的构建一个Class，在这个class里，有main, find, union三种功能。
main的功能就是构建一个长度符合功能要求的数组
并查集依靠数列去实现, 一开始每个数列里的值就是其本身的Index，但如果两个数合并，那么这个数作为Index在root数列中的值会变成另一个数的root。
Union(0, 1) -> root[1] = 0;
假设root[0] = 0;
对于find来说，就是不断去找到其相应的根的值，直到root本身的值和自身的Index相等为止
Find(x) -> if (x == root[x]) return x;
else return find(root[x]);
- 547 Number of Provinces
There are n cities. Some of them are connected, while some are not. If city a is connected directly with city b, and city b is connected directly with city c, then city a is connected indirectly with city c.
A province is a group of directly or indirectly connected cities and no other cities outside of the group.
You are given an n x n matrix isConnected where isConnected[i][j] = 1 if the ith city and the jth city are directly connected, and isConnected[i][j] = 0 otherwise.
Return the total number of provinces.
class Solution {
private int[] root;
public int findCircleNum(int[][] isConnected) {
//构建一个root数列
int n = isConnected.length;
root = new int[n];
for (int i = 0; i < root.length; i++) {
root[i] = i;
}
int count = 0;
for (int i = 0; i < isConnected.length; i++) {
for (int j = 0; j < isConnected[0].length; j++) {
if (isConnected[i][j] == 1) {
union(i, j);
}
}
}
for (int i = 0; i < root.length; i++) {
if (root[i] == i) {
count++;
}
}
return count;
}
private int find(int x) {
if (x == root[x]) {
return x;
}
return find(root[x]);
}
private void union(int x, int y) {
root[find(x)] = find(y);
}
}
-
200 岛屿数量
-
- 二维数组和一维数组的坐标转换 （x * column + y）
class Solution {
//process with UnionFind
private int[] root;
private int unionCount;
private int row;
private int column;
// total - watercount (遍历中得到) - unionCount = result;
public int numIslands(char[][] grid) {
if (grid == null || grid.length == 0) {
return 0;
}
//构建基本条件
row = grid.length;
column = grid[0].length;
root = new int[row * column];
for (int i = 0; i < root.length; i++) {
root[i] = i;
}
int totalCount = row * column;
int watercount = 0;
//遍历
for (int x = 0; x < row; x++) {
for (int y = 0; y < column; y++) {
if (grid[x][y] == '0') {
watercount++;
} else {
processCoordinate(x, y, 1, 0, grid);
processCoordinate(x, y, -1, 0, grid);
processCoordinate(x, y, 0, 1, grid);
processCoordinate(x, y, 0, -1, grid);
}
}
}
return totalCount - unionCount - watercount;
}
private void processCoordinate(int x, int y, int offsetX, int offsetY, char [][] grid) {
int curX = x + offsetX;
int curY = y + offsetY;
if (curX >= 0 && curX < row && curY >= 0 && curY < column && grid[curX][curY] == '1') {
union(curX * column + curY, x * column + y);
}
}
private int find(int x) {
if (root[x] == x) {
return x;
}
return find(root[x]);
}
private void union(int x, int y) {
int rootX = find(x);
int rootY = find(y);
if (rootX != rootY) {
root[rootX] = rootY;
unionCount++;
}
}
}
标签：27,return,日报,++,int,grid,TreeNode,root 来源： https://blog.csdn.net/jjsobig1/article/details/122722550