在阿里云centos7.0 上安装mysql最新版方法

使用rpm方法

1.在http://dev.mysql.com/downloads/mysql/#downloads 上选择
(1):(mysql-community-common-5.7.11-1.el7.x86_64.rpm)
(2):(mysql-community-libs-5.7.11-1.el7.x86_64.rpm)
(3):(mysql-community-client-5.7.11-1.el7.x86_64.rpm)
(4):(mysql-community-devel-5.7.11-1.el7.x86_64.rpm)
(5):(mysql-community-server-5.7.11-1.el7.x86_64.rpm)

5条命令来安装上面5个;

1
[root@iZ28m9hwbnmZ ~]# wget -c http://dev.mysql.com/get/Downloads/MySQL-5.7/mysql-community-common-5.7.11-1.el7.x86_64.rpm

dataStrucute

线性表

链表

栈和队列

队列

KMP匹配算法

树的定义

二叉树

二叉树的基本的5中基本形态:
1.空二叉树
2.只有一个根结点
3.根结点只有左子树
4.根结点只有右子树
5.根结点既有左子树又有右子树

特殊二叉树

1.斜树
2.满二叉树
3.完全二叉树
完全二叉树是每个结点位置的编号要与满二叉树相同位置的编号相同
特点
(1)叶子结点只能出现在最下两层。
(2)最下层的叶子一定集中在左部连续位置。
(3)倒数二层,若有叶子结点,一定都在左部连续位置。
(4)如果结点度为1,则该结点只有左孩子,既不存在只有右子树的情况。
(5)同样结点数的二叉树,完全二叉树的深度最小。

二叉树的性质

性质1:在二叉树的第i层上至多有2^(i-1)个结点(i>=1)。
性质2:深度为K的二叉树至多由2^k - 1个结点(k>=1)。
性质3:对于任何一颗二叉树T,如果终端结点数为n0,度为2的结点数为n2,则n0=n2+1。
性质4:具有n个结点的完全二叉树的深度为

树,森林和二叉树的转换

森林的前序遍历和二叉树的前序遍历结果相同,森林的后续遍历和二叉树的中序遍历结果相同
树的先根遍历和后根遍历也完全可以借助二叉树的前序遍历和中序遍历实现。

图的各种定义

图的定义:图是由一组顶点和一组能够将两个顶点相连的边的组成。
无向边:若定点vi到定点vj之间的边没有方向,则称这条边为无向边,由无序偶对(vi, vj)来表示。如果途中任意两个顶点之间的边都是无向边,则称该图为无向图
有向边:若从顶点vi到vj的边有方向,则称这条边为有向边,也称为弧。用有序偶来表示,vi称为弧尾,vj称为弧头。如果图中任意两个顶点之间的边都是有向边,则称该图为有向图。
简单图:不存在顶点到其自身的边,且同一条边不重复出现。
在无向图中如果任意两个顶点之间都存边,则称该图为无向完全图。含有n个顶点的无向完全图由(nx(n-1))/2条边。
在有向图中如果任意两个顶点之间都存在方向弧尾相反的两条弧,则称该图为完全有向图。含有n个顶点的完全有向图有nx(n-1)条边。
网:有些图的边或弧具有与它相关的数字,这种与图的边或弧相关的数叫做权。这种带权的图通常称为网。
当且仅当一幅含有V个结点的图G满足下列5个条件之一时,它就是一棵树:
1.G由V-1个条边且不含有环;
2.G有V-1条边且是不连通的;
3.G是连通的,但删除任意一条边都会使它不再连通;
4.G是无环图,但添加任意一条边都会产生一条环;
5.G中任意一对顶点之间仅存在一条简单路径;

图的存储结构

有两个要求:
1.它必须为可能的应用中碰到的各种类型的图预留出足够的空间。
2.Graph的势力方法的实现一定要快——它们是开发处理图的各种用例的基础。

邻接矩阵

使用V乘V的布尔矩阵存储图,但是由一个缺点,当由上百万个顶点以上时,V的平方个布尔值所需的空间太大,不好表示,不符合第一个要求。

邻接表

以顶点为索引的列表数组,其中的每个元素都是和该顶点相邻的顶点列表。
特点:
1.使用的空间和V+E成正比;
2.添加一条边所需的时间为常数;
3.遍历顶点v的所有相邻顶点所需要的时间和v的度数成正比(处理每个相邻顶点所需的时间为常数);

十字链表

邻接多重链表

边集数组

最小生成树

普里姆算法

克鲁斯卡尔算法()

代码如下:
克鲁斯卡尔算法主要是针对边来展开,边数少时效率会非常高,所以对于稀疏图有很大优势;而普里姆算法对于稠密图,即边数非常多的情况会更好一些。

最短路径

最短路径:

1)算法深度搜索算法:

2)广度搜索算法:

迪杰斯特拉算法

弗洛伊德算法

拓扑排序

AOV网:在一个表示工程的有向图中,用顶点表示活动,用弧表示活动之间的优先关系,这样的有向图为顶点表示活动的网,称为AOV网
拓扑序列:设G=(V,E)是一个具有n个顶点的有向图,V中的顶点序列v1, v2, ……, vn,满足若从顶点vi到vj有一条路径,则在顶点序列中顶z点vi比在顶点vj之前。则我们称这样的顶点序列为拓扑序列

关键路径

Java编程思想读书笔记(三)

通过异常处理错误

Java标准异常

RuntimeException,由它继承而来的异常被称为“不受检查的异常”。这种异常属于错误,会自动被捕获,不用我们自己去动手。所以我们可以不用在异常声明中声明方法将被抛出RuntimeException类型的异常。要注意到的是只能在代码中忽略RuntimeException及子类的异常,其他异常都是由编译器强制实施的,而RuntimeException算编程错误。
Exception是所有“被检查的异常”的基类。

用finally进行清理

当要把出内存之外的资源恢复到它们的初始状态,就要finally子句,对于没有垃圾回收和构析函数自动调用机制的语言来说,finally可以是程序员保证:无论try快里发生了什么,内存总能的到释放。因为finally字句总是会执行的,所以在一个方法中,可以从多喝点返回,并且可以保证重要的清理工作仍旧会执行:

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
public class MultipleReturns {
public static void f(int i) {
System.out.println("Initialization that requires cleanup");
try {
System.out.println("Point 1");
if(i == 1) return;
System.out.println("Point 2");
if(i == 2) return;
System.out.println("Point 3");
if(i == 3) return;
System.out.println("End");
return;
} finall {
System.out.println("Performing cleanup");
}
}
public static void main(Stringp[] args) {
for(int i = 1; i <= 4; i++) {
f(i);
}
}
} /* Output:
Initialization that requires cleanup
Point 1
Performing cleanup
Initialization that requires cleanup
Point 1
Point 2
Performing cleanup
Initialization that requires cleanup
Point 1
Point 2
Point 3
Performing cleanup
Initialization that requires cleanup
Point 1
Point 2
Point 3
End
Performing cleanup
*///:~

异常使用指南

在下列情况下使用异常:
1)在恰当的级别处理问题。(在知道该如何处理的情况下才捕获异常。)
2)解决问题并且重新调用产生异常的方法。
3)进行少许修补,然后绕过异常发生的地方继续执行。
4)用别的数据进行计算,以替代方法预计会返回的值。
5)把当前运行环境下能做的事情尽量昨晚,然后把相同的异常重抛到更高层。
6)把当前运行环境下能做的事情尽量做完,然后把不同的异常抛到更高层。
7)终止程序。
8)进行简化。(如果你的异常模式是问题变得太复杂,那用起来会非常痛苦也很烦人。)
9)让类库和程序更安全。(这既是在为调试做短期投资,也是在为程序的健壮性做长期投资。)

字符串

重载 “+” 与StringBuilder

如果是使用String字符串创建的对象,在使用”+”连接符时,编译器会创建一个StringBuilder对象,用以构造最终的String,为每个字符串调用一个StringBuilder的append()方法。最后调用toString()生成结果
如果一个类编写toString()方法时,如果字符串操作比较简单,那就可以依赖编译器,它会合理地为我们构造最终的字符串结果。

正则表达式

字符类
. 任意字符
[abc] 包含a,b和c的任何字符(和a|b|c作用相同)
[^abc] 除了a,b和c之外的任何字符(否定)
[a-zA-Z] 从a到z或A到Z的任何字符(范围)
[abc[hij]] 任意a,b,c,h,i和j字符(与a|b|c|h|i|j作用相同)(合并)
[a-z&&[hij]] 任意h,i或j(交)
\s 空白符(空格,tab,换行,换页和回车)
\S 非空白符([^\s])
\d 数字[0-9]
\D 非数字[^0-9]
\w 词字符[a-zA-Z0-9]
\W 非词字符[^\w]

边界匹配符
^ 一行的起始
$ 一行的结束
\b 词的边界
\B 非词的边界
\G 前一个匹配的结束

类型信息

为什么需要RTTI

在Java中所有类型转换是在运行时进行正确性检查的。这也是RTTI名字的含义:在运行时,识别一个对象的类型。

Class对象

Class对象就是用来创建类的所有的“常规”对象的
Class的newInstance()方法是实现“虚拟构造器”的一种途径,虚拟构造器允许我们声明:“我不知道你的确切类型,但是无论如何要正确创建你自己”,这句话让我对反射的逐渐有了理解,利用Class对象的这个方法,在反射时,创建这个需要的类型。看下面的一段代码,体验使用的例子中Class的方法

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
//:typeinfo/toys/ToyTest.java
package typeinfo.toys;
import static net.midview.util.Print.*;
interface HasBatteries {
}
interface Waterproof {
}
interface Shoots {
}
class Toy {
Toy() {
}
Toy(int i) {
}
}
class FancyToy extends Toy implements HasBatteries, Waterproof, Shoots {
FancyToy() {
super(1);
}
}
public class ToyTest {
static void printInfo(Class cc) {
print("Class name: " + cc.getName() + " is interface? [" + cc.isInterface() + "]");
print("Simple name: " + cc.getSimpleName());
print("Canonical name: " + cc.getCanonicalName);
}
public static void main(String[] args) {
Class c = null;
try {
c = Class.forname("typeomfp.toys.FancyToy");
} catch(ClassNoFoundException e) {
print("Can't find FancyToy");
System.exit(1);
}
printInfo(c);
for(Class face : c.getInterfaces())
printInfo(face);
Class up = c.getSuperclass();
Object obj = null;
try {
obj = up.newInstance();
} catch(InstantiationException e) {
print("Cannot instantiate");
System.exit(1);
} catch(IllegalAccessException e) {
System.exit(1);
}
printInfo(obj.getClass());
}
} /*Output:
Class name: typeinfo.toys.FancyToy is interface? [false]
Simple name: FancyToy
Canonical name: typeinfo.toys.FancyToy
Class name: typeinfo.toys.HasBatteries is interface? [true]
Simple name: HasBatteries
Canonical name: typeinfo.toys.HasBatteries
Class name: typeinfo.toys.Waterproof is interface? [true]
Simple name: Waterproof
Canonical name: typeinfo.toys.Waterproof
Class name: typeinfo.toys.Shoots is interface? [true]
Simple name: Shoots
Canonical name: typeinfo.toys.Shoots
Class name: typeinfo.toys.Toy is interface? [False]
Simple name: Toy
Canonical name: typeinfo.toys.Toy
*///:~

up仅仅只是一个Class引用,在编译器不具备任何更近一步的类型信息。当我们创建新实例时,会得到Object引用,但是这个引用指向的是Toy对象。

反射

java反射是在程序运行时,获取某个对象的确切类型,这个确切的类型要求在编译时必须已知,这样可以在运行时识别它,然后获取相关信息,反射可以获得这个java类型的相关Field,Method,以及Constructor。在Class类与java.lang.reflect类库一起对反射提供了支持,在java.lang.reflect类库中提供了Fiedl,Method,Constructor三个类。这些类型的对象都是在运行时期创建的,用以表示未知类里对应的成员。可以用Constructor创建新的对象,用set(),get()方法修改和读取与Field对象相关的对象。对于反射来说,重要的一点是,反射可以读取private修饰符修饰的类,字段,方法,并且可以调用它们。包括私有内部类和匿名类都可以调用。

动态代理

动态代理是23种设计模式中最基本的几种设计模式,它的UML图如下所示
动态代理的目的是在与充当中间人的角色实现两个类之间的低耦合性,而且代理可以提供额外的或不同的操作,示例代码也如下所示,

Java编程思想读书笔记(二)

复用类

final 关键字

1.final 对基本类型运用时,能让基本类型数值保持不变,但对于对象引用时,能够保持对象的引用不变,但是对于对象自身的是可以被修改的,这个在不可变对象使用中要注意到这个问题。

多态

转机

1.导出类无法覆盖基类的私有方法,在向上转型中,调用的私有方法时,得到的是基类的私有方法运行的结果。
只有非peivate方法不会被覆盖。
2.当导出类转型为基类时,调用的任何域访问操作都将由编译器解析,因此不是多态的,所以当该对象使用某个域的值时,得到的结果是基类的域的结果,不是子类相同域的结果。还有静态方法也不具有多态性。

构造器和多态

1.创建对象调用构造器时,初始化的实际过程:
1)在其他对象任何事物发生之前,将分配给对象的存储空间初始化为二进制的零
2)调用基类构造器。不断递归下去,从最顶层的基类到最底层的导出类。(还有补充,请看下面的代码)
3)按声明顺序调用成员的初始化方法。
4)调用导出类构造器的主体

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
class Glyph {
void draw() {
System.out.println("Glyph.draw()");
}
Glyph() {
System.out.println("Glyph() before draw()");
draw();
System.out.println("Glyph() after draw()");
}
}
class RoundGlyph extends Glyph {
private int radius = 1;
RoundGlyph(int r) {
radius = r;
System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);
}
void draw() {
System.out.println("RoundGlyph.draw(), radius = " + radius);
}
}
public class PolyConstructors {
public static void main(String[] args) {
new RoundGlyph(5);
}
} /* Output:
Glyph() before draw()
RoundGlyph.draw(), radius = 0
Glyph() after draw()
RoundGlyph.RoundGlyph(), radius = 5
*///:~

Java编程思想读书笔记(一)

《Thinking in Java》这本书几个月前就在看了,但是自己的Java基础比较差,到后面一些东西看得有些懵逼,上个月勉强看完了。自己现在做一些读书笔记吧,也把自己看这本书的获得知识以及思考分享给大家,我会画出这本书的思维导图给大家看下,我的文笔很烂,表达不清楚,或者说的太多废话,望大家不要介意,还有一些东西可能由错误,有什么意见也可以指点出,谢谢了!

对象导论

本章是让没有了解面向对象程序设计的人,进行了解的,是背景性,补充性材料。Alan Kay总结的面向对象语言的五基本特性:
1.万物皆为对象
2.程序是对象的集合,它们通过发送消息老告知彼此所要做的事
3.每个对象都有自己的由其它对象所构成的存储
4.每个对象都拥有其类型
5.某一特定类型的所有对象都可以接收同样的消息
理解:所有东西都可以分类,比如书这一类,人这一类,那么人在仔细分,就是具体到我们每个人了,我们是独一无二的,我们单独自己就是一个对象,是人这一类中的一个例子,而程序就好比我们一个整体,比如一个班级,包含是一个班人,就是我们的集合,我们一个人是一个对象,而班级像程序一样也要运行,班主任告知学生和任课老师要做的事,任课老师也告知彼此要做的事。而第三点,万物都是对象,所以具体的书本也是对象,以及器官也是对象,那么我们每个人也是由其它的对象组成的。而每个对象都有自己的分类,比如人类,书类等。比如上课了,学生都要在自己笔记本上做笔记,学生是一个特定的类型,学生们都接收了这个消息。
每个对象都由自己的状态,行为和标识,状态就好比类里变量赋予了值,行为就是类里定义的方法,但由可以根据对象的不同使方法产生不同的结果,好比 东施效颦 产生了不同的结果,而对象都是特定的独一无二的,在内存里每个对象都由唯一一个地址,我们人也一样,就算是双胞胎,也有不一样的因素。
接口就好比人会思考这个技能一样,原本所有动物都没有的,但是人类添加了这个接口,实现了这个接口定义的思考这个方法。
所谓的继承就是一层层关系下来的,比如书,书有很多种类,文学,科普什么的,然后文学这类算继承了书这一类,而文学里还有各种分类,最后到具体的某一本书名了,所以这是一步一步地继承下去的。
封装就像任课老师们教的课一样,而班主任只需要告诉任课老师们把学生教好,至于任课老师所教的课的东西,怎么教好学生都不用班主任管理,每个任课老师(一个接口),就每个任课老师讲课这些方式就像接口内部实现一样,以及接口外部调用者(班主任),这是就是封装了!
而多态就是好比一道母题,根据它的特性生成很多子题,子题继承了母题,不过更改了母题的条件,这样让母题有多种实现的方式,不同子题对母题的不同实现方式!

第一次Android学习总结

今天总结的是由郭霖大神写的《第一行代码Android》

这本书很值得新人去看我的第一本Android书就是这个,在一个月前就看完了,可是一直没有时间去总结这本书的知识点!这对于学习来说很是被动的,不去总结很难获得什么经验,特别是对于我这种记忆力不知道有多差的人来说更是灾难!首先上一张图,我自己画的思维导图:

我的博客搭建过程

今天基本把我的博客给搞好了,就差域名备好案了

我是用hexo 在阿里云服务器(CentOS 7系统)上用nginx 运行的 然后用push钩子,在本地用git push完后自动部署到你的服务器上,我在网上看到很多教程,但是有一些比较久了,自己看的也迷迷糊糊的.今天就讲一下我的搭建过程,希望有用.

hexo 使用

先下载nodejs,在你自己的本地电脑,还有阿里云服务器都要下载,我本机系统是ubuntu15.10,具体怎么下载google吧
下载完后是npm安装

1
npm install hexo -g

用下面语句,测试是不是成功

1
hexo help

接着就是在~/目录里建立一个文件夹(blog)

1
cd ~/blog

1
hexo init
|