解决方式：

1. 添加github-client源
2. apt update & apt install gh
3. gh auth login. # choose ssh

enjoy!

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment

• Windows
• Mac
• Ubuntu
• 其他Linux (非debian)

RDD：Resilient Distributed Dataset

弹性分布式数据集：不可变，分布式抽象数据。使用时可以显示的将其换存在内存中以提高速度

• 分片，每一个分片会被一个计算任务处理，可以在创建RDD时指定分片数
• 迭代器，每个分片计算结果可以通过迭代器的compute函数进行整合，无需保存每次计算的结果
• 依赖关系，RDD转换后形成新的RDD，新的RDD就依赖之前的结果。在部分分区计算失败或数据丢失时，可以具体到依赖的分区进行重新计算即可
• 分片函数，哈希分片语范围分片，其决定了分片数量
• 移动计算而不是移动数据，任务调度时尽可能将任务下发到所需处理的数据块存储节点执行

创建RDD

• HDFS
• 数据库
• 本地文件
• 其他

算子

• Transformation

  将一个RDD转换为另一个RDD，transfromation具有lazy load特性。需要遇到action算子时才会执行

  Transformation	含义
  map(func)	返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
  filter(func)	返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成
  flatMap(func)	类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）
  mapPartitions(func)	类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]
  mapPartitionsWithIndex(func)	类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Interator[T]) => Iterator[U]
  sample(withReplacement, fraction, seed)	根据fraction指定的比例对数据进行采样，可以选择是否使用随机数进行替换，seed用于指定随机数生成器种子
  union(otherDataset)	对源RDD和参数RDD求并集后返回一个新的RDD
  intersection(otherDataset)	对源RDD和参数RDD求交集后返回一个新的RDD
  distinct([numTasks]))	对源RDD进行去重后返回一个新的RDD
  groupByKey([numTasks])	在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD
  reduceByKey(func, [numTasks])	在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置
  aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])	先按分区聚合 再总的聚合 每次要跟初始值交流 例如：aggregateByKey(0)(+,+) 对k/y的RDD进行操作
  sortByKey([ascending], [numTasks])	在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
  sortBy(func,[ascending], [numTasks])	与sortByKey类似，但是更灵活 第一个参数是根据什么排序 第二个是怎么排序 false倒序 第三个排序后分区数 默认与原RDD一样
  join(otherDataset, [numTasks])	在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD 相当于内连接（求交集）
  cogroup(otherDataset, [numTasks])	在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD
  cartesian(otherDataset)	两个RDD的笛卡尔积 的成很多个K/V
  pipe(command, [envVars])	调用外部程序
  coalesce(numPartitions**)**	重新分区 第一个参数是要分多少区，第二个参数是否shuffle 默认false 少分区变多分区 true 多分区变少分区 false
  repartition(numPartitions)	重新分区 必须shuffle 参数是要分多少区 少变多
  repartitionAndSortWithinPartitions(partitioner)	重新分区+排序 比先分区再排序效率高 对K/V的RDD进行操作
  foldByKey(zeroValue)(seqOp)	该函数用于K/V做折叠，合并处理 ，与aggregate类似 第一个括号的参数应用于每个V值 第二括号函数是聚合例如：_+_
  combineByKey	合并相同的key的值 rdd1.combineByKey(x => x, (a: Int, b: Int) => a + b, (m: Int, n: Int) => m + n)
  partitionBy****（partitioner）	对RDD进行分区 partitioner是分区器 例如new HashPartition(2
  cache	RDD缓存，可以避免重复计算从而减少时间，区别：cache内部调用了persist算子，cache默认就一个缓存级别MEMORY-ONLY ，而persist则可以选择缓存级别
  persist
  Subtract****（rdd）	返回前rdd元素不在后rdd的rdd
  leftOuterJoin	leftOuterJoin类似于SQL中的左外关联left outer join，返回结果以前面的RDD为主，关联不上的记录为空。只能用于两个RDD之间的关联，如果要多个RDD关联，多关联几次即可。
  rightOuterJoin	rightOuterJoin类似于SQL中的有外关联right outer join，返回结果以参数中的RDD为主，关联不上的记录为空。只能用于两个RDD之间的关联，如果要多个RDD关联，多关联几次即可
  subtractByKey	substractByKey和基本转换操作中的subtract类似只不过这里是针对K的，返回在主RDD中出现，并且不在otherRDD中出现的元素

• Action

  触发代码执行，一段spark代码至少需要一个action

  Action	含义
  reduce(func)	通过func函数聚集RDD中的所有元素，这个功能必须是课交换且可并联的
  collect()	在驱动程序中，以数组的形式返回数据集的所有元素
  count()	返回RDD的元素个数
  first()	返回RDD的第一个元素（类似于take(1)）
  take(n)	返回一个由数据集的前n个元素组成的数组
  takeSample(withReplacement,num, [seed])	返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子
  takeOrdered(n, [ordering])
  saveAsTextFile(path)	将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
  saveAsSequenceFile(path)	将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
  saveAsObjectFile(path)
  countByKey()	针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。
  foreach(func)	在数据集的每一个元素上，运行函数func进行更新。
  aggregate	先对分区进行操作，在总体操作
  reduceByKeyLocally
  lookup
  top
  fold
  foreachPartition

Spark任务基础概念

• Application

  driver程序以及集群执行的代码

• driver

  创建sc，加载数据集，处理数据以及展示流程

• 集群节点

  driver：创建sc，启动spark级集群计算任务

  master：master节点

  worker：集群任务执行节点，启动executor进程

  Executor：执行应用程序以及汇报执行状态

  cluster manager：集群资源管理器，负责申请资源调度任务，如yarn

• jobs

  RDD中的action，每个action变为一个job，然后DAGScheduler回分解stage执行

• stage

  一个job拆分为多组task，每组是一个stage

• task

  送到executor执行的工作单元，两类：shuffleMapTask：输出shffle所需要的数据；resultTask：无需shuffle直接返回处理结果

• partition

  数据划分

• cores

  worker执行进程

• memory

  内存设置

• shuffle

  stage之间的数据拷贝

窄依赖与宽依赖

窄依赖：每个RDD只会被一个子RDD所依赖，例如map、filter、union等操作都会产生窄依赖；（独生子女）

宽依赖：每个RDD被多个子RDD所依赖，例如groupByKey、reduceByKey、sortByKey等操作都会产生宽依赖；（超生）

关于join的依赖关系：

两个RDD在进行join操作时，一个RDD的partition仅仅和另一个RDD中已知个数的Partition进行join，那么这种类型的join操作就是窄依赖。否则就是宽依赖。

DAG图与宽窄依赖

DAGScheduler遇到action job时，会根据宽窄依赖决定stage划分。如果遇到窄依赖会将该action加入当前stage，遇到宽依赖则创建新的stage去执行

https://www.conventionalcommits.org/en/v1.0.0/

https://www.ruanyifeng.com/blog/2016/01/commit_message_change_log.html

Specification

1
2
3
4
5

<type>[optional scope]: <description>

[optional body]

[optional footer(s)]

Types:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

abaliable types:
[
  'build',
  'chore',
  'ci',
  'docs',
  'feat',
  'fix',
  'perf',
  'refactor',
  'revert',
  'style',
  'test'
];

description:
feat：新功能（feature）
fix：修补bug
docs：文档（documentation）
style： 格式（不影响代码运行的变动）
refactor：重构（即不是新增功能，也不是修改bug的代码变动）
test：增加测试
chore：构建过程或辅助工具的变动

Examples

Commit message with description and breaking change footer

1
2
3

feat: allow provided config object to extend other configs

BREAKING CHANGE: `extends` key in config file is now used for extending other config files

Commit message with ! to draw attention to breaking change

1

feat!: send an email to the customer when a product is shipped

Commit message with scope and ! to draw attention to breaking change

1

feat(api)!: send an email to the customer when a product is shipped

Commit message with both ! and BREAKING CHANGE footer

1
2
3

chore!: drop support for Node 6

BREAKING CHANGE: use JavaScript features not available in Node 6.

Commit message with no body

1

docs: correct spelling of CHANGELOG

Commit message with scope

1

feat(lang): add Polish language

Commit message with multi-paragraph body and multiple footers

1
2
3
4
5
6
7
8
9
10

fix: prevent racing of requests

Introduce a request id and a reference to latest request. Dismiss
incoming responses other than from latest request.

Remove timeouts which were used to mitigate the racing issue but are
obsolete now.

Reviewed-by: Z
Refs: #123

Others

idea plugins: git commit template

hangelog generate & commit message validate

如果我们要在分布式计算里面分发大对象，例如：字典，集合，黑白名单等，这个都会由Driver端进行分发，一般来讲，如果这个变量不是广播变量，那么每个task就会分发一份，这在task数目十分多的情况下Driver的带宽会成为系统的瓶颈，而且会大量消耗task服务器上的资源，如果将这个变量声明为广播变量，那么知识每个executor拥有一份，这个executor启动的task会共享这个变量，节省了通信的成本和服务器的资源。

使用方式

1
2
3
4
5
6

# create
val a = 3
val broadcast = sc.broadcast(a)

# use
val c = broadcast.value

注意事项

1、能不能将一个RDD使用广播变量广播出去？

不能，因为RDD是不存储数据的。**可以将RDD的结果广播出去。**

2、 广播变量只能在Driver端定义，不能在Executor端定义。

3、 在Driver端可以修改广播变量的值，在Executor端无法修改广播变量的值。

4、如果executor端用到了Driver的变量，如果不使用广播变量在Executor有多少task就有多少Driver端的变量副本。

5、如果Executor端用到了Driver的变量，如果使用广播变量在每个Executor中只有一份Driver端的变量副本。

累加器

在spark应用程序中，我们经常会有这样的需求，如异常监控，调试，记录符合某特性的数据的数目，这种需求都需要用到计数器，如果一个变量不被声明为一个累加器，那么它将在被改变时不会再driver端进行全局汇总，即在分布式运行时每个task运行的只是原始变量的一个副本，并不能改变原始变量的值，但是当这个变量被声明为累加器后，该变量就会有分布式计数的功能。

使用方式

1
2
3
4
5

# create
val a = sc.accumulator(0)

# use
val b = a.value

注意事项

累加器在Driver端定义赋初始值，累加器只能在Driver端读取最后的值，在Excutor端更新。

1.安装ss客户端和kcp客户端

• kcp客户端：https://github.com/xtaci/kcptun/releases 选择对应版本下载即可
• shadowsocks客户端linux版本：https://github.com/shadowsocks/shadowsocks-rust/releases 选择对应版本

2.修改配置启动kcp与ss客户端

2.1 配置

• 创建kcp.json, 主要配置远程vps服务地址以及本地端口如: :10080
• 创建ss.json, 配置服务地址为kcp配置的本地端口，本地端口设置如：10088

2.2 启动

1
2

kcp-client -c kcp.json
sslocal -c ss.json

3.开启全局代理

1
2

export ALL_PROXY="socks5://代理服务器IP地址:代理端口"  # 开启sock代理
unset ALL_PROXY  # 关闭代理

4.使用polipo将socks代理转为http代理

1
2
3

apt install polipo
修改配置：/etc/polipo/config： 协议端口指定为socks地址
service start polipo

开启代理：

1
2

export HTTP_PROXY=http://xxxx:xxx
export HTTPS_PROXY=https://xxxx:xxx

5.开启代理后python使用requets报错

错误信息：ValueError: check_hostname requires server_hostname

解决方式：降低urllib3版本至1.25.8

Git 一般只添加数据, 你执行的 Git 操作，几乎只往 Git 数据库中增加数据。 很难让Git 执行任何不可逆操作，或者让它以任何方式清除数据。 同别的 VCS 一样，未提交更新时有可能丢失或弄乱修改的内容;但是一旦你提交快照到 Git 中，就难以再丢失数据，特别是如果你定期的推送数据库到其它仓库的话。

• Workspace：工作区

• Index/Stage：暂存区，也叫索引

• Repository：仓库区（或本地仓库），也存储库

• Remote：远程仓库

这使得我们使用 Git 成为一个安心愉悦的过程，因为我们深知可以尽情做各种尝试，而没有把事情弄糟的危险。 更深度探讨 Git 如何保存数据及恢复丢失数据的话题，请参考撤消操作。

1. 历史操作记录

   1 2 3 4 5 6

   git log # 查看历史操作记录 git log --oneline # 简洁版本的历史操作记录 git log --graph # 拓扑图选项 git log --reverse # 逆向显示日志 git log --auther=auther # 查看auther的提交 # 指定日期，可以执行几个选项：--since 和 --before，也可以用 --until 和 --after。

2. 查看当前仓库状态

   1	git status # 查看当前仓库状态

3. 推送

   1 2 3

   git add * # 添加至暂存区 git commit -m "commit message" # 提交 git push origin master # 推送至远程仓库master分支

4. 更新与拉取

   1 2	git clone http://xxx.com/xxx.git # clone远程仓库 git pull # 获取新更改

5. 暂存区保留临时更改

   1 2 3

   git stash # 本地更改暂存 git stash list # 列出本地暂存数据 git stash pop # 恢复

6. 移动

   对于仓库的文件做移动

   1 2	git mv xxx yyy # xxx移动/重命名到yyy, git文件前显示R表示已被重命名 git commit -a -m "rename xxx to yyy" # -a标志，这使git commit自动检测修改的文件

7. 删除

   1 2	git rm xxx # 删除xxx文件 git commit -a -m "remove file xxx"

todo: http://www.bjpowernode.com/tutorial_git/1775.html

1. 创建UML类图

   1 2	<pre class="mermaid"> classDiagram // 以上为固定写法,此处开始创建对象与关系</pre>

2. 类与接口

   • 创建

     1 2 3

     class A { }

          classDiagramclass A {    }

   • 类型

     符号	类型
     <>	接口
     <>	抽象类
     <>	service类
     <>	枚举

     使用方式:

     1 2 3 4 5 6 7 8

     // 方式一：内嵌 class A { <<Interface>> } // 方式二：单独的行 class B <<Interface>> B

          classDiagramclass A {    <>}class B<> B

   • 属性

     两种方式内联和单独指定

     方式一:

     1 2 3 4 5 6 7

     class A A : +String name A : -int age A : List~Object~ child //泛型变量 A : +eat() A : +sleep(time) //有参数的方法 A : +getAge() int //有返回值的方法

          classDiagramclass AA : +String nameA : -int ageA : List~Object~ child    //泛型变量A : +eat()A : +sleep(time)          //有参数的方法A : +getAge() int         //有返回值的方法

     方式二:

     1 2 3 4 5 6 7 8

     class B { +String name -int age List~Object~ child +eat() +sleep(time) +getAge() int }

          classDiagramclass B {    +String name    -int age    List~Object~ child    +eat()    +sleep(time)    +getAge() int}

     元素可见范围:

     修饰符号	可见范围
     -	private
     +	public
     #	protected
     ~	package

3. 关系

   • 继承

     表示子类继承父类的所有特征和行为

     1	ClassA <|-- ClassB // class B extends A

          classDiagramClassA <|-- ClassB

   • 实现

     类是接口所有特征和行为的实现

     1	InterfaceA <|.. ClassB // class B implements interface A

          classDiagramInterfaceA <|.. ClassB

   • 组合/聚合

     组合: 整体与部分的关系，但部分不能离开整体而单独存在 带实心菱形的实线，实心菱形指向整体

     聚合: 整体与部分的关系，且部分可以离开整体而单独存在 带空心菱形的实现，空心菱形指向整体。

     1	ClassA *-- ClassB // class B is part of A

          classDiagramClassA *-- ClassB

   • 关联

     一个类知道另一个类的属性和方法；关联可以是双向的，也可以是单向的。双向的关联可以有两个箭头或者没有箭头，单向的关联有一个箭头

     1 2	ClassA -- ClassB ClassC <-- ClassD

          classDiagramClassA -- ClassBClassC <-- ClassD

   • 依赖

     一个类的实现需要另一个类的协助

     1	ClassA <.. ClassB

          classDiagramClassA <.. ClassB

   • 关系标识

     • 关系上添加标签

       1	ClassA <.. ClassB : 依赖

              classDiagramClassA <.. ClassB : 依赖

     • 关系上添加数量

       符号	含义
       1	1个
       0..1	0或1个
       1..*	1个或多个
       *	任意个
       n	n个(n>1)
       0..n	0个到n个(n>0)
       1..n	1到n个(n>1)

       1	ClassA "1" --> "*" ClassB

              classDiagramClassA "1" --> "*" ClassB

4. 例子

classDiagramclass Parent {  <>    +String name    -int age    #List children    ~Float weight    +eat()    +sleep()}class Child {    +String toy    -Integer grade}Parent "1" <|-- "*" Child : 继承

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。

为了让您更好地理解问题，以下面的二叉搜索树为例：

我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。

下图展示了上面的二叉搜索树转化成的链表。“head” 表示指向链表中有最小元素的节点。

特别地，我们希望可以就地完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中的第一个节点的指针。

思路: 可以将整颗树的转化分解为左子树转化和右子树转化. 然后对于左子树转化后的结果获取头尾节点更新与当前根节点的指针即可, 右子树同样如此

代码:

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

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val,Node _left,Node _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
    public Node treeToDoublyList(Node root) {
         if(root == null) { 
             return null;
         }
         // 返回节点,默认当前根节点
         Node ret = root;
         // 尾结点,默认根节点
         Node end = root;
         Node left = root.left;
         Node right = root.right;
         // 左侧双向链表
         Node linkLeft = treeToDoublyList(left);
         // 右侧双向链表
         Node linkRight = treeToDoublyList(right);
         if(linkLeft != null) {
             ret = linkLeft;
             Node tmp = linkLeft;
             // 这里是寻找子树尾结点(后续可以优化)
             while(tmp.right != null) {
                 if(tmp.right == linkLeft){
                     break;
                 }
                 tmp = tmp.right;
             }
             // 更新指针指向
             tmp.right = root;
             root.left = tmp;
         }
         if(linkRight != null) {
             Node tmp = linkRight;
             while(tmp.right != null) {
                 if(tmp.right == linkRight){
                     break;
                 }
                 tmp = tmp.right;
             }
             // 更新指针指向
             root.right = linkRight;
             linkRight.left = root;
             // 更新头尾节点的指向关系
             tmp.right = ret;
             ret.left = tmp;
         } else {
             ret.left = root;
             root.right = ret;
         }
         return ret;
    }
}

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

1
2
3

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

思路: 先遍历找到第一个累加到大于等于target的索引值idx,找不到就返回0. 随后设置左指针为0, 右指针为idx. 通过控制左右指针移动寻找最短连续子数组长度

代码:

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

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        // 最短长度
        int match = nums.length;
        // 当前累计和
        int sum = 0;
        // 从0开始第一个累计和达到target的索引
        int beginIdx = -1;
        for(int i = 0; i < nums.length; i++) {
            sum += nums[i];
            if(sum >= target) {
                beginIdx = i;
                break;
            }
        }
        if(beginIdx == -1) {
            return 0;
        }
        int l = 0;
        int r = beginIdx;
        while(l <= r && r < nums.length) {
            if(sum >= target) {
                match = Math.min(match, r - l + 1);
                if(match == 1) {
                    return 1;
                }
                // 当前sum满足条件,尝试左指针右移并更新sum
                sum -= nums[l];
                l++;
            } else {
                // 当前sum不满足条件,右指针右移并更新sum
                r++;
                if(r >= nums.length){
                    break;
                }
                sum += nums[r];
            }
        }
        return match;
    }
}

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random –> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random –> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

val：一个表示 Node.val 的整数。
random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。
你的代码 只 接受原链表的头节点 head 作为传入参数。

1
2

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

思路：首先遍历原链表，并在遍历过程中创建复制节点，并且维护一个新旧节点的映射关系。然后第二次遍历时，根据映射关系，找出每一个random节点在新链表的节点并指向它。

代码：

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

class Solution {
    public Node copyRandomList(Node head) {
        if(head == null) {
            return head;
        }
        Map<Node, Node> nmap = new HashMap();
        Node bak = head;
        Node node = new Node(head.val);
        Node nodebak = node;
        Node ret = node;
        nmap.put(head, node);
        head = head.next;
        while(head != null) {
            Node next = new Node(head.val);
            nmap.put(head, next);
            node.next = next;
            node = node.next;
            head = head.next;
        }
        while(bak!=null){
            Node radom = bak.random;
            Node rnode = nmap.get(radom);
            nodebak.random = rnode;
            nodebak = nodebak.next;
            bak = bak.next;
        }
        return ret;
    }
}

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

1
2
3
4

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

思路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

class Solution {
    int max = 0;
    public int rob(int[] nums) {
        rob(nums, 0, 0, null);
        return max;
    }

    /**
     * home 当前偷到哪一个房子了
     * money 当前偷了多少钱了
     * last 最后一个偷的房间
     */
    public void rob(int[] nums, int home, int money, Integer last) {
        max = Math.max(max, money);
        if(home >= nums.length) {
            return;
        }
        for(int i = home; i < nums.length; i++) {
            if(last == null) {
                rob(nums, i, nums[i] + money, i);
            } else {
                // 确认不会触发报警
                if(i > last + 1) {
                    // 偷,然后继续下一个房间
                    rob(nums, i, nums[i] + money, i);
                }
            }
            if(last == null) {
                rob(nums, i+1, money, i+1);
            } else {
                if(i > last + 1) {
                    // 不偷,继续下一个房间
                    rob(nums, i + 1, money, i + 1);
                }

            }
        }
    }
}

思路2: 动态规划, 定义dp数组, dp[i] 代表到第i位最大的金额,存在状态转移关系:

1
2

dp[i] = nums[i] i == 0
dp[i] = max(nums[i], dp[i-1], dp[i-1]) i > 0, i > 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

class Solution {
    int max = 0;
    public int rob(int[] nums) {
        int length = nums.length;
        int[] dp = new int[length];
        for(int i = 0; i < length; i++) {
            if(i == 0) {
                dp[i] = nums[i];
            } else {
                int last = i - 2;
                int last2 = i - 1;
                if(last2 >= 0) {
                    dp[i] = Math.max(dp[i], dp[i - 1]);
                }
                if(last >= 0) {
                    dp[i] = Math.max(dp[last] + nums[i], dp[i]);
                } 
                dp[i] = Math.max(dp[i], nums[i]);
                
            }
        }
        return dp[length - 1];
    }
}

给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。

整数除法仅保留整数部分。

你可以假设给定的表达式总是有效的。所有中间结果将在 [-231, 231 - 1] 的范围内。

注意：不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。

1
2

输入：s = "3+2*2"
输出：7

思路: 维护一个操作符栈和操作数栈以及操作符优先级字典. 流程如下: 遇到数字入栈,遇到操作符,如果优先级小于已入栈的操作符, 计算之前大于该操作符的操作,并将计算结果入栈操作数栈. 然后入栈新操作符,重复以上操作. 最终返回操作符栈剩下的结果即可.

代码:

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

class Solution {
    public int calculate(String s) {
        Stack<Integer> nums = new Stack();
        Stack<Character> ops = new Stack();
        StringBuilder sb = new StringBuilder();
        Map<Character, Integer> pmap = new HashMap();
        pmap.put('+', 1);
        pmap.put('-', 1);
        pmap.put('*', 2);
        pmap.put('/', 2);
        for(int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(c == ' ') {
                if(!sb.isEmpty()) {
                    nums.push(Integer.parseInt(sb.toString()));
                    sb = new StringBuilder();
                }
                continue;
            }
            if(pmap.containsKey(c)) {
                if(!sb.isEmpty()) {
                    nums.push(Integer.parseInt(sb.toString()));
                    sb = new StringBuilder();
                }
                if(ops.isEmpty()) {
                    ops.push(c);
                }else {
                    while(!ops.isEmpty() && pmap.get(ops.peek()) >= pmap.get(c)) {
                        int v2 = nums.pop();
                        int v1 = nums.pop();
                        nums.push(calc(v1, v2, ops.pop()));   
                    }
                    ops.push(c);
                }
            } else {
                sb.append(c);
            }
        }
        if(!sb.isEmpty()) {
            nums.push(Integer.parseInt(sb.toString()));
        }
        while(!ops.isEmpty()){
            int v2 = nums.pop();
            int v1 = nums.pop();
            nums.push(calc(v1, v2, ops.pop()));
        }
        return nums.pop();
    }

    public int calc(int v1, int v2, char op) {
        switch(op) {
            case '+':
                return v1 + v2;
            case '-':
                return v1 - v2;
            case '*':
                return v1 * v2;
            case '/':
                return v1 / v2;
            default:
                return 0;
        }
    }
}

栈, 堆, 树, 图

1. 数组

2. 链表

   优点:

   缺点: 节点内存不连续, 无法很好的利用CPU缓存. 同时链表需要维护指针带来的内存开销

外企面试，英文自我介绍是必答题，是送分题。

无论是电话面试，还是face to face面试，只要能流利，语速适度的完成1分钟左右自我介绍，基本都可以通关。

而大部分面试者，要么没有准备，要么磕磕巴巴，要么自我介绍太长，要么语速过快……

如果你面试环节的自我介绍被面试官打断了，99%是个失败的自我介绍。

01 自我介绍方程式

A. For New Graduates 毕业生自我介绍

我叫小小，xx大学，xx专业毕业。大学期间我顺利通过xx级，xx级，拿到xx证书，我的平均成绩都在Top xx，我是xx协会的xx，是xx志愿者，我在平时还参加了xx实践项目。我熟练掌握英语、计算机和xx，精通office软件，具有(可以开始说你的各种能力)良好的沟通能力，xx能力，xx能力，xx能力，和人际交往能力….我相信我很适合xx职位.谢谢。

I am Xiao Xiao. I recently graduated from ×× University with a bachelor degree in Business Accounting. My GPA was among the top 3 in my class. I passed CET6. Besides studying I was very active on campus. I participated in volunteer activities whenever I had time. I became the Chairman for the Student Union during my senior year. I also worked with Baidu as a Social Media Intern for a semester. I learned a lot about content curation and using social media tools. I could speak （pretty） good English and I’m fluent in Mandarin Chinese (Hahaha…因为我是中国人). I am highly proficient with Office. I have great communication skills. I am an outgoing person. I am very responsible and hardworking. I believe I’m a good fit for the Department Assistant position. Thank you for the opportunity.

描述顺序拆解：

B. For Working Professionals 有工作经验自我介绍

我是小小，具有xx年xx领域的经验，现在是xx公司xx职位。之前是有xx年xx行业经验，xx行业xx经验。我的专长是xx比如说品牌管理和业务发展。我也很擅长xx比如说项目管理和活动策划。我英语很好英语、计算机和xx，擅长xx， 在工作中，我曾经获得xx等奖项。我有优秀的沟通技能，有很强的团队精神和自我驱动力。我相信以我的经验和热情我能够在xx岗位上给xx公司的成功做出贡献。谢谢。

I am Xiao Xiao. I have over 8 years of experience in marketing. I am the team manager of marketing for HP since 2013. Previously I worked in IT for a year and retail for another 4 years or so. My specialties include brand management and business development. I’m also very experienced with project management and event coordination. I was voted the 2016 Best Employee among my peers. I could speak （pretty） good English and I’m fluent in Mandarin Chinese(Hahaha…因为我是中国人). I am highly proficient with Microsoft Office softwares and Photoshop. I have excellent written and verbal communication skills. I’m a team player and self-driven. I believe I have the combination of experience and enthusiasm to contribute to the success of Intel Shanghai as the Senior Manager of Marketing. Thanks.

描述顺序拆解：

C. Top 10个常用句型

计算机和英语证书

I am highly proficient with…

学习成绩优秀

My grades were top in the class.

社团/志愿者/实践项目

I was very active on campus.

I’ve participated in many campus groups, volunteer programs, and practical activities

具备能力

I’m passionate about…

I’m very familiar with…

I’m experienced with…

行业经验

I’ve work in marketing/sales/business development/international education for X years

管理经验

I have x years of management experiences

项目经验

I took the lead in xxx project which was very successful.

获奖经历

I was recognized as…

I was awarded the…

I was voted the…

性格特质

I’m a people person.

I’m a team player.

I’m very hardworking.

I’m super self-driven.

职位匹配描述

I believe I have the right combination of experience and enthusiasm to be successful in xxx position.

I believe I am a good fit for xxx company as the xxx position.

I believe I can do a great job as your xxx.

D: General Skill list 通用技能列表

Personality and Characteristics 好用的性格和特征

A people person; 善于与人打交道的人

A team player; 善于团队合作的人

A good listener;好的倾听者

A good leader; 好的领导

An analytical thinker; 善于分析的思考者

Hard working; 勤奋的

Self-motivated;有上进心的，积极主动的

Very driven;自我驱动很强的

Adaptable; 适应能力不错

Energetic;精力充沛的

Proactive;积极主动的

Business oriented;商业/业务导向的

Results oriented;结果导向的

High attention to detail; 非常关注细节

Skills 技能

Excellent communication skills; 卓越的沟通技能

Outstanding organization skills; 出众的组织技能

Great verbal and written communication
skills in English and Chinese; 优秀的中英文口语和书面交流技能

Good interpersonal skills; 很好的交际能力

Fantastic organizational skills; 极好组织能力

Excellent time management skills;卓越的时间管理技能

Fantastic negotiation skills；极好的谈判技能

Strong analytical skills; 很强的分析能力

Highly proficient in PC skills.精通电脑

Abilities 能力

Ability to work effectively with staff at all levels; 能和各个级别员工高效工作

Ability to interpret financial statements/statistics; 解释财务报表/统计数据的能力

Strong problem solving ability; 较强的问题处理能力

Strong business acumen; 良好的商业敏感度

Ability to prioritize and work within tight timeframe; 能在时间紧迫的情况下安排工作优先等级

Excellent research ability; 优秀的研究/调研能力

Very familiar with labor law and related policies in China; 非常熟悉劳动法和中国的相关政策法规

Fluent in both English and Mandarin Chinese;英语和中文都很流利

Tech savvy；科技通

Ability to adapt quickly to any new accounting/information system; 能够迅速适应任何新会计/信息系统

Computer skills 电脑技能

Good at Office 精通 Office

Proficient in Photoshop 精通PS

High proficiency in PowerPoint 精通PPT

Advanced level proficiency in Excel 精通Excel

Certificate List 证书列表

CET-4;四级

CET-6;六级

Certificate of English Interpreting:
Preliminary; 英语初级口译

Certificate of English Interpreting:
Intermediate; 英语中级口译

Certificate of English Interpreting:
Advanced; 英语高级口译

Certificate of Teachers’Qualification (English); 教师资格证书

Certificate of Mandarin Test.普通话测试证书

……

Personality and characteristics 更多性格特质形容词

aggressive有进取心的,攻击性的 (这不是一个好的特质，听起来像是很有野心)

passionate/enthusiastic 热情的

creative 富有创造性（力）的

insightful 富有洞察力的

diligent 好学的,勤奋的

liberal 慷慨的,不拘泥的,宽大的

nice 友善的

Kind 善良的

friendly 友善的

considerate考虑周到的,体谅的

humorous 幽默的

confident 自信的

imaginative 富想像力的

responsible 负责的

courageous 勇敢的

independent 独立的

demanding 要求多的 （a demanding position对员工要求很多，很高的职位）

individualistic 个人主义的

efficient 效率高的,有能力的

energetic 精力旺盛的

loyal 忠诚的

modest 谦虚的

thoughtful 考虑周到的

motivated 有动力的

positive/optimistic 积极的/乐观的

open-minded 思想开明的

trustworthy 值得信赖的

gentle 温文尔雅的

precise 精确的

good-natured 脾气好的,温厚的

idealistic 理想主义的

witty 急智的

wise 明智的,聪明的

smart/intelligent/clever 聪明的

outgoing/sociable 爱好交际的

easy-going 随和的,跟谁都处得来

*redis存储访问流程

• redisDb 结构，表示 Redis 数据库的结构，结构体里存放了指向了 dict 结构的指针；
• dict 结构，结构体里存放了 2 个哈希表，正常情况下都是用「哈希表1」，「哈希表2」只有在 rehash 的时候才用；
• ditctht 结构，表示哈希表的结构，结构里存放了哈希表数组，数组中的每个元素都是指向一个哈希表节点结构（dictEntry）的指针；
• dictEntry 结构，表示哈希表节点的结构，结构里存放了 void * key 和 void * value 指针， *key 指向的是 String 对象，而 *value 则可以指向 String 对象，也可以指向集合类型的对象，比如 List 对象、Hash 对象、Set 对象和 Zset 对象。

string：字符串

redis使用c语言开发, 在redis中，其自己定义了一种字符串格式，叫做SDS（Simple Dynamic String），即简单动态字符串. 结构定义sds.h:

1

typedef char *sds;

sds包含以下属性:

• len：已使用的长度，即字符串的真实长度. 降低获取字符串长度复杂度到O(1). 同时帮助二进制安全
• alloc：分配的长度, 除去标头和终止符(‘\0’)后的长度. 减少而内存分配次数
• flags：表示不同类型的SDS, 低3位表示
• buf[]：存储字符数据

list：列表

使用双向链表, 获取节点前后节点时间复杂度O(1),获取头尾节点也是O(1). 同时链表使用指针保存值, 可以保存各种类型的数据.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

typedef struct list {
    //链表头节点
    listNode *head;
    //链表尾节点
    listNode *tail;
    //节点值复制函数
    void *(*dup)(void *ptr);
    //节点值释放函数
    void (*free)(void *ptr);
    //节点值比较函数
    int (*match)(void *ptr, void *key);
    //链表节点数量
    unsigned long len;
} list;

• ziplist

  

  相比链表, 设计为更为内存紧凑的数据结构, 可以有效利用CPU缓存. 而且针对不同长度数据进行编码以节省内存开销. 同样存在缺陷: 不可以保存过多的元素,新增修改元素时,内存需要重分配和引发连锁更新问题.

  • zlbytes：4个字节（32bits），表示ziplist占用的总字节数
  • zltail：4个字节（32bits），表示ziplist中最后一个节点在ziplist中的偏移字节数
  • entries：2个字节（16bits），表示ziplist中的元素数
  • entry：长度不定，表示ziplist中的数据 (内部包含prevlen: 记录前一个节点长度(如果内存重新分配,后续的该字段都要更新,造成性能下降–连锁更新问题), encoding: 记录当前节点类型与长度, data: 数据)
  • zlend：1个字节（8bits），表示结束标记，这个值固定为ff（255）

  这些数据均为小端存储，所以可能有些人查看数据的二进制流与其含义对应不上，其实是因为读数据的方式错了

  ziplist内部采取数据压缩的方式进行存储，压缩方式就不是重点了，我们仅从宏观来看，ziplist类似一个封装的数组，通过zltail可以方便地进行追加和删除尾部数据、使用entries可以方便地计算长度

  但是其依然有数组的缺点，就是当插入和删除数据时会频繁地引起数据移动，所以就引出了quicklist数据类型

• quick list

  「双向链表 + 压缩列表」组合，因为一个 quicklist 就是一个链表，而链表中的每个元素又是一个压缩列表。

  

• listpack

  

hash：散列表

• 哈希冲突
• 链式哈希
• rehash
• 渐进式 rehash
• rehash 触发条件

set：无序集合

整数集合是 Set 对象的底层实现之一。当一个 Set 对象只包含整数值元素，并且元素数量不时，就会使用整数集这个数据结构作为底层实现。

• 整数集合

zset：有序集合

内部使用跳表

• 跳表

待补充

问题描述

1
2
3
4
5

JAVA的client和server，使用socket通信。server使用NIO。
1.间歇性的出现client向server建立连接三次握手已经完成，但server的selector没有响应到这连接。
2.出问题的时间点，会同时有很多连接出现这个问题。
3.selector没有销毁重建，一直用的都是一个。
4.程序刚启动的时候必会出现一些，之后会间歇性出现。

分析问题

• 第一步：client 发送 syn 到server 发起握手；
• 第二步：server 收到 syn后回复syn+ack给client；
• 第三步：client 收到syn+ack后，回复server一个ack表示收到了server的syn+ack（此时client的56911端口的连接已经是established）

从问题的描述来看，有点像TCP建连接的时候全连接队列（accept队列）满了，尤其是症状2、4. 为了证明是这个原因，马上通过 ss -s 去看队列的溢出统计数据：

1

667399 times the listen queue of a socket overflowed

反复看了几次之后发现这个overflowed 一直在增加，那么可以明确的是server上全连接队列一定溢出了

接着查看溢出后，OS怎么处理：

1
2

# cat /proc/sys/net/ipv4/tcp_abort_on_overflow
0

tcp_abort_on_overflow 为0表示如果三次握手第三步的时候全连接队列满了那么server扔掉client 发过来的ack（在server端认为连接还没建立起来）

为了证明客户端应用代码的异常跟全连接队列满有关系，我先把tcp_abort_on_overflow修改成 1，1表示第三步的时候如果全连接队列满了，server发送一个reset包给client，表示废掉这个握手过程和这个连接（本来在server端这个连接就还没建立起来）。

接着测试然后在客户端异常中可以看到很多connection reset by peer的错误，到此证明客户端错误是这个原因导致的。

于是开发同学翻看java 源代码发现socket 默认的backlog（这个值控制全连接队列的大小，后面再详述）是50，于是改大重新跑，经过12个小时以上的压测，这个错误一次都没出现过，同时 overflowed 也不再增加了。

到此问题解决，简单来说TCP三次握手后有个accept队列，进到这个队列才能从Listen变成accept，默认backlog 值是50，很容易就满了。满了之后握手第三步的时候server就忽略了client发过来的ack包（隔一段时间server重发握手第二步的syn+ack包给client），如果这个连接一直排不上队就异常了。

TCP握手创建流程

在 TCP 三次握手的过程中，Linux 内核会维护两个队列，分别是：

• 半连接队列 (SYN Queue)
• 全连接队列 (Accept Queue)

正常的 TCP 三次握手过程：

1. Client 端向 Server 端发送 SYN 发起握手，Client 端进入 SYN_SENT 状态
2. Server 端收到 Client 端的 SYN 请求后，Server 端进入 SYN_RECV 状态，此时内核会将连接存储到半连接队列(SYN Queue)，并向 Client 端回复 SYN+ACK
3. Client 端收到 Server 端的 SYN+ACK 后，Client 端回复 ACK 并进入 ESTABLISHED 状态
4. Server 端收到 Client 端的 ACK 后，内核将连接从半连接队列(SYN Queue)中取出，添加到全连接队列(Accept Queue)，Server 端进入 ESTABLISHED 状态
5. Server 端应用进程调用 accept 函数时，将连接从全连接队列(Accept Queue)中取出

半连接队列和全连接队列都有长度大小限制，超过限制时内核会将连接 Drop 丢弃或者返回 RST 包。

相关指标查看

• ss 命令

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  # -n 不解析服务名称 # -t 只显示 tcp sockets # -l 显示正在监听(LISTEN)的 sockets $ ss -lnt State Recv-Q Send-Q Local Address:Port Peer Address:Port LISTEN 0 128 [::]:2380 [::]:* LISTEN 0 128 [::]:80 [::]:* LISTEN 0 128 [::]:8080 [::]:* LISTEN 0 128 [::]:8090 [::]:* $ ss -nt State Recv-Q Send-Q Local Address:Port Peer Address:Port ESTAB 0 0 [::ffff:33.9.95.134]:80 [::ffff:33.51.103.59]:47452 ESTAB 0 536 [::ffff:33.9.95.134]:80 [::ffff:33.43.108.144]:37656 ESTAB 0 0 [::ffff:33.9.95.134]:80 [::ffff:33.51.103.59]:38130 ESTAB 0 536 [::ffff:33.9.95.134]:80 [::ffff:33.51.103.59]:38280 ESTAB 0 0 [::ffff:33.9.95.134]:80 [::

  LISTEN状态Socket

  • Recv-Q：当前全连接队列的大小，即已完成三次握手等待应用程序 accept() 的 TCP 链接
  • Send-Q：全连接队列的最大长度，即全连接队列的大小

  非LISTEN状态Socket

  • Recv-Q：已收到但未被应用程序读取的字节数
  • Send-Q：已发送但未收到确认的字节数

• netstat命令

  通过 netstat -s 命令可以查看 TCP 半连接队列、全连接队列的溢出情况

  1 2 3

  $ netstat -s | grep -i "listen" 189088 times the listen queue of a socket overflowed 30140232 SYNs to LISTEN sockets dropped

  上面输出的数值是累计值，分别表示有多少 TCP socket 链接因为全连接队列、半连接队列满了而被丢弃

  • 189088 times the listen queue of a socket overflowed 代表有 189088 次全连接队列溢出
  • 30140232 SYNs to LISTEN sockets dropped 代表有 30140232 次半连接队列溢出

  在排查线上问题时，如果一段时间内相关数值一直在上升，则表明半连接队列、全连接队列有溢出情况

其他内容待补充, 参考文首链接

一、结构化数据

结构化的数据是指可以使用关系型数据库表示和存储，表现为二维形式的数据。一般特点是：数据以行为单位，一行数据表示一个实体的信息，每一行数据的属性是相同的。举一个例子：

1
2
3
4

id      name            age     gender
1       Liu Yi          20      male
2       Chen Er         35      female
3       Zhang San       28      male

所以，结构化的数据的存储和排列是很有规律的，这对查询和修改等操作很有帮助。

但是，它的扩展性不好。比如，如果字段不固定，利用关系型数据库也是比较困难的，有人会说，需要的时候加个字段就可以了，这样的方法也不是不可以，但在实际运用中每次都进行反复的表结构变更是非常痛苦的，这也容易导致后台接口从数据库取数据出错。你也可以预先设定大量的预备字段，但这样的话，时间一长很容易弄不清除字段和数据的对应状态，即哪个字段保存有哪些数据。

二、半结构化数据

半结构化数据是结构化数据的一种形式，它并不符合关系型数据库或其他数据表的形式关联起来的数据模型结构，但包含相关标记，用来分隔语义元素以及对记录和字段进行分层。因此，它也被称为自描述的结构。

半结构化数据，属于同一类实体可以有不同的属性，即使他们被组合在一起，这些属性的顺序并不重要。

常见的半结构数据有XML和JSON，对于对于两个XML文件，第一个可能有

1
2
3
4
5

<person>
    <name>A</name>
    <age>13</age>
    <gender>female</gender>
</person>

复制

第二个可能为：

1
2
3
4

<person>
    <name>B</name>
    <gender>male</gender>
</person>

复制

从上面的例子中，属性的顺序是不重要的，不同的半结构化数据的属性的个数是不一定一样的。有些人说半结构化数据是以树或者图的数据结构存储的数据，怎么理解呢？上面的例子中，标签是树的根节点，和标签是子节点。通过这样的数据格式，可以自由地表达很多有用的信息，包括自我描述信息（元数据）。所以，半结构化数据的扩展性是很好的。

三、非结构化数据

非结构化数据是数据结构不规则或不完整，没有预定义的数据模型，不方便用数据库二维逻辑表来表现的数据。包括所有格式的办公文档、文本、图片、各类报表、图像和音频/视频信息等等。

非结构化数据其格式非常多样，标准也是多样性的，而且在技术上非结构化信息比结构化信息更难标准化和理解。所以存储、检索、发布以及利用需要更加智能化的IT技术，比如海量存储、智能检索、知识挖掘、内容保护、信息的增值开发利用等。

四、应用场景

结构化数据，简单来说就是数据库。结合到典型场景中更容易理解，比如企业ERP、财务系统；医疗HIS数据库；教育一卡通；政府行政审批；其他核心数据库等。这些应用需要哪些存储方案呢？基本包括高速存储应用需求、数据备份需求、数据共享需求以及数据容灾需求。

非结构化数据，包括视频、音频、图片、图像、文档、文本等形式。具体到典型案例中，像是医疗影像系统、教育视频点播、视频监控、国土GIS、设计院、文件服务器（PDM/FTP）、媒体资源管理等具体应用，这些行业对于存储需求包括数据存储、数据备份以及数据共享等。

半结构化数据，包括邮件、HTML、报表、资源库等等，典型场景如邮件系统、WEB集群、教学资源库、数据挖掘系统、档案系统等等。这些应用对于数据存储、数据备份、数据共享以及数据归档 等基本存储需求。