<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[Neflibata_mo的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/Neflibata_mo</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; Neflibata_mo]]></copyright><item><title><![CDATA[学习笔记1：分类方法]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/120687766</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/120687766</guid><author>Neflibata_mo</author><pubDate>Sun, 10 Oct 2021 20:30:27 +0800</pubDate><description><![CDATA[名词：


偏差：描述的是预测值（估计值）的期望与真实值之间的差距。偏差越大，越偏离真实数据，如下图第二行所示。


方差：描述的是预测值的变化范围，离散程度，也就是离其期望值的距离。方差越大，数据的分布越分散，如下图右列所示。



泛化能力：机器学习算法对新鲜样本的适应能力。学习的目的是学到隐含在数据背后的规律，对具有同一规律的学习集以外的数据，经过训练的网络也能给出合适的输出，该能力称为泛化能力。


过拟合：


噪音数据：即无意义的数据，包含所有难以被机器正确理解和翻译的数据，如非结构化文本。..]]></description><category></category></item><item><title><![CDATA[java数据结构与算法 学习笔记2：栈]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/120250477</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/120250477</guid><author>Neflibata_mo</author><pubDate>Sun, 12 Sep 2021 14:46:45 +0800</pubDate><description><![CDATA[一、实现栈的思路：

使用数组来模拟栈
定义一个top表示栈顶，初始化为-1；
入栈的操作，当有数据加入栈时，top++；stack[top]=data;
出栈的操作，int value=stack[top];top–;return value;

二、代码演示
package com.stack;

import java.util.Arrays;
import java.util.Scanner;

public class ArrayStackDemo {
    public static void]]></description><category></category></item><item><title><![CDATA[java数据结构与算法 学习笔记2：队列]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/120208655</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/120208655</guid><author>Neflibata_mo</author><pubDate>Fri, 10 Sep 2021 20:01:31 +0800</pubDate><description><![CDATA[一、队列的应用场景
如银行排队
二、介绍

队列是一个有序列表，可以用数组或是链表来实现。
遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。

三、数组模拟队列的思路

队列本身是有序列表，若使用数组的结构来存储队列的数据，其中maxSize是该队列的最大容量。
因为队列的输入输出是分别从前后端来处理的，因此需要两个变量front和rear分别记录队列前后端的下标，front会随着数据输出而改变，rear随着数据输入而改变。
当我们将数据存入队列式称为“addQueue”，addQue]]></description><category></category></item><item><title><![CDATA[java数据结构与算法 学习笔记1：稀疏数组转换的思路]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/120188304</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/120188304</guid><author>Neflibata_mo</author><pubDate>Thu, 09 Sep 2021 19:44:03 +0800</pubDate><description><![CDATA[一、稀疏数组的应用场景

基本介绍：当一个数组中大部分元素为0或同一个值的数组时，可以使用稀疏数组来保存该数组。
处理方法：


记录数组一共有几行几列，有多少个不同的值。
把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。


应用场景：编写五子棋程序时，实现存盘退出和续上盘的功能。

二、
4. 二维数组转化为稀疏数组的思路：
遍历原始的二维数组，得到有效的数据的个数sum
根据sum就可以创建稀疏数组，sparseArr int[sum+1][3]
将二维数组的有效数据存入到稀]]></description><category></category></item><item><title><![CDATA[学习笔记 数据结构与算法]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119563499</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119563499</guid><author>Neflibata_mo</author><pubDate>Tue, 10 Aug 2021 10:18:11 +0800</pubDate><description><![CDATA[数据结构：

空间复杂度和时间复杂度

数据结构1 数组Array

数据结构2 链表（Linked List）

数据结构3 队列（Queue）

数据结构4 栈（Stack）

数据结构5 哈希表（Hash Table）

数据结构6 集合（Set）

数据结构7 树（Tree）

数据结构8 堆（Heap）

数据结构9 图（Graph）
算法：

算法

...]]></description><category></category></item><item><title><![CDATA[学习笔记 算法]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119522644</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119522644</guid><author>Neflibata_mo</author><pubDate>Mon, 09 Aug 2021 22:09:09 +0800</pubDate><description><![CDATA[一、 双指针

普通双指针：两个指针往同一个方向移动（有时不是同一个方向）
对撞双指针：两个指针面对面移动
快慢双指针：慢指针+快指针
例：a = [1,4,5,7,9]（有序数组）  两个数相加等于12，且两个数不能相同。
对撞双指针：

例：检测是否为环形链表
快慢双指针：慢指针每次循环移动一格，快指针移动两格，最终是否相遇。
二、 二分查找法
特点：一定要有序（数组元素单调增或单调减）
三、滑动窗口
目的：减少while循环
应用：数组中的定长问题
四、递归

定义：函数直接或者间接调用自己
四个要素]]></description><category></category></item><item><title><![CDATA[数据结构9 图（Graph）]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119522281</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119522281</guid><author>Neflibata_mo</author><pubDate>Sun, 08 Aug 2021 22:33:38 +0800</pubDate><description><![CDATA[图：


顶点：与树中的节点相同。
邻居节点
边：两个顶点之间的线
度：指一个顶点有几条边
顶点更像邻居关系，可以有多条路径。


分类：


无向图
有向图
权重图


有向图：


入度：多少边指向该顶点
出度：多少边从这个点指向别的顶点


权重图


算法：
贝尔曼-福特算法（Bellman-Ford）
狄克斯特拉算法（Dijkstra）
DFS
BFS


...]]></description><category></category></item><item><title><![CDATA[数据结构8 堆（Heap）]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119517007</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119517007</guid><author>Neflibata_mo</author><pubDate>Sun, 08 Aug 2021 17:28:01 +0800</pubDate><description><![CDATA[堆：一种二叉树的结构–完全二叉树，且每个节点的值都≥或≤孩子节点。
最大堆：每个节点的值都≥孩子节点（堆顶元素是最大值）
最小堆：每个节点的值都≤孩子节点（堆顶元素是最小值）
复杂度


访问（acess）：无
搜索：O(1) (堆顶)
添加：O（logN）
删除：O(logN） 一般是堆顶


Python常用操作

import heapq
//创建堆
minheap = []

//添加元素
heapq.heappush(minheap,10)
heapq.heappush(minheap,8)
h.]]></description><category></category></item><item><title><![CDATA[数据结构7 树（Tree）]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119516316</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119516316</guid><author>Neflibata_mo</author><pubDate>Sun, 08 Aug 2021 16:32:33 +0800</pubDate><description><![CDATA[树：描述的是一种父子关系。
节点：代表树中的元素。
根节点：第一个开始的节点
叶子节点：最底层的节点，没有孩子的节点
深度：从上往下计算，最下一层为0
高度：从下往上计算，最上一层为0
层：根节点作为第一层，从上往下计算。
二叉树：


普通二叉树：每个节点最多两个孩子
满二叉树：除了叶子结点，每个节点都有左右两个孩子，所有叶子结点在同一层上。
完全二叉树：从树的根节点，从上到下，从左到右依次填满节点形成的二叉树
满二叉树一定是完全二叉树


二叉树的遍历：


前序遍历:先访问根节点，然后访问左节点，最.]]></description><category></category></item><item><title><![CDATA[数据结构6 集合（Set）]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119507525</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119507525</guid><author>Neflibata_mo</author><pubDate>Sun, 08 Aug 2021 11:20:15 +0800</pubDate><description><![CDATA[特点：无序，不重复
主要作用：


检查某一个元素是否存在
是否有重复元素


HashSet：实质上背后是一张哈希表，元素通过哈希函数得到哈希值。
复杂度


访问: 没有这个方法
搜索：O(1)， 如果有hash碰撞的情况下，就不是O(1)了，为O(K), K为碰撞元素的个数
插入: O(1)； 有hash冲突O（k）
删除： O(1)； 有hash冲突O（k）


Python常用操作：

#创建集合
s = set()

#添加元素
s.add(1)
s.add(4)
s.add(3)
s.add.]]></description><category></category></item><item><title><![CDATA[数据结构5 哈希表（Hash Table）]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119489612</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119489612</guid><author>Neflibata_mo</author><pubDate>Sat, 07 Aug 2021 17:43:04 +0800</pubDate><description><![CDATA[键值对  key : value
哈希碰撞：两个不同的key通过同一个hash函数得到相同的内存地址
4通过哈希函数解析出的地址也是1，冲突了。
解决方法：
链表法， 在后面通过链表加入内存地址相同的值。
复杂度


访问: 没有这个方法
搜索：O(1)， 如果有hash碰撞的情况下，就不是O(1)了，为O(K), K为碰撞元素的个数
插入: O(1)
删除： O(1)


Python常用操作：


创建哈希表：

# 使用数组创建hash
hashTable = ['']x4
# 使用字典创建hash.]]></description><category></category></item><item><title><![CDATA[数据结构4 栈（Stack）]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119465451</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119465451</guid><author>Neflibata_mo</author><pubDate>Sat, 07 Aug 2021 00:09:18 +0800</pubDate><description><![CDATA[栈：先进后出。
基于链表创建的。
应用：浏览器后退功能。
复杂度：


访问: O(1)
只访问栈顶元素。
搜索：O(N)
插入: O(1)
只在栈的尾端插入。
删除： O(1)
只删除栈顶元素。


Python栈的常用操作：


创建栈

stack = []


添加元素

stack.append(1)
stack.append(2)
stack.append(3)


查看栈顶元素 – 即将出栈的元素

stack[-1]


删除栈顶元素 – 即将出栈的元素

temp = stack.pop.]]></description><category></category></item><item><title><![CDATA[数据结构3 队列（Queue）]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119462139</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119462139</guid><author>Neflibata_mo</author><pubDate>Fri, 06 Aug 2021 20:51:25 +0800</pubDate><description><![CDATA[队列：类似排队，先到先得。（比如：管道只有一端可以入队，另一端可以出队）
特点：先入先出。
单端队列：只有一个口可以进，一个口可以出。
双端队列：两个端都利用进，两个端都可以出。（分方向）
复杂度：


访问: O(N)
搜索：O(N)
插入: O(1)
删除： O(1)


python队列常用操作：


创建队列

queue = deque()


添加元素

queue.append(1)
queue.append(2)
queue.append(3)
print(queue)   #[1,2,3.]]></description><category></category></item><item><title><![CDATA[数据结构2 链表（Linked List）]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119457587</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119457587</guid><author>Neflibata_mo</author><pubDate>Fri, 06 Aug 2021 17:12:26 +0800</pubDate><description><![CDATA[链表：非连续空间，包含当前数据和下一节点的地址。
单端链表：只能从前一个元素指向后一个元素。
双端链表：可以向下移动，也可以向前移动。
复杂度：


访问（access） O（N）
搜索 （Search）O（N）
插入（Insert） O(1)
删除 （Delete）O（1）


特点：写很快，读很慢（读少写多）
Python链表常用操作：


创建链表

linkedlist = deque() 


添加元素

linkedlist.append(1)
linkedlist.append(2)
lin.]]></description><category></category></item><item><title><![CDATA[数据结构1 数组Array]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119444576</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119444576</guid><author>Neflibata_mo</author><pubDate>Fri, 06 Aug 2021 14:59:11 +0800</pubDate><description><![CDATA[数组：在连续的内存空间中，存储一组相同类型的元素。
区分：数组的访问（Access）和数组的搜索（Search）


数组的访问（Access）：
通过索引访问某个元素
数组的搜索（Search）：
查找某个元素


数据结构的四个方法：


访问（Access）   o（1）
例：a = [1,2,3]   访问a[1] :  数组自带的内存地址+当前元素的位置*当前一个元素所占空间大小    从这个位置取数
搜索（Search）   o（N）
从头开始遍历数组中的元素
插入（Insert）     o.]]></description><category></category></item><item><title><![CDATA[空间复杂度和空间复杂度]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119429649</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/119429649</guid><author>Neflibata_mo</author><pubDate>Fri, 06 Aug 2021 09:18:00 +0800</pubDate><description><![CDATA[一、什么是时间复杂度
算法的执行效率
算法的执行时间与算法的输入值之间的关系
例：
def test(num):
	total = 0
	for i in range(num):
		total += i
	return total

假设该示例中“total = 0”的执行时间为a，“total += i”的执行时间为b，“return total”执行时间为c，num=N，故总执行时间为a+Nb+c。
其中对总执行时间影响最大的是Nb。
（时间复杂度不关心系数和小的执行时间。）
** 时间复杂度的大o表]]></description><category></category></item><item><title><![CDATA[五月学习总结]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/117394836</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/117394836</guid><author>Neflibata_mo</author><pubDate>Sun, 30 May 2021 10:15:10 +0800</pubDate><description><![CDATA[五月学习了hadoop集群的伪分布式和完全分布式搭建、hdfs的基本原理和常用命令、hive与zookeeper的配置和使用以及部分MapReduce的学习。
链接：
学习笔记1 hive基本操作

学习笔记2 hive表查询


学习笔记3 hive数据分析（实例）


学习笔记1 hdfs常用命令


学习笔记1 zookeeper


学习笔记 MapReduce


...]]></description><category></category></item><item><title><![CDATA[学习笔记 MapReduce]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/117337251</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/117337251</guid><author>Neflibata_mo</author><pubDate>Sun, 30 May 2021 10:11:18 +0800</pubDate><description><![CDATA[一、MapReduce概述
1. 定义
MapReduce是一个分布式运算程序的编程框架。
2. 优势劣势
优点：

易于编程：用户只需关心业务逻辑。实现框架的接口。
良好的扩展性：可以动态增加服务器，解决计算资源不够问题。
高容错性：任何一台机器挂掉，可以将任务转移到其他节点。
室和海量数据计算（TB/PB)。几千台服务器同时计算。
缺点：
不擅长实时计算。  (mysql)
不擅长流式计算。（sparktreaming flink)
不擅长DAG有向无环图计算。（spark）

3. 核心编程思想

M]]></description><category></category></item><item><title><![CDATA[学习笔记1 zookeeper]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/117390002</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/117390002</guid><author>Neflibata_mo</author><pubDate>Sun, 30 May 2021 10:04:59 +0800</pubDate><description><![CDATA[1. zookeeper是什么


它是一个分布式服务框架，它主要是用来解决分布式应用中经常遇到的一些数据管理问题。
（zookeeper=文件系统+监听通知机制。）


实现诸如分布式应用配置管理、统一命名服务、状态同步服务、集群管理等功能。


2.常用命令

启动
./zkServer.sh start
查看状态
./zkServer.sh status
帮助命令 ：help
客户端连接：./zkCli.sh
创建节点



...]]></description><category></category></item><item><title><![CDATA[学习笔记1 hdfs常用命令]]></title><link>https://blog.youkuaiyun.com/Neflibata_mo/article/details/117305232</link><guid>https://blog.youkuaiyun.com/Neflibata_mo/article/details/117305232</guid><author>Neflibata_mo</author><pubDate>Sat, 29 May 2021 19:32:38 +0800</pubDate><description><![CDATA[1.

]]></description><category></category></item></channel></rss>