yukiiris

Leetcode 763.partition labels

2018-07-06T00:00:00+00:00

Leetcode 763.Partition Labels

题目：

A string S of lowercase letters is given. We want to partition this string into as many parts as possible so that each letter appears in at most one part, and return a list of integers representing the size of these parts

Example 1:

Input: S = "ababcbacadefegdehijhklij"
Output: [9,7,8]
Explanation:
The partition is "ababcbaca", "defegde", "hijhklij".
This is a partition so that each letter appears in at most one part.
A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.

这题采用贪心算法解，主要思路是先从后往前找到第0 个字符最后一次出现的索引计为i，再遍历0到i中的每个字符，找出最后一次出现的索引，若比i大则更新i，直到结束，这样0到i就是一个最小分区。接下来对i+1之后也做同样的处理。

f方法就对所给出的索引进行分区处理。

Input: S = "ababcbacadefegdehijhklij"
Output: [9,7,8]
Explanation:
The partition is "ababcbaca", "defegde", "hijhklij".
This is a partition so that each letter appears in at most one part.
A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.

这题采用贪心算法解，主要思路是先从后往前找到第0 个字符最后一次出现的索引计为i，再遍历0到i中的每个字符，找出最后一次出现的索引，若比i大则更新i，直到结束，这样0到i就是一个最小分区，

class Solution {
    public List<Integer> partitionLabels(String s) {
        List<Integer> result = new ArrayList<>();
        if (s == null || s.length() == 0) {
            return result;
        }
        if (s.length() == 1) {
            result.add(0);
            return result;
        }
        int i = f(0, s);
        int j = 0;
        while (i < s.length()) {
            if (i == -1)
                break;
            result.add(i + 1 - j);
            j = i + 1;
            i = f(i + 1, s);
        }
        return result;
    }
    int f(int index, String s) {
        int n = index;
        if (index >= s.length())
            return -1;
        for (int i = index; i < n + 1; i++) {
            for (int j = s.length() - 1; j >= 0; j--) {
                if (s.charAt(i) == s.charAt(j)) {
                    if (j > n) {
                        n = j;
                    }
                    break;
                }
            }
        }
        return n;
    }
}

Leetcode 16.convert sorted list to binary search tree

2018-06-26T00:00:00+00:00

Leetcode 16.Convert Sorted List to Binary Search Tree

题目：

Given an array nums of n integers and an integer target, find three integers in nums such that the sum is closest to target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

Example:

Given array nums = [-1, 2, 1, -4], and target = 1.

The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).

主要思路是双指针，从第一个到倒数第三个元素循环，循环中再用两个指针指向i+1和最后这两个元素，将i， i+1,end这三个索引的数相加，若和大于目标值，右指针左移，反之左指针右移，直至两指针相遇。若和更接近目标值则更新答案。

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        int last = nums[0] + nums[1] + nums[2];
        int temp;
        Arrays.sort(nums);
        int start, end;
        for (int i = 0; i < nums.length - 2; i++) {
            start = i + 1;
            end = nums.length - 1;
            while (start < end) {
                if (Math.abs(nums[i] + nums[start] + nums[end] - target) < 
                        Math.abs(last - target)) {
                    last = nums[i] + nums[start] + nums[end];
                }
                if ((nums[i] + nums[start] + nums[end]) > target) {
                    end--;
                } else {
                    start++;
                }
            }
        }
        return last;
    }
}

Leetcode 3.Longest Substring Without Repeating Characters

2018-04-27T00:00:00+00:00

Leetcode 3.Longest Substring Without Repeating Characters

题目：

Given a string, find the length of the longest substring without repeating characters.

示例：

Given "abcabcbb", the answer is "abc", which the length is 3.

Given "bbbbb", the answer is "b", with the length of 1.

Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.

这题的思路是用两个指针指向字符串，如果没有重复情况，右指针向右移动，左指针不动，如果出现重复，左指针向左移动直至没有出现重复。维护一个set（数组可以更简单）来确定是否出现重复。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        
        if (s == null || s.length() == 0) {
            return 0;
        }
        if (s.length() == 1) {
            return 1;
        }
        
        Set<Character> set = new HashSet();
        char[] chars = s.toCharArray();
        int m = 0, n = 0, max = 1;
        
        for (n = 0; n < chars.length; n++) {
            
            if (set.contains(chars[n])) {
                if (max < n - m) {
                    max = n - m;
                }
                while (chars[m] != chars[n]) {
                    set.remove(chars[m]);
                    m++;
                }
                m++;
            } else {
                set.add(chars[n]);
            }
        }
        return Math.max(max, n - m);
    }
}

MIT 6.830 Lab1 SimpleDB

2018-04-08T00:00:00+00:00

MIT 6.830 Lab1 SimpleDB

简介

在这个系列的课程中，我们会完成一个简单的关系型数据库，了解数据库的底层实现。

1.The Database Class

Database类提供数据库中的全局变量的访问方法，尤其是访问catalog（数据库中所有表的列表）、bufferpool（缓冲池）和日志文件的方法。

2. Fiels and Tuples

tuples是数据库里基础的组成部分，它们由一系列Field物体构成，每个field构成一个tuple。Field是不同数据类型的实现接口。tuple由底层访问创建。tuple也有一种类型叫做 tuple descriptor，被TupleDesc类代表。这个对象由一系列Type构成，每个tuple里的field描述相应字段的类型。

3.Catalog

catalog由一个表格和模式的列表构成，支持添加新表、获取特定数据。与每个表关联的是一个TupleDesc对象，它允许操作者确定表中字段的类型和数量。

全局的catalog是一个单例，通过Database.getCatalog()获取。

4.BufferPool

缓冲池负责将最近读过的page缓存起来。所有从不同文件读写page的操作都要经过缓冲池，它包含固定数字的page。

5.HeapFile access method

访问方法提供从硬盘读写数据的特定方法。一般的访问方法有heap files和b树。

HeapFIle对象被排列成一组page，每个都包含固定byte的tuples，包括header。在SimpleDB中，每个table都有一个HeapFile，每个HeapFile里的page被排列成一组槽，每个slot里有一个tuple。除了这些槽，每个page包含一个含有bitmap的header（每个比特来自一个tuple槽）。如果相应比特为1，则这个tuple可用，反之不行。page储存在缓冲池中，但是读写它们要通过HeapFile类。

SimpleDB存储的heap files或多或少有相同的格式，它们存储在内存中的磁盘。每个文件由磁盘上连续排列的页面数据组成。每个页面由一个或多个字节组成，代表header，接着是实际页面内容的页面大小字节。每个元组要求元组大小为其内容的8位，header的1位。因此，可以在单个页面中匹配的元组数是：

_tuples per page_ = floor((_page size_ * 8) / (_tuple size_ * 8 + 1))

tuple的大小是是这个page中的tuple的byte的大小。这里的想法是，每个tuple要求在header中存储额外的位。我们计算在一个页面中的比特数（page大小乘8），并将该数量的tuple中的比特数（包括额外的header）得到的每个page的uple数量。

每个字节的低（最少）位表示文件前面的槽的状态。因此，第一个字节的最低位表示页面中的第一个槽是否在使用中。第一个字节的第二个最低位表示页面中的第二个槽是否在使用，等等。另外，注意最后一个字节的高阶位可能与实际在文件中的插槽不对应，因为插槽的数目可能不是8的倍数。也注意到所有的java虚拟机的大小。

6.Operators

运算符负责查询计划的实际执行。它们实现关系代数的运算。在SimpleDB，运营商是基于迭代器的；每个经营者实施dbiterator接口。操作符通过将低级操作符传递到高级操作符的构造函数中，即通过将它们链接在一起，将它们连接到一个计划中。“计划”叶子的特殊访问方法运算符负责从磁盘读取数据（因此在它们下面没有任何操作符）。在计划的顶部，与SimpleDB程序只需调用在根算子GETNEXT；这个操作员随后呼吁儿童GETNEXT，等等，直到这些叶者被称为。他们把元组从磁盘和山上的树（返回参数GETNEXT）；元组传播了这样的计划，直到他们在根或合并或被另一家运营商在计划输出。

Leetcode 53.maximum subarray

2018-03-29T00:00:00+00:00

LeetCode 53.Maximum Subarray

题目

Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [-2,1,-3,4,-1,2,1,-5,4], the contiguous subarray [4,-1,2,1] has the largest sum = 6.

Leetcode 109.Convert Sorted List to Binary Search Tree

2018-03-28T00:00:00+00:00

Leetcode 109.Convert Sorted List to Binary Search Tree

题目：

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

示例：

Given the sorted linked list: [-10,-3,0,5,9],

One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:

      0
     / \
   -3   9
   /   /
 -10  5

由于链表的值是顺序排列的，自然可以想的到用递归二分地构造BST，因为数组的长度非奇即偶，所以结点深度相差不会超过一。那么先取到链表的最中间元素作为根节点，再取前半部分以同样过程构造左子树，后半部分构造右子树即可。因为之前写过数组转BST，所以直接将链表转为数组再转为BST。

public TreeNode sortedListToBST(ListNode head)
{
    if (head == null)
    {
        return null;
    }
    ListNode p = head;
    List<Integer> list = new ArrayList<Integer>();
    while (p != null)
    {
        list.add(p.val);
        p = p.next;
    }
    return f(list.stream().filter(t -> t != null).mapToInt(t -> 			t).toArray(), 0, list.size() - 1);
}
TreeNode f(int a[], int start, int end)
{
    if (start > end)
    {
        return null;
    }
    int mid = start + (end - start) / 2;
    TreeNode node = new TreeNode(a[mid]);
    node.left = f(a, start, mid - 1);
    node.right = f(a, mid + 1, end);
    return node;
}

MIT 6.824 Lab1 MapReduce

2018-03-22T00:00:00+00:00

MIT 6.824 Lab1 MapReduce

###简介

MapReduce是Google提出的一个软件架构，用于大规模数据集（大于1TB）的并行运算。概念“Map（映射）”和“Reduce（归纳）”。

当前的软件实现是指定一个Map（映射）函数，用来把一组键值对映射成一组新的键值对，指定并发的Reduce（归纳）函数，用来保证所有映射的键值对中的每一个共享相同的键组。

Part I: Map/Reduce input and output

在这个part中，需要扩展common_map.go的doMap()和在common_reduce中的doReduce()。具体如下：

doMap方法的任务：它读入输入文件，对内容调用用户定义的map方法mapF()，然后将mapF的输出分割成nReduce个中间文件。
每个reduce任务都有一个中间文件，用reduceName()生成文件名。为每个键调用ihash()并模除 nReduce，为键值对选择r。
mapF()是用户提供的方法，它为reduce返回一个包含一个键值对的切片。
doreduce方法的任务：它为任务读出中间文件，通过键为这些中间键值对排序，为每个键调用用户定义的reduceF方法，将结果写入硬盘。
你必须为每个map任务读出中间文件，reduceName方法为每个map任务产生文件名。
你的domap方法将中间文件的键值对进行了编码，所以你需要解码。
reduceF方法由用户提供，你必须为每个不同的键以及它的所有值调用它。这个方法返回这些值应该对应的键。

Part II: Single-worker word count

这个part需要实现一个统计文档中出现单词数目的简单例子，具体如下：

mapF()方法将每个传入的内容分割为单词，用单词作为键，为每个单词创建一个KeyValue，值为”1”，表示这个单词出现了一次，将所有KeyValue作为一个切片返回。
redecuF()方法传入一个键和键对应的值数组，这个方法需要将所以mapF()中统计的次数相加，返回值数组的长度即可。

Part III: Distributing MapReduce tasks

这个part需要用分布式的思想实现上一个part的内容，具体采用的是RPC调用和go的并发编程来实现。

schedule()在所给的阶段（map或reduce）启动和等待所有任。mapFIles参数决定map阶段输入文件的名字。nReduce参数是reduce任务的数量。
所有ntasks个任务都会在worker中被调度，当所有任务都成功结束，schedule()会返回。
master线程在mapreduce中调用两次schedule()，map阶段一次，reduce()阶段一次。这个方法的任务是，把任务交给可用的工作线程。因为任务一般比工作线程多，所以schedule()方法要给每个工作线程一系列任务。
schedule()方法从rigisterChan参数中知道有多少可用的工作线程。这个channel为每个worker产生一个字符串包含它的RPC地址。一些worker在schedule()方法被调用之前已经存在，另一些会在这个方法运行时生成，schedule()必须将这些worker充分利用。
schedule()通过发送一个Worker.DoTask RPC给worker来告诉它要执行任务。

这里踩了好几个坑，说明一下。一个是关于sync.WaitGroup的add和Done两个方法，add只能在主线程里面用，想要同步线程就要在其他线程里用Done。然后将worker从registerChan中读出来并结束一个任务以后要放回去（来自一个没怎么学go并发编程的兄弟）

Part IV: Handling worker failures

在这个part中，需要处理失败的线程。

一个RPC调用失败不意味着这个线程没有在执行这个任务，这可能是因为返回值丢失或者master线程的RPC调用超时了。因此，这可能会发生于两个worker收到相同任务，处理他，然后生成输出。两个map或reduce调用必须对同一个输入生成相同的输出，所以如果后续处理有时读取一个输出并且有时读取另一个输出，则不会有不一致。除此之外，MapReduce框架确保map方法和reduce方法自动输出：输出文件可能不存在也可能包含map或reduce方法的单个执行的全部输出。

理解JAVA虚拟机（三）

2017-10-07T00:00:00+00:00

1. 类加载的时机

类的生命周期
- 加载、验证、准备、解析、初始化、使用、卸载
- 其中验证、准备、解析又被称为连接
- 这是一个交叉的过程
如何触发类的初始化（有且只有）
- 遇到new、getstatic、putstatic、invokestatic
- 使用反射
- 初始化一个类的时候父类还没有初始化
- 虚拟机启动时，含main方法
- 啥句柄之类的，看不懂

2. 类加载的过程

加载
- 通过一个类的全限定名来获取定义此类的二进制字节流
- 将这个字节流所代表的静态存储结构转化为方法区运行时的数据结构
- 在内存中生成一个代表此类的Class对象，作为方法区这个类各种数据的入口
验证
- 文件格式验证（魔数、版本号、常量类型等）
- 元数据验证（是否有父类、父类是否允许被继承、是否实现未实现的方法或接口等）
- 字节码验证（通过数据流和控制流分析确定程序语义是合法的、符合逻辑的
- 符号引用验证（对除自身以外的类的信息的匹配））
准备（正式为类分配内存）
- 仅包括类变量，而不是实例变量
解析（将符号引用转为直接引用）
- 符号引用：一组描述所引用目标的符号，可以是任何字面量
- 直接引用：如果有了直接引用，引用的目标必定已存在在内存中
- 可能会对同一个符号引用进行多次解析，可以进行缓存
- 类或接口的解析
  - 不是数组
  - 是数组
  - 访问权限
- 字段解析
- 类方法解析
- 接口方法解析
初始化（执行类构造器的()方法
- clinit是所有类变量的赋值动作和静态语句块的集合
- 此方法不需要显示调用父类构造器
- 可能会产生阻塞

3. 类加载器

类与类加载器

操作系统学习笔记（三）

2017-10-01T00:00:00+00:00

第三章存储系统

3.1 无存储器抽象

用户可以直接访问物理内存，不安全
运行多个程序很困难

3.2 地址空间

地址空间的概念
- 地址空间是一个进程可用于寻址内存的一套地址集合
- 动态重定位将进程的地址空间和物理内存进行一个简单的映射
交换技术
- 交换：把一个进程完整调入内存，运行一段时间后存回磁盘
  - 不同的进程一直在交换
  - 内存紧缩：将交换产生的空洞尽量合成大的内存区
  - 动态分配：预留空间
- 虚拟内存
空闲内存管理（动态分配内存）
- 使用位图的存储管理
  - 分配单元
- 使用链表的存储管理
  - 链表中的一个结点或者包含一个进程，或者两个进程间的空闲区
  - 结点包含以下区域：空闲区或进程的指示标志、起始地址、长度和指向下一结点的指针
  - 首次适配算法
  - 下次适配算法
  - 最佳适配算法
  - 最差适配算法
  - 进程与空闲区用两个链表管理

3.3 虚拟内存

虚拟内存的基本思想：每个程序有自己的地址空间，这个空间被分成多个块，每一块被称作一页或页面，每一页有连续的内存范围
分页
- 当程序运行时会产生的地址成为虚拟地址，它们构成虚拟地址空间
  - 没有虚拟内存的计算机上，系统将虚拟地址送到内存总线上，直接操作物理地址
  - 有虚拟内存的计算机上，系统将虚拟地址送到内存管理单元上（MMU），MMU将其映射到物理内存
- 虚拟地址空间被分为页面，对应的物理内存单元被称为页框，通常一样大
  - 虚拟内存能比物理内存大，通过设置MMU可以使其完整映射，但不能解决这个问题
  - 页面没有被映射而被访问会引起页面中断陷阱
  - MMU内部
    - 虚拟地址二进制为16位，被分为4位的页号和12位的偏移量，前者表示16个页面，后者可以表示一页4096个全部地址之一
页表（虚拟地址和物理地址的关系）
- 最简单的映射实现：虚拟地址被分为虚拟页号和偏移量
- 虚拟页号可以作为页表的索引，页表可以找到页框号，用页框号替换页号与偏移量拼接形成物理地址
- 页表项的细节
  - 页框号
  - “在/不在”位
  - “保护”：指出允许访问的类型（权限）
  - “修改”/“访问”位：修改过要保存，否则丢弃
  - “禁止被高速缓存”
- 虚拟内存的本质是建立对物理内存的抽象
加速分页过程
- 主要问题
  - 映射要很快
  - 如果虚拟地址空间很大，页表也要很大
- 转换检测缓冲区
  - 大多数程序总是对少量页表进行多次访问
  - 为计算机设置一个小型硬件将虚拟地址直接映射到物理地址，这个硬件被称为转换检测缓冲区/相联存储器（TLB），通常在MMU中
- 软件TLB管理：由操作系统管理被频繁访问的地址
  - 软失效：访问的页面在内存而不在TLB中
  - 硬失效：访问的页面不在内存不在TLB而在磁盘中
针对大内存的页表
- 多级页表
  - 避免把全部页表存在内存中
  - PT1、PT2、Offset
- 倒排页表
  - 实际内存中的每一个页框有一个表项
  - 映射会变得困难，需要倒排而不能用索引直接访问
  - 散列表/TLB

3.4 页面置换算法

发生页面中断时，操作系统要在内存中选择一个页面将其换出内存，腾出空间
最优页面置换算法：置换最不容易被访问的页面（无法实现）
最近未使用页面置换算法：随机地从类编号最小的非空类中选一个淘汰
先进先出页面置换算法
第二次机会页面置换算法：寻找最近的时钟间隔以来没有被访问的页面，是对先进先出页面置换算法的改进
时钟页面置换算法：第二次机会页面置换算法的改进，环形链表
最近最少使用页面置换算法
软件模拟LRU
工作集页面置换算法
工作集时钟页面置换算法

3.5 分页系统中的设计问题

局部分配策略与全局分配策略

理解java虚拟机（二）

2017-09-25T00:00:00+00:00

1. 概述

2.对象

引用计数法
- 难以解决对象之间互相循环引用的问题
可达性分析算法
- 当一个对象
- 到GC没有任何引用链，此对象不可用
引用
- 强引用、软引用、弱引用、虚引用
生存还是死亡
- 如果对象在可达性分析后被发现不可达，它会被第一次标记并且进行一次筛选，筛选的条件是此对象是否有必要执行finalize（）方法
- 若有必要，这个对象则会被放到F-Queue中缓慢执行
- 在执行finalize（）是最后一次逃脱被销毁的机会——将自己与另一个引用链上的对象建立引用
- finalize（）只会被执行一次
回收方法区

3. 垃圾回收算法

标记-清除算法
- 首先标记出要回收的对象，在标记完成后统一回收所有被标记的对象
- 效率不高，标记和清除都比较慢
- 空间问题，标记清除会产生大量不连续的内存碎片，分配大对象内存时，如果没有足够内存会再次触发垃圾收集
复制算法
- 将可用内存分为大小相等两块，当其中一块内存用完了，就把还活着的对象复制到另一块上，再将这一块一次清理完
- 减小一半可用内存，代价太大
- 不需要1：1划分空间
标记-整理算法
- 复制算法在存活率高的时候效率比较低
- 标记后使其向一边移动，然后直接清理边界内存
分代收集算法
- 把内存按照对象存活周期分为几个部分，根据各个年代采用最适当的算法

4. HotSpot算法实现

枚举根节点
- 查找全局引用和暂停来保证一致性上会耗费很多时间
安全点
- 程序不能再任意位置停下来进行GC，于是设置适当的安全点
- 抢先式中断：首先把线程全部暂停，如果发现有线程不在安全点上，就恢复它让它跑到安全点上
- 主动式中断：不对线程进行操作，设置一个标志，各个线程执行时主动轮询这个标志，发现中断标志为真就暂停
安全区域
- 为正在休眠的线程设计

5. 垃圾收集器

Serial收集器
- 单线程、“stop the world”
- 没有线程交互开销，专心做垃圾收集自然可以获得最高的单线程收集效率
ParNew收集器
- Serial的多线程版
Parallel Scavenge收集器
- 目标是达到一个可控制的吞吐量，更高效利用CPU
Serial Old收集器
- Serial收集器的老年代版
Parallel Old收集器
- Parallel Scavenge老年版
CMS收集器
- 以最短停顿时间为目标的收集器
- 基于“标记-清除”实现
- CMS收集器的内存回收过程和用户线程一起并发执行
- 并发收集、低停顿
- 对CPU资源非常敏感
- 无法处理浮动垃圾
GI收集器
- 并行与并发
- 分代收集
- 空间整合
- 可预测停顿
GC日志

6. 内存分配与回收策略

对象优先在eden分配
大对象直接进入老年代
长期存活的对象将进入老年代
动态对象年龄判断
空间分配担保

yukiiris

Leetcode 763.partition labels

Leetcode 763.Partition Labels

题目：

Leetcode 16.convert sorted list to binary search tree

Leetcode 16.Convert Sorted List to Binary Search Tree

题目：

Leetcode 3.Longest Substring Without Repeating Characters

Leetcode 3.Longest Substring Without Repeating Characters

题目：

示例：

MIT 6.830 Lab1 SimpleDB

MIT 6.830 Lab1 SimpleDB

简介

1.The Database Class

2. Fiels and Tuples

3.Catalog

4.BufferPool

5.HeapFile access method

6.Operators

Leetcode 53.maximum subarray

LeetCode 53.Maximum Subarray

题目

Leetcode 109.Convert Sorted List to Binary Search Tree

Leetcode 109.Convert Sorted List to Binary Search Tree

题目：

示例：

MIT 6.824 Lab1 MapReduce

MIT 6.824 Lab1 MapReduce

Part I: Map/Reduce input and output

Part II: Single-worker word count

Part III: Distributing MapReduce tasks

Part IV: Handling worker failures

理解JAVA虚拟机（三）

1. 类加载的时机

2. 类加载的过程

3. 类加载器

操作系统学习笔记（三）

第三章 存储系统

3.1 无存储器抽象

3.2 地址空间

3.3 虚拟内存

3.4 页面置换算法

3.5 分页系统中的设计问题

理解java虚拟机（二）

1. 概述

2.对象

3. 垃圾回收算法

4. HotSpot算法实现

5. 垃圾收集器

6. 内存分配与回收策略

第三章存储系统