ZhouJie's Blog

刷题汇总（六）leetcode 多线程 / Shell

2019-12-17T13:55:52.000Z

题目来源

这篇文章使用 POSIX 编写多线程 C++ 程序。POSIX Threads 或 Pthreads 提供的 API 可在多种类 Unix POSIX 系统上可用，比如 FreeBSD、NetBSD、GNU/Linux、Mac OS X 和 Solaris。

知识点1：创建线程/终止线程

#include
pthread_create (thread, attr, start_routine, arg)
pthread_exit (status)

使用 -lpthread 库编译：
$ g++ test.cpp -lpthread -o test.o

多线程

1、按序打印

我们提供了一个类：

public class Foo {
  public void one() { print("one"); }
  public void two() { print("two"); }
  public void three() { print("three"); }
}

三个不同的线程将会共用一个 Foo 实例。

线程 A 将会调用 one() 方法
线程 B 将会调用 two() 方法
线程 C 将会调用 three() 方法
请设计修改程序，以确保 two() 方法在 one() 方法之后被执行，three() 方法在 two() 方法之后被执行。

示例 1:

输入: [1,2,3]
输出: “onetwothree”
解释:
有三个线程会被异步启动。
输入 [1,2,3] 表示线程 A 将会调用 one() 方法，线程 B 将会调用 two() 方法，线程 C 将会调用 three() 方法。
正确的输出是 “onetwothree”。
示例 2:

输入: [1,3,2]
输出: “onetwothree”
解释:
输入 [1,3,2] 表示线程 A 将会调用 one() 方法，线程 B 将会调用 three() 方法，线程 C 将会调用 two() 方法。
正确的输出是 “onetwothree”。

注意:

尽管输入中的数字似乎暗示了顺序，但是我们并不保证线程在操作系统中的调度顺序。
你看到的输入格式主要是为了确保测试的全面性。

#include 
class Foo {
public:
    sem_t t1, t2, t3;

    Foo() {
        sem_init(&t1,0,1);
        sem_init(&t2,0,0);
        sem_init(&t3,0,0);
    }

    void first(function<void()> printFirst) {
        sem_wait(&t1);
        // printFirst() outputs "first". Do not change or remove this line.
        printFirst();
        sem_post(&t2);
    }

    void second(function<void()> printSecond) {
        sem_wait(&t2);
        // printSecond() outputs "second". Do not change or remove this line.
        printSecond();
        sem_post(&t3);
    }

    void third(function<void()> printThird) {
        sem_wait(&t3);
        // printThird() outputs "third". Do not change or remove this line.
        printThird();
    }
};

知识点2：信号量

#include
int sem_init(sem_t *sem, int pshared, unsigned int val); // 初始化信号量
int sem_wait(sem_t *sem); // 信号量减1
int sem_post(sem_t *sem); // 信号量加1
int sem_destory(sem_t *sem); // 销毁信号量

2、交替打印FooBar

我们提供一个类：

class FooBar {
  public void foo() {
    for (int i = 0; i < n; i++) {
      print("foo");
    }
  }

  public void bar() {
    for (int i = 0; i < n; i++) {
      print("bar");
    }
  }
}

两个不同的线程将会共用一个 FooBar 实例。其中一个线程将会调用 foo() 方法，另一个线程将会调用 bar() 方法。

请设计修改程序，以确保 “foobar” 被输出 n 次。

示例 1:

输入: n = 1
输出: “foobar”
解释: 这里有两个线程被异步启动。其中一个调用 foo() 方法, 另一个调用 bar() 方法，”foobar” 将被输出一次。
示例 2:

输入: n = 2
输出: “foobarfoobar”

# include
class FooBar {
private:
    int n;
    sem_t t1, t2;
public:
    FooBar(int n) {
        this->n = n;
        sem_init(&t1,0,1);
        sem_init(&t2,0,0);
    }

    void foo(function<void()> printFoo) {
        for (int i = 0; i < n; i++) {
            sem_wait(&t1);
            // printFoo() outputs "foo". Do not change or remove this line.
        printFoo();
            sem_post(&t2);
        }
    }

    void bar(function<void()> printBar) {
        for (int i = 0; i < n; i++) {
            sem_wait(&t2);
            // printBar() outputs "bar". Do not change or remove this line.
        printBar();
            sem_post(&t1);
        }
    }
};

class FooBar {
private:
    int n;
    pthread_mutex_t t1, t2;
public:
    FooBar(int n) {
        this->n = n;
        pthread_mutex_init(&t1,NULL);
        pthread_mutex_init(&t2,NULL);
        pthread_mutex_lock(&t2);
    }

    void foo(function<void()> printFoo) {
        for (int i = 0; i < n; i++) {
            pthread_mutex_lock(&t1);
            // printFoo() outputs "foo". Do not change or remove this line.
        printFoo();
            pthread_mutex_unlock(&t2);
        }
    }

    void bar(function<void()> printBar) {
        for (int i = 0; i < n; i++) {
            pthread_mutex_lock(&t2);
            // printBar() outputs "bar". Do not change or remove this line.
        printBar();
            pthread_mutex_unlock(&t1);
        }
    }
};

知识点3：互斥量
pthread_mutex_t sum_mutex; //互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER //静态初始化
pthread_mutex_init( &sum_mutex, NULL ); //动态初始化初始化成功返回0
pthread_mutex_lock( &sum_mutex ); //加锁
pthread_mutex_unlock( &sum_mutex ); //释放锁，供其他线程使用
pthread_mutex_destroy( &sum_mutex ); //注销锁

3、打印零与奇偶数

假设有这么一个类：

class ZeroEvenOdd {
  public ZeroEvenOdd(int n) { ... }      // 构造函数
  public void zero(printNumber) { ... }  // 仅打印出 0
  public void even(printNumber) { ... }  // 仅打印出 偶数
  public void odd(printNumber) { ... }   // 仅打印出 奇数
}

相同的一个 ZeroEvenOdd 类实例将会传递给三个不同的线程：

线程 A 将调用 zero()，它只输出 0 。
线程 B 将调用 even()，它只输出偶数。
线程 C 将调用 odd()，它只输出奇数。
每个线程都有一个 printNumber 方法来输出一个整数。请修改给出的代码以输出整数序列 010203040506… ，其中序列的长度必须为 2n。

示例 1：

输入：n = 2
输出：”0102”
说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 “0102”。
示例 2：

输入：n = 5
输出：”0102030405”

# include
class ZeroEvenOdd {
private:
    int n;
    sem_t t0, t1, t2;
public:
    ZeroEvenOdd(int n) {
        this->n = n;
        sem_init(&t0,0,1);
        sem_init(&t1,0,0);
        sem_init(&t2,0,0);
    }

    // printNumber(x) outputs "x", where x is an integer.
    void zero(function<void(int)> printNumber) {
        for(int i=1;i<=n;i++){
            sem_wait(&t0);
            printNumber(0);
            if(i%2==1) sem_post(&t1);
            else sem_post(&t2);
        }
    }

    void even(function<void(int)> printNumber) {
        for(int i=2;i<=n;i+=2){
            sem_wait(&t2);
            printNumber(i);
            sem_post(&t0);
        }
    }

    void odd(function<void(int)> printNumber) {
        for(int i=1;i<=n;i+=2){
            sem_wait(&t1);
            printNumber(i);
            sem_post(&t0);
        }
    }
};

4、H2O 生成

现在有两种线程，氢 oxygen 和氧 hydrogen，你的目标是组织这两种线程来产生水分子。

存在一个屏障（barrier）使得每个线程必须等候直到一个完整水分子能够被产生出来。

氢和氧线程会被分别给予 releaseHydrogen 和 releaseOxygen 方法来允许它们突破屏障。

这些线程应该三三成组突破屏障并能立即组合产生一个水分子。

你必须保证产生一个水分子所需线程的结合必须发生在下一个水分子产生之前。

换句话说:

如果一个氧线程到达屏障时没有氢线程到达，它必须等候直到两个氢线程到达。
如果一个氢线程到达屏障时没有其它线程到达，它必须等候直到一个氧线程和另一个氢线程到达。
书写满足这些限制条件的氢、氧线程同步代码。

示例 1:

输入: “HOH”
输出: “HHO”
解释: “HOH” 和 “OHH” 依然都是有效解。
示例 2:

输入: “OOHHHH”
输出: “HHOHHO”
解释: “HOHHHO”, “OHHHHO”, “HHOHOH”, “HOHHOH”, “OHHHOH”, “HHOOHH”, “HOHOHH” 和 “OHHOHH” 依然都是有效解。

限制条件:

输入字符串的总长将会是 3n, 1 ≤ n ≤ 50；
输入字符串中的 “H” 总数将会是 2n；
输入字符串中的 “O” 总数将会是 n。

# include
class H2O {
public:
    sem_t h_limit, o_limit, h, o;

    H2O() {
        sem_init(&h_limit,0,2);
        sem_init(&o_limit,0,1);
        sem_init(&h,0,0);
        sem_init(&o,0,0);
    }

    void hydrogen(function<void()> releaseHydrogen) {
        sem_wait(&h_limit);
        sem_post(&h);
        sem_wait(&o);
        // releaseHydrogen() outputs "H". Do not change or remove this line.
        releaseHydrogen();
        sem_post(&h_limit);
    }

    void oxygen(function<void()> releaseOxygen) {
        sem_wait(&o_limit);
        sem_post(&o);
        sem_post(&o);
        sem_wait(&h);
        sem_wait(&h);
        // releaseOxygen() outputs "O". Do not change or remove this line.
        releaseOxygen();
        sem_post(&o_limit);
    }
};

5、交替打印字符串

编写一个可以从 1 到 n 输出代表这个数字的字符串的程序，但是：

如果这个数字可以被 3 整除，输出 “fizz”。
如果这个数字可以被 5 整除，输出 “buzz”。
如果这个数字可以同时被 3 和 5 整除，输出 “fizzbuzz”。
例如，当 n = 15，输出： 1, 2, fizz, 4, buzz, fizz, 7, 8, fizz, buzz, 11, fizz, 13, 14, fizzbuzz。

假设有这么一个类：

class FizzBuzz {
  public FizzBuzz(int n) { ... }               // constructor
  public void fizz(printFizz) { ... }          // only output "fizz"
  public void buzz(printBuzz) { ... }          // only output "buzz"
  public void fizzbuzz(printFizzBuzz) { ... }  // only output "fizzbuzz"
  public void number(printNumber) { ... }      // only output the numbers
}

请你实现一个有四个线程的多线程版 FizzBuzz，同一个 FizzBuzz 实例会被如下四个线程使用：

线程A将调用 fizz() 来判断是否能被 3 整除，如果可以，则输出 fizz。
线程B将调用 buzz() 来判断是否能被 5 整除，如果可以，则输出 buzz。
线程C将调用 fizzbuzz() 来判断是否同时能被 3 和 5 整除，如果可以，则输出 fizzbuzz。
线程D将调用 number() 来实现输出既不能被 3 整除也不能被 5 整除的数字。

# include
class FizzBuzz {
private:
    int n;
    sem_t t0, t3, t5, t35;

public:
    FizzBuzz(int n) {
        this->n = n;
        sem_init(&t0,0,1);
        sem_init(&t3,0,0);
        sem_init(&t5,0,0);
        sem_init(&t35,0,0);
    }

    // printFizz() outputs "fizz".
    void fizz(function<void()> printFizz) {
        for(int i=1;i<=n;i++){
            if(i%3==0 && i%5!=0){
                sem_wait(&t3);
                printFizz();
                sem_post(&t0);
            }
        }
    }

    // printBuzz() outputs "buzz".
    void buzz(function<void()> printBuzz) {
        for(int i=1;i<=n;i++){
            if(i%3!=0 && i%5==0){
                sem_wait(&t5);
                printBuzz();
                sem_post(&t0);
            }
        }
    }

    // printFizzBuzz() outputs "fizzbuzz".
void fizzbuzz(function<void()> printFizzBuzz) {
        for(int i=1;i<=n;i++){
            if(i%3==0 && i%5==0){
                sem_wait(&t35);
                printFizzBuzz();
                sem_post(&t0);
            }
        }
    }

    // printNumber(x) outputs "x", where x is an integer.
    void number(function<void(int)> printNumber) {
        for(int i=1;i<=n;i++){
            sem_wait(&t0);
            if(i%3!=0 && i%5!=0){
                printNumber(i);
                sem_post(&t0);
            }
            else if(i%3==0 && i%5!=0){
                sem_post(&t3);
            }
            else if(i%3!=0 && i%5==0){
                sem_post(&t5);
            }
            else{
                sem_post(&t35);
            }
        }
    }
};

6、哲学家进餐

5 个沉默寡言的哲学家围坐在圆桌前，每人面前一盘意面。叉子放在哲学家之间的桌面上。（5 个哲学家，5 根叉子）

所有的哲学家都只会在思考和进餐两种行为间交替。哲学家只有同时拿到左边和右边的叉子才能吃到面，而同一根叉子在同一时间只能被一个哲学家使用。每个哲学家吃完面后都需要把叉子放回桌面以供其他哲学家吃面。只要条件允许，哲学家可以拿起左边或者右边的叉子，但在没有同时拿到左右叉子时不能进食。

假设面的数量没有限制，哲学家也能随便吃，不需要考虑吃不吃得下。

设计一个进餐规则（并行算法）使得每个哲学家都不会挨饿；也就是说，在没有人知道别人什么时候想吃东西或思考的情况下，每个哲学家都可以在吃饭和思考之间一直交替下去。

问题描述和图片来自维基百科 wikipedia.org

哲学家从 0 到 4 按顺时针编号。请实现函数 void wantsToEat(philosopher, pickLeftFork, pickRightFork, eat, putLeftFork, putRightFork)：

philosopher 哲学家的编号。
pickLeftFork 和 pickRightFork 表示拿起左边或右边的叉子。
eat 表示吃面。
putLeftFork 和 pickRightFork 表示放下左边或右边的叉子。
由于哲学家不是在吃面就是在想着啥时候吃面，所以思考这个方法没有对应的回调。
给你 5 个线程，每个都代表一个哲学家，请你使用类的同一个对象来模拟这个过程。在最后一次调用结束之前，可能会为同一个哲学家多次调用该函数。

示例：

输入：n = 1
输出：[[4,2,1],[4,1,1],[0,1,1],[2,2,1],[2,1,1],[2,0,3],[2,1,2],[2,2,2],[4,0,3],[4,1,2],[0,2,1],[4,2,2],[3,2,1],[3,1,1],[0,0,3],[0,1,2],[0,2,2],[1,2,1],[1,1,1],[3,0,3],[3,1,2],[3,2,2],[1,0,3],[1,1,2],[1,2,2]]
解释:
n 表示每个哲学家需要进餐的次数。
输出数组描述了叉子的控制和进餐的调用，它的格式如下：
output[i] = [a, b, c] (3个整数)

a 哲学家编号。
b 指定叉子：{1 : 左边, 2 : 右边}.
c 指定行为：{1 : 拿起, 2 : 放下, 3 : 吃面}。
如 [4,2,1] 表示 4 号哲学家拿起了右边的叉子。

提示：
1 <= n <= 60

# include
class DiningPhilosophers {
private:
    sem_t sem;
    pthread_mutex_t mutex[5];
public:
    DiningPhilosophers() {
        sem_init(&sem,0,4);
        for(int i=0;i<5;i++){
            pthread_mutex_init(&mutex[i],NULL);
        }
    }
    
    // 限定哲学家就餐数量
    void wantsToEat(int philosopher,
                    function<void()> pickLeftFork,
                    function<void()> pickRightFork,
                    function<void()> eat,
                    function<void()> putLeftFork,
                    function<void()> putRightFork) {

                    int left = philosopher;
                    int right = (philosopher+1)%5;

                    sem_wait(&sem);
                    pthread_mutex_lock(&mutex[left]);
                    pthread_mutex_lock(&mutex[right]);

                    pickLeftFork();
                    pickRightFork();

                    eat();

                    putLeftFork();
                    putRightFork();

                    pthread_mutex_unlock(&mutex[left]);
                    pthread_mutex_unlock(&mutex[right]);

                    sem_post(&sem);
    }
};

# include
class DiningPhilosophers {
private:
    pthread_mutex_t mutex;
    pthread_mutex_t forks_mutex[5];
public:
    DiningPhilosophers() {
        pthread_mutex_init(&mutex,NULL);
        for(int i=0;i<5;i++){
            pthread_mutex_init(&forks_mutex[i],NULL);
        }
    }

    // 同时拿起左右2把叉子
    void wantsToEat(int philosopher,
                    function<void()> pickLeftFork,
                    function<void()> pickRightFork,
                    function<void()> eat,
                    function<void()> putLeftFork,
                    function<void()> putRightFork) {

                    int left = philosopher;
                    int right = (philosopher+1)%5;

                    pthread_mutex_lock(&mutex);

                    pthread_mutex_lock(&forks_mutex[left]);
                    pthread_mutex_lock(&forks_mutex[right]);

                    pickLeftFork();
                    pickRightFork();

                    pthread_mutex_unlock(&mutex);

                    eat();

                    putLeftFork();
                    putRightFork();

                    pthread_mutex_unlock(&forks_mutex[left]);
                    pthread_mutex_unlock(&forks_mutex[right]);
    }
};

# include
class DiningPhilosophers {
private:
    pthread_mutex_t forks_mutex[5];
public:
    DiningPhilosophers() {
        for(int i=0;i<5;i++){
            pthread_mutex_init(&forks_mutex[i],NULL);
        }
    }

    // 一部分哲学家优先去获取其左边的叉子，再去获取其右边的叉子；
    // 再让剩余哲学家优先去获取其右边的叉子，再去获取其左边的叉子
    void wantsToEat(int philosopher,
                    function<void()> pickLeftFork,
                    function<void()> pickRightFork,
                    function<void()> eat,
                    function<void()> putLeftFork,
                    function<void()> putRightFork) {

                    int left = philosopher;
                    int right = (philosopher+1)%5;

                    if(philosopher%2 == 1){
                        pthread_mutex_lock(&forks_mutex[left]);
                        pthread_mutex_lock(&forks_mutex[right]);
                    }
                    else{
                        pthread_mutex_lock(&forks_mutex[right]);
                        pthread_mutex_lock(&forks_mutex[left]);

                    }

                    pickLeftFork();
                    pickRightFork();

                    eat();

                    putLeftFork();
                    putRightFork();

                    pthread_mutex_unlock(&forks_mutex[left]);
                    pthread_mutex_unlock(&forks_mutex[right]);
    }
};

Shell

1、统计词频

写一个 bash 脚本以统计一个文本文件 words.txt 中每个单词出现的频率。

为了简单起见，你可以假设：

words.txt只包括小写字母和 ‘ ‘ 。
每个单词只由小写字母组成。
单词间由一个或多个空格字符分隔。
示例:

假设 words.txt 内容如下：

the day is sunny the the
the sunny is is
你的脚本应当输出（以词频降序排列）：

the 4
is 3
sunny 2
day 1
说明:

不要担心词频相同的单词的排序问题，每个单词出现的频率都是唯一的。
你可以使用一行 Unix pipes 实现吗？

1
2

# Read from the file words.txt and output the word frequency list to stdout.
cat words.txt | xargs -n1 | awk '{data[$1] += 1} END {for(str in data) print data[str],str}' | sort -nr | awk '{print $2, $1}'

xargs 用作替换工具，读取输入数据重新格式化后输出
# cat test.txt
a b c d e
f g h
$ cat test.txt | xargs -n3
a b c
d e f
g h
按照数值大小反向排序
$ sort -nr

1	cat words.txt \| xargs -n1 \| awk '{data[$1] += 1} END {for(str in data) print str,data[str]}' \| sort -nr -k2

将第二列按照数值大小反向排序
$ sort -nr -k2
1
cat words.txt | awk '{for(i=1;i<=NF;i++) data[$i] += 1} END {for(str in data) print str,data[str]}' | sort -nr -k2

1	awk '{for(i=1;i<=NF;i++) data[$i] += 1} END {for(str in data) print str,data[str]}' words.txt \| sort -nr -k2

NF 一条记录的字段的数目
NR 已经读出的记录数，就是行号，从1开始

1	cat words.txt \| xargs -n1 \| sort \| uniq -c \| sort -nr \| awk '{print $2,$1}'

统计各行在文件中出现的次数：
$ sort testfile | uniq -c
当重复的行并不相邻时，uniq 命令是不起作用的，因此常与sort一起使用

1	cat words.txt \| tr -s ' ' '\n' \| sort \| uniq -c \| sort -nr \| awk '{print $2,$1}'

空格改为换行符
$ tr -s ‘ ‘ ‘\n’
缩减连续重复的字符成指定的单个字符

2、有效电话号码

给定一个包含电话号码列表（一行一个电话号码）的文本文件 file.txt，写一个 bash 脚本输出所有有效的电话号码。

你可以假设一个有效的电话号码必须满足以下两种格式： (xxx) xxx-xxxx 或 xxx-xxx-xxxx。（x 表示一个数字）

你也可以假设每行前后没有多余的空格字符。

示例:

假设 file.txt 内容如下：

987-123-4567
123 456 7890
(123) 456-7890
你的脚本应当输出下列有效的电话号码：

987-123-4567
(123) 456-7890

1 2	# Read from the file file.txt and output all valid phone numbers to stdout. grep -E "^$[0-9]{3}$ [0-9]{3}-[0-9]{4}$\|^[0-9]{3}-[0-9]{3}-[0-9]{4}$" file.txt

^ 为匹配输入字符串的开始位置,$ 为匹配输入字符串的结束位置

1	awk "/^$[0-9]{3}$ [0-9]{3}-[0-9]{4}$\|^[0-9]{3}-[0-9]{3}-[0-9]{4}$/" file.txt

1	awk "/^$[0-9]{3}$ [0-9]{3}-[0-9]{4}$/ \|\| /^[0-9]{3}-[0-9]{3}-[0-9]{4}$/" file.txt

1	awk "/^($[0-9]{3}$ \|[0-9]{3}-)[0-9]{3}-[0-9]{4}$/" file.txt

1	grep -P "^($\d{3}$ \|\d{3}-)\d{3}-\d{4}$" file.txt

grep -E主要是用来支持扩展正则表达式加上-P（使用Perl的正则引擎）在MAC OS下面man grep是没有-P参数的，新的主流正则引擎已经默认加上了-P参数

3、转置文件

给定一个文件 file.txt，转置它的内容。

你可以假设每行列数相同，并且每个字段由 ‘ ‘ 分隔.

示例:

假设 file.txt 文件内容如下：

name age
alice 21
ryan 30
应当输出：

name alice ryan
age 21 30

1 2	# Read from the file file.txt and print its transposed content to stdout. awk '{for(i=1;i<=NF;i++)if(arr[i]){arr[i]=arr[i]" "$i}else{arr[i]=$i}}END{for(key in arr)print arr[key]}' file.txt

4、第十行

给定一个文本文件 file.txt，请只打印这个文件中的第十行。

示例:

假设 file.txt 有如下内容：

Line 1
Line 2
Line 3
Line 4
Line 5
Line 6
Line 7
Line 8
Line 9
Line 10
你的脚本应当显示第十行：

Line 10
说明:

如果文件少于十行，你应当输出什么？
至少有三种不同的解法，请尝试尽可能多的方法来解题。

1	awk 'NR==10' file.txt

NR在awk中指行号

1	tail -n +10 file.txt \| head -1

tail -n +10 从第 10 行至文件末尾

1	sed -n '10p' file.txt

-n表示只输出匹配行，p表示Print

刷题汇总（五）leetcode 热题 HOT 100 C++ 答案总结

2019-12-05T04:14:26.000Z

题目来源

leetcode 热题 HOT 100题

PDF版 code （提取码：0wxr ）

1、两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

class Solution {
public:
    // 时间复杂度：O(n)，空间复杂度：O(n)
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res(2);
        unordered_map<int,int> map;
        for(int i=0;i
            int tmp = target - nums[i];
            if(map.find(tmp)!=map.end()){
                res[0] = i;
                res[1] = map[tmp];
                break;
            }
            map[nums[i]] = i;
        }
        return res;
    }
};

2、两数相加

给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 // 时间复杂度：O(max(m,n))，空间复杂度：O(max(m,n))， 新列表的长度最多为max(m,n)+1
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* res = new ListNode(0);
        ListNode* head = res;
        int flag = 0;
        while(l1 || l2){
            int x = l1?l1->val:0;
            int y = l2?l2->val:0;
            head->next = new ListNode((x+y+flag)%10);
            flag = x+y+flag>9?1:0;
            if(l1) l1 = l1->next;
            if(l2) l2 = l2->next;
            head = head->next;
        }
        if(flag==1){
            head->next = new ListNode(1);
        }
        return res->next;
    }
};

3、无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是子串的长度，”pwke” 是一个子序列，不是子串。

// 时间复杂度：O(n)，空间复杂度：O(m)，m 是字符集的大小
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int res = 0;
        unordered_map<char,int> map;
        int i = 0;
        for(int j=0;j
            if(map.find(s[j])!=map.end()){
                i = max(map[s[j]],i);
            }
            map[s[j]] = j+1;
            res = max(j-i+1, res);
        }
        return res;
    }
};

4、寻找两个有序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0
示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

class Solution {
public:
    // 时间复杂度：O(log(min(m,n)))，空间复杂度：O(1)O(1)
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        if(nums1.size()>nums2.size())
            return findMedianSortedArrays(nums2,nums1);
        int m = nums1.size(), n = nums2.size();
        int lmax1,rmin1,lmax2,rmin2,c1,c2,low=0,heigh=2*m;
        while(low <= heigh){
            int c1 = (low+heigh)/2;
            int c2 = m+n-c1;
            lmax1 = c1 == 0? INT_MIN:nums1[(c1-1)/2];
            rmin1 = c1 == 2*m? INT_MAX:nums1[c1/2];
            lmax2 = c2 == 0? INT_MIN:nums2[(c2-1)/2];
            rmin2 = c2 == 2*n? INT_MAX:nums2[c2/2];
            if(lmax1>rmin2) heigh = c1-1;
            else if(lmax2>rmin1) low = c1+1;
            else break;
        }
        return (max(lmax1,lmax2)+min(rmin1,rmin2))/2.0;
    }
};

5、最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：

输入: “cbbd”
输出: “bb”

class Solution {
public:
    // 时间复杂度：O(n^2)，空间复杂度：O(1)
    string longestPalindrome(string s) {
        int start=0, len=0;
        for(int i=0;i
            int tmp = max(getsub(i,i,s),getsub(i,i+1,s));
            if(tmp>len){
                len = tmp;
                start = i-(len-1)/2;
            }
        }
        return s.substr(start,len);
    }

    int getsub(int i,int j,string s){
        while(i>=0 && j
            i--;
            j++;
        }
        return j-i-1;
    }
};

6、正则表达式匹配

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。

‘.’ 匹配任意单个字符
‘*’ 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖整个字符串 s的，而不是部分字符串。

说明:

s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。
示例 1:

输入:
s = “aa”
p = “a”
输出: false
解释: “a” 无法匹配 “aa” 整个字符串。
示例 2:

输入:
s = “aa”
p = “a*”
输出: true
解释: 因为 ‘*’ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。
示例 3:

输入:
s = “ab”
p = “.*”
输出: true
解释: “.*” 表示可匹配零个或多个（’*’）任意字符（’.’）。
示例 4:

输入:
s = “aab”
p = “cab”
输出: true
解释: 因为 ‘*’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。
示例 5:

输入:
s = “mississippi”
p = “misisp*.”
输出: false

class Solution {
public:
    bool isMatch(string s, string p) {
        const char* str = s.c_str();
        const char* pattern = p.c_str();
        return match(str,pattern);
    }

    bool match(const char* str, const char* pattern)
    {
        if(*str == '\0' && *pattern == '\0') return true;
        if(*str != '\0' && *pattern == '\0') return false;
        if(*(pattern+1) != '*'){
            if(*str==*pattern || *pattern=='.'&&*str!='\0'){
                return match(str+1,pattern+1);
            }
            else return false;
        }
        else{
            if(*str==*pattern || *pattern=='.'&&*str!='\0'){
                return match(str,pattern+2)|| match(str+1,pattern+2)|| match(str+1,pattern);
            }
            else return match(str,pattern+2);
        }
    }
};

class Solution {
public:
    // 时间复杂度：O(TP)，空间复杂度：O(TP)
    bool isMatch(string s, string p) {
        int l1 = s.size(),l2 = p.size();
        vector<vector<bool>> dp(l1+1,vector<bool>(l2+1));
        dp[l1][l2]=true;
        for(int i=l1;i>=0;i--){
            for(int j=l2-1;j>=0;j--){
                bool tmp = i'.');
                if(j+11] == '*'){
                    dp[i][j] = dp[i][j+2] || tmp && dp[i+1][j];
                }
                else{
                    dp[i][j] = tmp && dp[i+1][j+1];
                }
            }
        }
        return dp[0][0];
    }
};

7、盛最多水的容器

给定 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2。

图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例:

输入: [1,8,6,2,5,4,8,3,7]
输出: 49

class Solution {
public:
    // 时间复杂度：O(n)，空间复杂度：O(1)
    int maxArea(vector<int>& height) {
        int res=0;
        int i=0,j=height.size()-1;
        while(i
            res = max(res,(j-i)*min(height[i],height[j]));
            if(height[i]
            else j--;
        }
        return res;
    }
};

8、三数之和

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

class Solution {
public:
    // 时间复杂度：O(n^2)，空间复杂度：O(1)
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        if(nums.empty()) return res;
        sort(nums.begin(),nums.end());
        for(int i=0;i
            if(i>=1 && nums[i] == nums[i-1]) continue;
            if(nums[i]>0) break;
            int l=i+1,r=nums.size()-1;
            while(l
                if(nums[l]+nums[r]+nums[i] < 0) l++;
                else if(nums[l]+nums[r]+nums[i] > 0) r--;
                else{
                    res.push_back({nums[i],nums[l],nums[r]});
                    l++;
                    r--;
                    while(l-1]) l++;
                    while(l1]) r--;
                }
            }
        }
        return res;
    }
};

9、电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例:

输入：”23”
输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”].
说明:
尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

class Solution {
public:
    // 时间复杂度：O(3^N*4^M)，空间复杂度：O(3^N*4^M)
    unordered_map<char,string> map{{'2',"abc"},{'3',"def"},{'4',"ghi"},{'5',"jkl"},{'6',"mno"},{'7',"pqrs"},{'8',"tuv"},{'9',"wxyz"}};

    vector<string> letterCombinations(string digits) {
        vector<string> res;
        if(digits.empty()) return res;
        help("",digits,res);
        return res;
    }

    void help(string str, string digits, vector<string> &res) {
        if(str.size() == digits.size()){
            res.push_back(str);
            return;
        }
        string tmp = map[digits[str.size()]];
        for(int i=0;i
            str += tmp[i];
            help(str,digits,res);
            str.pop_back();
        }
        return;
    }
};

注：可以联系剑指offer27题一起看

class Solution {
public:
    // 时间复杂度：O(3^N*4^M)，空间复杂度：O(3^N*4^M)
    vector<string> letterCombinations(string digits) {
        unordered_map<char,string> map{{'2',"abc"},{'3',"def"},{'4',"ghi"},{'5',"jkl"},{'6',"mno"},{'7',"pqrs"},{'8',"tuv"},{'9',"wxyz"}};
        vector<string> res;
        if(digits.empty()) return res;
        if(digits.size() == 1){
            string tmp = map[digits[0]];
            for(char w : tmp) {
                string s(1,w);
                res.push_back(s);
            }
            return res;
        }
        vector<string> last = letterCombinations(digits.substr(0,digits.size()-1));
        string tmp = map[digits[digits.size()-1]]; //abc def
        for(int i=0;i0;i++){
            for(int j=0;j
                res.push_back(last[i]+tmp[j]);
            }
        }
        return res;
    }
};

10、删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(1)
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(!head || n==0) return head;
        ListNode* l1 = head;
        ListNode* l2 = head;
        int k=0;
        while(l1){
            if(k>n) l2 = l2->next;
            l1 = l1->next;
            k++;
        }
        // 倒数第k-1个结点l2
        if(k == n) return head->next;
        l2->next = l2->next->next;
        return head;
    }
};

11、有效的括号

给定一个只包括 ‘(‘，’)’，’{‘，’}’，’[‘，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:

输入: “()”
输出: true
示例 2:

输入: “()[]{}”
输出: true
示例 3:

输入: “(]”
输出: false
示例 4:

输入: “([)]”
输出: false
示例 5:

输入: “{[]}”
输出: true

class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(n)
    bool isValid(string s) {
        stack<char> stack;
        for(int i=0;i
            if(stack.empty() || !isok(stack.top(),s[i])){
                stack.push(s[i]);
            }
            else stack.pop();
        }
        return stack.empty();
    }

    bool isok(char a, char b) {
        return a=='('&&b==')' || a=='['&&b==']' || a=='{'&&b=='}';
    }
};

12、合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
// 时间复杂度：O(n+m)，空间复杂度：O(1)
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* res = new ListNode(0);
        ListNode* head = res;
        while(l1 && l2){
            if(l1->valval){
                head->next = l1;
                l1 = l1->next;
            }
            else{
                head->next = l2;
                l2 = l2->next;
            }
            head = head->next;
        }
        head->next = l1?l1:l2;
        return res->next;
    }
};

13、括号生成

给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。

例如，给出 n = 3，生成结果为：

[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]

class Solution {
public:
    // 时间复杂度：O(4^n/sqrt(n))，空间复杂度：O(4^n/sqrt(n))
    vector<string> generateParenthesis(int n) {
        vector<string> res;
        if(n==0) return {""};
        for(int i=0;i
            vector<string> left = generateParenthesis(i);
            vector<string> right = generateParenthesis(n-1-i);
            for(string l :left){
                for(string r :right){
                    res.push_back("("+l+")"+r);
                }
            }
        }
        return res;
    }
};

14、合并K个排序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
1->4->5,
1->3->4,
2->6
]输出: 1->1->2->3->4->4->5->6

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
// 时间复杂度：O(Nlogk)，空间复杂度：O(1)
    ListNode* mergeKLists(vector& lists) {
        ListNode* res = NULL;
        for(int i=0;i
            res = mergeTwoLists(res,lists[i]);
        }
        return res;
    }

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* res = new ListNode(0);
        ListNode* head = res;
        while(l1 && l2){
            if(l1->valval){
                head->next = l1;
                l1 = l1->next;
            }
            else{
                head->next = l2;
                l2 = l2->next;
            }
            head = head->next;
        }
        head->next = l1?l1:l2;
        return res->next;
    }
};

15、下一个排列

实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。

如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。

必须原地修改，只允许使用额外常数空间。

以下是一些例子，输入位于左侧列，其相应输出位于右侧列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(1)
    void nextPermutation(vector<int>& nums) {
        int i= nums.size()-2;
        while(i>=0 && nums[i]>=nums[i+1]){
            i--;
        }
        if(i>=0) {
            int j = nums.size()-1;
            while(j>=0 && nums[j]<=nums[i]){
                j--;
            }
            swap(nums[i],nums[j]);
        }
        reverse(nums,i+1);
    }

    void reverse(vector<int>& nums,int n){
        int l=n,r=nums.size()-1;
        while(l
            swap(nums[l],nums[r]);
            l++;
            r--;
        }
    }
};

16、最长有效括号

给定一个只包含 ‘(‘ 和 ‘)’ 的字符串，找出最长的包含有效括号的子串的长度。

示例 1:

输入: “(()”
输出: 2
解释: 最长有效括号子串为 “()”
示例 2:

输入: “)()())”
输出: 4
解释: 最长有效括号子串为 “()()”

class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(1)
    int longestValidParentheses(string s) {
        int l = 0, r = 0 , res = 0;
        for(int i=0;i
            if(s[i] == '(') l++;
            if(s[i] == ')') r++;
            if(l==r) res = max(res,2*l);
            if(r>l) l=r=0;
        }
        l=0,r=0;
        for(int i=s.size()-1;i>=0;i--){
            if(s[i] == '(') l++;
            if(s[i] == ')') r++;
            if(l==r) res = max(res,2*l);
            if(l>r) l=r=0;
        }
        return res;
    }
};

17、搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

class Solution {
public:
// 时间复杂度：O(logN)，空间复杂度：O(1)
    int search(vector<int>& nums, int target) {
        return help(nums,target,0,nums.size()-1);
    }
    int help(vector<int>& nums, int target, int l, int r) {
        if(l>r) return -1;
        int mid = (l+r)/2;
        if(nums[mid] == target) return mid;
        if(nums[mid]>nums[r]){ // 3 4 7 8 1 2  旋转点在右，左顺序
            if(nums[l]<=target && target return help(nums,target,l,mid-1);
            else return help(nums,target,mid+1,r);
        }
        else{ // 7 8 1 2 3 4
            if(nums[mid]return help(nums,target,mid+1,r);
            else return help(nums,target,l,mid-1);
        }
    }
};

18、在排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

class Solution {
public:
// 时间复杂度：O(logN)，空间复杂度：O(1)
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> res{-1,-1};
        int l=0,r=nums.size()-1;
        while(l<=r){
            int mid=(l+r)/2;
            if(nums[mid] == target) {
                help(nums,mid,res);
                break;
            }
            else if(nums[mid] > target) r = mid-1;
            else l = mid+1;
        }
        return res;
    }
    void help(vector<int> nums, int n,vector<int> &res) {
        int l=n,r=n;
        while(l>=0&&nums[l]==nums[n]){
            l--;
        }
        while(r
            r++;
        }
        res[0]=l+1;
        res[1]=r-1;
    }
};

19、组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。

说明：
所有数字（包括 target）都是正整数。
解集不能包含重复的组合。
示例 1:

输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
[7],
[2,2,3]
]示例 2:

输入: candidates = [2,3,5], target = 8,
所求解集为:
[
[2,2,2,2],
[2,3,3],
[3,5]
]

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        vector<vector<int>> res;
        vector<int> path;
        dfs(candidates,target,0,path,res);
        return res;
    }
    void dfs(vector<int>& candidates, int target, int start, vector<int> &path, vector<vector<int>> &res) {
        if(target == 0) {
            res.push_back(path);
            return;
        }
        for(int i=start;i=candidates[i];i++){
            path.push_back(candidates[i]);
            dfs(candidates,target-candidates[i],i,path,res);
            path.pop_back();
        }
    }
};

20、接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。感谢 Marcos 贡献此图。

示例:

输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6

class Solution {
public:
    // 时间复杂度：O(n)，空间复杂度：O(1)
    int trap(vector<int>& height) {
        int res = 0;
        int l = 0, r = height.size()-1;
        int max_left = 0, max_right = 0;
        while(l
            if(height[l]
                if(height[l]>=max_left) max_left = height[l];
                else res += max_left-height[l];
                l++;
            }
            else{
                if(height[r]>=max_right) max_right = height[r];
                else res += max_right-height[r];
                r--;
            }
        }
        return res;
    }
};

21、全排列

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

class Solution {
public:
    // 时间复杂度：O(n!)，空间复杂度：O(1)
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        help(nums,res,0);
        return res;
    }
    void help(vector<int>& nums, vector<vector<int>> &res, int k){
        if(k==nums.size()-1) res.push_back(nums);
        for(int i=k;i
            swap(nums[i],nums[k]);
            help(nums,res,k+1);
            swap(nums[i],nums[k]);
        }
    }
};

22、旋转图像

给定一个 n × n 的二维矩阵表示一个图像。
将图像顺时针旋转 90 度。

说明：
你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

示例 1:

给定 matrix =
[
[1,2,3],
[4,5,6],
[7,8,9]
],

原地旋转输入矩阵，使其变为:
[
[7,4,1],
[8,5,2],
[9,6,3]
]示例 2:

给定 matrix =
[
[ 5, 1, 9,11],
[ 2, 4, 8,10],
[13, 3, 6, 7],
[15,14,12,16]
],

原地旋转输入矩阵，使其变为:
[
[15,13, 2, 5],
[14, 3, 4, 1],
[12, 6, 8, 9],
[16, 7,10,11]
]

class Solution {
public:
    // 时间复杂度：O(n^2)，空间复杂度：O(1)
    void rotate(vector<vector<int>>& matrix) {
        int n= matrix.size();
        for(int i=0;i
            for(int j=i;j
                swap(matrix[i][j],matrix[j][i]);
            }
        }
        for(int i=0;i
            for(int j=0;j2;j++){
                swap(matrix[i][j],matrix[i][n-1-j]);
            }
        }
    }
};

23、字母异位词分组

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”],
输出:
[
[“ate”,”eat”,”tea”],
[“nat”,”tan”],
[“bat”]
]说明：

所有输入均为小写字母。
不考虑答案输出的顺序。

class Solution {
public:
// 时间复杂度：O(NK)，空间复杂度：O(NK)
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string,int> map;
        vector<vector<string>> res;
        int k = 0;
        for(int i=0;i
            string str = strs[i];
            string node(26,'0'); 
            for(int j=0;j
                int t = node[str[j]-'a']-'0'+1;
                node[str[j]-'a']= '0' + t;
            }
            if(map.find(node)!=map.end()){
                res[map[node]].push_back(str);
            }
            else{
                map[node] = k;
                res.push_back(vector<string>{str});
                k++;
            }
        }
        return res;
    }
};

24、最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
进阶:

如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。

class Solution {
public:
    // 时间复杂度：O(n)，空间复杂度：O(1)
    int maxSubArray(vector<int>& nums) {
        int res = INT_MIN;
        int add = 0;
        for(int i=0;i
            add+=nums[i];
            res=max(res,add);
            if(add<0) add=0;
        }
        return res;
    }
};

25、跳跃游戏

给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。

示例 1:

输入: [2,3,1,1,4]
输出: true
解释: 我们可以先跳 1 步，从位置 0 到达位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2:

输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ，所以你永远不可能到达最后一个位置。

class Solution {
public:
    // 时间复杂度：O(n)，空间复杂度：O(1)
    bool canJump(vector<int>& nums) {
       int last = nums.size()-1;
       for(int i=nums.size()-2;i>=0;i--){
           if(i+nums[i]>=last) last = i;
       }
       return last == 0;
    }
};

26、合并区间

给出一个区间的集合，请合并所有重叠的区间。

示例 1:

输入: [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2:

输入: [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

class Solution {
public:
// 时间复杂度：O(nlogn)，空间复杂度：O(1)
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> res;
        sort(intervals.begin(),intervals.end(),Sort);
        for(int i=0;i
            if(res.empty() || intervals[i][0]>res[res.size()-1][1])
                res.push_back(intervals[i]);
            else
                res[res.size()-1][1] = max(res[res.size()-1][1],intervals[i][1]);
        }
        return res;
    }
    static bool Sort(vector<int> &a,vector<int> &b) {
        return a[0]0];
    }
};

27、不同路径

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
问总共有多少条不同的路径？

例如，上图是一个7 x 3 的网格。有多少可能的路径？

说明：m 和 n 的值均不超过 100。

示例 1:

输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。

向右 -> 向右 -> 向下
向右 -> 向下 -> 向右
向下 -> 向右 -> 向右
示例 2:

输入: m = 7, n = 3
输出: 28

class Solution {
public:
// 时间复杂度：O(nm)，空间复杂度：O(nm)
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m+1,vector<int>(n+1));
        dp[0][0] = 0;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(i==1||j==1) dp[i][j] = 1;
                else dp[i][j] = dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m][n];
    }
};

28、最小路径和

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例:

输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

class Solution {
public:
// 时间复杂度：O(nm)，空间复杂度：O(nm)
    int minPathSum(vector<vector<int>>& grid) {
        int res = INT_MAX;
        int m = grid.size(), n = grid[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));
        for(int i=0;i
            for(int j=0;j
                if(i==0&&j==0) dp[i][j] = grid[i][j];
                else{
                    if(i==0) dp[i][j] = dp[i][j-1] + grid[i][j];
                    else if(j==0) dp[i][j] = dp[i-1][j] + grid[i][j];
                    else dp[i][j] = min(dp[i][j-1],dp[i-1][j]) + grid[i][j];
                }
            }
        }
        return dp[m-1][n-1];
    }
};

29、爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释：有两种方法可以爬到楼顶。

1 阶 + 1 阶
2 阶
示例 2：

输入： 3
输出： 3
解释：有三种方法可以爬到楼顶。

1 阶 + 1 阶 + 1 阶
1 阶 + 2 阶
2 阶 + 1 阶

class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(1)
    int climbStairs(int n) {
        // 1 2 3 5
        int i=0,j=1,k=0;
        while(k
            int t = j;
            j = i+j;
            i = t;
            k++;
        }
        return j;
    }
};

30、编辑距离

给定两个单词 word1 和 word2，计算出将 word1 转换成 word2 所使用的最少操作数。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符
示例 1:

输入: word1 = “horse”, word2 = “ros”
输出: 3
解释:
horse -> rorse (将 ‘h’ 替换为 ‘r’)
rorse -> rose (删除 ‘r’)
rose -> ros (删除 ‘e’)
示例 2:

输入: word1 = “intention”, word2 = “execution”
输出: 5
解释:
intention -> inention (删除 ‘t’)
inention -> enention (将 ‘i’ 替换为 ‘e’)
enention -> exention (将 ‘n’ 替换为 ‘x’)
exention -> exection (将 ‘n’ 替换为 ‘c’)
exection -> execution (插入 ‘u’)

class Solution {
public:
// 时间复杂度：O(mn)，空间复杂度：O(mn)
    int minDistance(string word1, string word2) {
        int m= word1.size(), n=word2.size();
        vector<vector<int>> dp(m+1,vector<int>(n+1));
        for(int i=0;i<=m;i++){
            for(int j=0;j<=n;j++){
                if(i==0||j==0) dp[i][j]= max(i,j);
                else if(word1[i-1]==word2[j-1]) dp[i][j] = dp[i-1][j-1];
                else dp[i][j]= min(dp[i-1][j],min(dp[i][j-1],dp[i-1][j-1])) + 1;
            }
        }
        return dp[m][n];
    }
};

31、颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:
不能使用代码库中的排序函数来解决这道题。

示例:

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]
进阶：

一个直观的解决方案是使用计数排序的两趟扫描算法。
首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。
你能想出一个仅使用常数空间的一趟扫描算法吗？

class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(1)
    void sortColors(vector<int>& nums) {
        int p0 = 0, p2 = nums.size()-1, cur = 0;
        while(cur<=p2){
            if(nums[cur] == 0){
                swap(nums[p0],nums[cur]); 
                p0++;
                cur++;
            }
            else if(nums[cur] == 2){
                swap(nums[p2],nums[cur]); 
                p2--;
            }
            else cur++;
        }
    }
};

32、最小覆盖子串

给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字母的最小子串。

示例：

输入: S = “ADOBECODEBANC”, T = “ABC”
输出: “BANC”
说明：

如果 S 中不存这样的子串，则返回空字符串 “”。
如果 S 中存在这样的子串，我们保证它是唯一的答案。

class Solution {
public:
// 时间复杂度：O(S+T)，空间复杂度：O(S+T)
    string minWindow(string s, string t) {
        int start = 0, len = INT_MAX;
        int l = 0, r = 0;
        unordered_map<char,int> map;
        unordered_map<char,int> match;
        for(char c : t) map[c]++;
        
        int count = 0;
        while(r
            char t = s[r];
            if(map.count(t)){
                match[t]++;
                if(map[t] == match[t]){
                    count++;
                }
            }
            r++;

            while(map.size()==count){
                if(r-l
                    start = l;
                    len = r-l;
                }
                char t2 = s[l];
                if(map.count(t2)){
                    match[t2]--;
                    if(match[t2]<map[t2]){
                        count--;
                    }
                }
                l++;
            }
        }
        return len == INT_MAX? "":s.substr(start,len);
    }
};

33、子集

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:

输入: nums = [1,2,3]
输出:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]

class Solution {
public:
    // 利用二进制，时间复杂度：O(2^n)，空间复杂度：O(2^n)
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res;
        int len = 1<
        for(int i=0;i
            vector<int> tmp;
            for(int j=0;j
                if(i&(1<
            }
            res.push_back(tmp);
        }
        return res;
    }
};

class Solution {
public:
// 时间复杂度：O(2^n)，空间复杂度：O(2^n)
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res{{}};
        for(int i=0;i
            int len = res.size();
            for(int j=0;j
                vector<int> tmp(res[j]);
                tmp.push_back(nums[i]);
                res.push_back(tmp);
            }
        }
        return res;
    }
};

34、单词搜索

给定一个二维网格和一个单词，找出该单词是否存在于网格中。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例:

board =
[
[‘A’,’B’,’C’,’E’],
[‘S’,’F’,’C’,’S’],
[‘A’,’D’,’E’,’E’]
]

给定 word = “ABCCED”, 返回 true.
给定 word = “SEE”, 返回 true.
给定 word = “ABCB”, 返回 false.

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        for(int i=0;i
            for(int j=0;j0].size();j++){
                if(help(board,i,j,word,0)) return true;
            }
        }
        return false;
    }
    bool help(vector<vector<char>> &board, int i, int j, string word, int k) {
        if(i<0||i>=board.size()||j<0||j>=board[0].size()||board[i][j]=='*'||board[i][j]!=word[k]) return false;
        if(k==word.size()-1) return true;
        char tmp = board[i][j];
        board[i][j] = '*';
        if(help(board,i-1,j,word,k+1)
        || help(board,i+1,j,word,k+1)
        || help(board,i,j-1,word,k+1)
        || help(board,i,j+1,word,k+1)){
            return true;
        }
        board[i][j] = tmp;
        return false;
    }
};

35、柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
求在该柱状图中，能够勾勒出来的矩形的最大面积。

以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为 [2,1,5,6,2,3]。

图中阴影部分为所能勾勒出的最大矩形面积，其面积为 10 个单位。

示例:

输入: [2,1,5,6,2,3]
输出: 10

class Solution {
public:
    // 时间复杂度：O(nlogn)，空间复杂度：O(n) 有时候通过有时候超时
    int largestRectangleArea(vector<int>& heights) {
        return help(heights,0,heights.size()-1);
    }
    int help(vector<int> &heights, int l, int r){
        if(l>r) return 0;
        int low = l;
        for(int i=l;i<=r;i++){
            if(heights[i]
        }
        return max(heights[low]*(r-l+1),max(help(heights,l,low-1),help(heights,low+1,r)));
    }
};

class Solution {
public:
    // 时间复杂度：O(n)，空间复杂度：O(n)
    int largestRectangleArea(vector<int>& heights) {        
        stack<int> st;
        heights.push_back(0);
        int size = heights.size();
        int res = 0;
        for (int i = 0; i < size; i++) {
            while (!st.empty() && heights[st.top()] >= heights[i]) {
                int val = st.top();
                st.pop();
                res = max(res, heights[val] * (st.empty() ? i : (i - st.top() - 1)));
            }
            st.push(i);
        }
        return res;
    } 
};

36、最大矩形

给定一个仅包含 0 和 1 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。

示例:

输入:
[
[“1”,”0”,”1”,”0”,”0”],
[“1”,”0”,”1”,”1”,”1”],
[“1”,”1”,”1”,”1”,”1”],
[“1”,”0”,”0”,”1”,”0”]
]输出: 6

class Solution {
public:
// 时间复杂度：O(n*m)，空间复杂度：O(m)
    int maximalRectangle(vector<vector<char>>& matrix) {
        if(matrix.empty()) return 0;
        int res = 0;
        vector<int> vec(matrix[0].size(),0);
        for(int i=0;i
            for(int j=0;j0].size();j++){
                vec[j] = matrix[i][j]=='1'?vec[j]+1:0;
            }
            res = max(res,help(vec));
        }
        return res;
    }
    int help(vector<int> &vec){
        stack<int> stack;
        int res = 0;
        vec.push_back(0);
        for(int i=0;i
            while(!stack.empty()&&vec[stack.top()]>=vec[i]){
                int tmp = stack.top();
                stack.pop();
                res = max(res,vec[tmp]*(stack.empty()?i:(i-stack.top()-1)));
            }
            stack.push(i);
        }
        vec.pop_back();
        return res;
    }
};

37、二叉树的中序遍历

给定一个二叉树，返回它的中序遍历。

示例:

输入: [1,null,2,3]

输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    // 时间复杂度：O(n)，空间复杂度：O(logn) 递归
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        help(res,root);
        return res;
    }
    void help(vector<int> &res, TreeNode* root){
        if(!root) return;
        help(res,root->left);
        res.push_back(root->val);
        help(res,root->right);
    }
};

class Solution {
public:
    // 时间复杂度：O(n)，空间复杂度：O(n) 栈
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack stack;
        TreeNode* cur = root;
        while(cur || !stack.empty()){
            while(cur){
                stack.push(cur);
                cur = cur->left;
            }
            cur = stack.top();
            stack.pop();
            res.push_back(cur->val);
            cur = cur->right;
        }
        return res;
    }
};

class Solution {
public:
    // 时间复杂度：O(n)，空间复杂度：O(n) 线索二叉树
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        TreeNode* cur = root;
        TreeNode* next;
        while(cur){
            if(!cur->left){
                res.push_back(cur->val);
                cur = cur->right;
            }
            else{
                next = cur->left;
                while(next->right){
                    next = next->right;
                }
                next->right = cur;
                TreeNode* tmp = cur;
                cur = cur->left;
                tmp->left = NULL;
            }
        }
        return res;
    }
};

38、不同的二叉搜索树

给定一个整数 n，求以 1 … n 为节点组成的二叉搜索树有多少种？

示例:

输入: 3
输出: 5
解释:
给定 n = 3, 一共有 5 种不同结构的二叉搜索树:

1         3     3      2      1
 \       /     /      / \      \
  3     2     1      1   3      2
 /     /       \                 \
2     1         2                 3

class Solution {
public:
    // 时间复杂度：O(n^2)，空间复杂度：O(n)
    int numTrees(int n) {
        vector<int> res(n+1);
        res[0] = 1;
        res[1] = 1;
        for(int i=2;i<=n;i++){
            for(int j=1;j<=i;j++){
                res[i] += res[j-1]*res[i-j];
            }
        }
        return res[n];
    }
};

39、验证二叉搜索树

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:

输入:

1
2
3

  2
 /  \
1    3

输出: true
示例 2:

输入:

输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
根节点的值为 5 ，但是其右子节点值为 4 。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    // 时间复杂度：O(n)，空间复杂度：O(n) 中序遍历递增
    bool isValidBST(TreeNode* root) {
        stack stack;
        TreeNode* cur = root;
        //int tmp = INT_MIN; // 测试用例用[-2147483648]卡边界值过分了。。。
        long tmp = LONG_MIN;
        while(cur || !stack.empty()){
            while(cur){
                stack.push(cur);
                cur=cur->left;
            }
            cur = stack.top();
            stack.pop();
            if(cur->val<=tmp){
                return false;
            }
            tmp = cur->val;
            cur = cur->right;
        }
        return true;
    }
};

40、对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(n) 递归
    bool isSymmetric(TreeNode* root) {
        if(!root) return true;
        return help(root->left,root->right);
    }
    bool help(TreeNode* l,TreeNode* r) {
        if(!l && !r) return true;
        if(!l || !r) return false;
        return l->val==r->val && help(l->right,r->left) && help(l->left,r->right);
    }
};

class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(n) 迭代
    bool isSymmetric(TreeNode* root) {
        queue queue;
        queue.push(root);
        queue.push(root);
        while(!queue.empty()){
            TreeNode* t1 = queue.front();
            queue.pop();
            TreeNode* t2 = queue.front();
            queue.pop();
            if(!t1 && !t2) continue;
            if(!t1 || !t2) return false;
            if(t1->val != t2->val) return false;
            queue.push(t1->left);
            queue.push(t2->right);
            queue.push(t2->left);
            queue.push(t1->right);
        }
        return true;
    }
};

41、二叉树的层次遍历

给定一个二叉树，返回其按层次遍历的节点值。（即逐层地，从左到右访问所有节点）。

例如:
给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(n) 
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue queue;
        if(root) queue.push(root);
        while(!queue.empty()){
            int count = queue.size();
            vector<int> tmp;
            while(count!=0){
                tmp.push_back(queue.front()->val);
                count--;
                if(queue.front()->left) queue.push(queue.front()->left);
                if(queue.front()->right) queue.push(queue.front()->right);
                queue.pop();
            }
            res.push_back(tmp);
        }
        return res;
        
    }
};

42、二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(logn) 
    int maxDepth(TreeNode* root) {
        if(!root) return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

43、从前序与中序遍历序列构造二叉树

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(n) 
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return help(preorder,0,preorder.size()-1,inorder,0,inorder.size()-1);
    }
    TreeNode* help(vector<int>& pre,int pl,int pr,vector<int>& vin,int vl,int vr) {
        if(pl>pr || vl>vr) return NULL;
        TreeNode* head = new TreeNode(pre[pl]);
        int i;
        for(i=vl;i<=vr;i++){
            if(vin[i]==pre[pl]) break;
        }
        int num = i-vl;
        head->left=help(pre,pl+1,pl+num,vin,vl,vl+num-1);
        head->right=help(pre,pl+num+1,pr,vin,vl+num+1,vr);
        return head;
    }
};

44、二叉树展开为链表

给定一个二叉树，原地将它展开为链表。

例如，给定二叉树

将其展开为：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    // 先序遍历 线索二叉树
    // 时间复杂度：O(n)，空间复杂度：O(1) 
    void flatten(TreeNode* root) {
        TreeNode* cur = root;
        TreeNode* next;
        while(cur){
            if(!cur->left){
                cur = cur->right;
            }
            else{
                next = cur->left;
                while(next->right){
                    next = next->right;
                }
                next->right = cur->right;
                cur->right = cur->left;
                cur->left = NULL;
                cur = cur->right;
            }
        }
    }
    /*
    // 中序遍历 线索二叉树
    vector inorderTraversal(TreeNode* root) {
        vector res;
        TreeNode* cur = root;
        TreeNode* next;
        while(cur){
            if(!cur->left){
                res.push_back(cur->val);
                cur = cur->right;
            }
            else{
                next = cur->left;
                while(next->right){
                    next = next->right;
                }
                next->right = cur;
                TreeNode* tmp = cur;
                cur = cur->left;
                tmp->left = NULL;
            }
        }
        return res;
    }
    */
};

45、买卖股票的最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

注意你不能在买入股票前卖出股票。

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(1) 
    int maxProfit(vector<int>& prices) {
        int res = 0;
        int minp = INT_MAX;
        for(int i=0;i
            minp=min(minp,prices[i]);
            res = max(res,prices[i]-minp);
        }
        return res;
    }
};

46、二叉树中的最大路径和

给定一个非空二叉树，返回其最大路径和。

本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。

示例 1:

输入: [1,2,3]

  1 / \2   3

输出: 6
示例 2:

输入: [-10,9,20,null,null,15,7]

-10
/
9 20
/
15 7

输出: 42

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(logn) 
    int maxPathSum(TreeNode* root) {
        int res=INT_MIN;
        help(root,res);
        return res;
    }
    int help(TreeNode* root,int &res){ // 从root向下走的最长距离
        if(!root) return 0;
        int l = max(0, help(root->left,res));
        int r = max(0, help(root->right,res));
        res = max(res,root->val+l+r);
        return root->val+max(l,r);
    }
};

47、最长连续序列

给定一个未排序的整数数组，找出最长连续序列的长度。

要求算法的时间复杂度为 O(n)。

示例:

输入: [100, 4, 200, 1, 3, 2]
输出: 4
解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。

class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(n) 
    int longestConsecutive(vector<int>& nums) {
        int res = 0;
        set<int> s(nums.begin(),nums.end());
        set<int>::iterator it;
        for(it = s.begin();it!=s.end();it++){
            int beg = *it;
            if(s.find(beg-1)==s.end()){
                int len = 1;
                while(s.find(beg+1)!=s.end()){
                    len++;
                    beg++;
                }
                res=max(res,len);
            }
        }
        return res;
    }
};

48、只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1
示例 2:

输入: [4,1,2,1,2]
输出: 4

class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(1) 
    int singleNumber(vector<int>& nums) {
        int res;
        for(int num:nums) res^=num;
        return res;
    }
};

49、单词拆分

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

拆分时可以重复使用字典中的单词。
你可以假设字典中没有重复的单词。
示例 1：

输入: s = “leetcode”, wordDict = [“leet”, “code”]
输出: true
解释: 返回 true 因为 “leetcode” 可以被拆分成 “leet code”。
示例 2：

输入: s = “applepenapple”, wordDict = [“apple”, “pen”]
输出: true
解释: 返回 true 因为 “applepenapple” 可以被拆分成 “apple pen apple”。
注意你可以重复使用字典中的单词。
示例 3：

输入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”]
输出: false

class Solution {
public:
// 时间复杂度：O(n^2)，空间复杂度：O(n) 
    // dp[i]表示字符串s的前i个字符能否拆分成wordDict
    bool wordBreak(string s, vector<string>& wordDict) {
        vector<bool> flag(s.size()+1,false);
        unordered_set<string> set(wordDict.begin(),wordDict.end());
        flag[0] = true;
        for(int i=1;i<=s.size();i++){
            for(int j=0;j
                if(flag[j] && set.find(s.substr(j,i-j))!=set.end()){
                    flag[i]=true;
                    break;
                }
            }
        }
        return flag[s.size()];
    }
};

50、环形链表

给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
// 时间复杂度：O(n)，空间复杂度：O(1) 
    bool hasCycle(ListNode *head) {
        if(!head) return false;
        ListNode * fast = head;
        ListNode * slow = head;
        while(fast && fast->next){
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow) return true;
        }
        return false;
    }
};

技术类编程题汇总 C++ 刷题记录

2019-12-02T03:57:52.000Z

腾讯2018春招技术类编程题汇总

1、翻转数列

小Q定义了一种数列称为翻转数列:
给定整数n和m, 满足n能被2m整除。对于一串连续递增整数数列1, 2, 3, 4…, 每隔m个符号翻转一次, 最初符号为’-‘;。
例如n = 8, m = 2, 数列就是: -1, -2, +3, +4, -5, -6, +7, +8.
而n = 4, m = 1, 数列就是: -1, +2, -3, + 4.
小Q现在希望你能帮他算算前n项和为多少。

输入描述:
输入包括两个整数n和m(2 <= n <= 109, 1 <= m), 并且满足n能被2m整除。

输出描述:
输出一个整数, 表示前n项和。

输入例子1:
8 2

输出例子1:
8

#include 
using namespace std;

// 暴力法 case通过率为80.00%，超时
long long fun(int n, int m) {
long long res = 0;
int k = 0, flag = -1;
for (int i = 0; i < n/m; i++){
for (int j = 0; j < m; j++){
k = flag * (abs(k) + 1);
res += k;
}
flag *= -1;
}
return res;
}

// 找规律：第一个加号值加上第一个减号值,差值刚好是m,共有n/2对
// -1, -2, +3, +4, -5, -6, +7, +8
long long fun2(int n, int m) {
    return n/2*m;
}

int main() {
int n, m;
cin >> n >> m;

cout << fun2(n,m) << endl;
return 0;
}

2、纸牌游戏

牛牛和羊羊正在玩一个纸牌游戏。这个游戏一共有n张纸牌, 第i张纸牌上写着数字ai。
牛牛和羊羊轮流抽牌, 牛牛先抽, 每次抽牌他们可以从纸牌堆中任意选择一张抽出, 直到纸牌被抽完。
他们的得分等于他们抽到的纸牌数字总和。
现在假设牛牛和羊羊都采用最优策略, 请你计算出游戏结束后牛牛得分减去羊羊得分等于多少。

输入描述:
输入包括两行。
第一行包括一个正整数n(1 <= n <= 105),表示纸牌的数量。
第二行包括n个正整数ai(1 <= ai <= 109),表示每张纸牌上的数字。

输出描述:
输出一个整数, 表示游戏结束后牛牛得分减去羊羊得分等于多少。

输入例子1:
32 7 4

输出例子1:
5

#include 
#include 
#include 
using namespace std;

int main(){
int n;
cin >> n;
priority_queue<int, vector<int>,less<int>> card;
int t;
for (int i = 0; i < n; i++){
cin >> t;
card.push(t);
}

int res = 0;
int flag = 1;
while (!card.empty()){
int c = card.top();
res += flag*c;
flag *= -1;
card.pop();
}
cout << res << endl;
return 0;
}

3、贪吃的小Q

小Q的父母要出差N天，走之前给小Q留下了M块巧克力。小Q决定每天吃的巧克力数量不少于前一天吃的一半，但是他又不想在父母回来之前的某一天没有巧克力吃，请问他第一天最多能吃多少块巧克力

输入描述:
每个输入包含一个测试用例。
每个测试用例的第一行包含两个正整数，表示父母出差的天数N(N<=50000)和巧克力的数量M(N<=M<=100000)。

输出描述:
输出一个数表示小Q第一天最多能吃多少块巧克力。

输入例子1:
3 7

输出例子1:
4

#include 
#include 
using namespace std;

int fun(int n, int m){
int start = ceil(m / 2.0);
for (int i = start; i >= 1; i--){
int t = 0;
int ti = i;
for (int j = 0; j < n; j++){
t += ti;
if (ti != 1)
ti = ceil(ti / 2.0);
}
if (t <= m)
return i;
}
return 0;
}

int main(){
int n, m;
cin >> n >> m;

if (n == 1)
cout << m << endl;
else
cout << fun(n, m) << endl;
return 0;
}

4、小Q的歌单

小Q有X首长度为A的不同的歌和Y首长度为B的不同的歌，现在小Q想用这些歌组成一个总长度正好为K的歌单，每首歌最多只能在歌单中出现一次，在不考虑歌单内歌曲的先后顺序的情况下，请问有多少种组成歌单的方法。

输入描述:
每个输入包含一个测试用例。
每个测试用例的第一行包含一个整数，表示歌单的总长度K(1<=K<=1000)。
接下来的一行包含四个正整数，分别表示歌的第一种长度A(A<=10)和数量X(X<=100)以及歌的第二种长度B(B<=10)和数量Y(Y<=100)。保证A不等于B。

输出描述:
输出一个整数,表示组成歌单的方法取模。因为答案可能会很大,输出对1000000007取模的结果。

输入例子1:
52 3 3 3

输出例子1:
9

#include 
#include 
using namespace std;

// n选k组合数C(n,k) = C(n-1,k) + C(n-1,k-1）
void CreatSelect(vector<vector<long long>> &arr){
arr[0][0] = 1;
for (int i = 1; i <= 100; i++){
arr[i][0] = 1;
for (int j = 1; j <= 100; j++){
arr[i][j] = (arr[i - 1][j] + arr[i - 1][j - 1] )% 1000000007;
}
}
}

long long fun(int k, int a, int x, int b, int y, vector<vector<long long>> arr){
long long res = 0;
for (int i = 0; i <= k / a && i <= x; i++){
if ((k - a*i) % b == 0 && (k - a*i) / b <= y){
// x里选i个a，y里选(k - a*i) / b个b
res = (res + arr[x][i] * arr[y][(k - a*i) / b] % 1000000007) % 1000000007;
}
}
return res;
}

int main(){
int k;
cin >> k;
int a, b, x, y;
cin >> a >> x >> b >> y;

vector<vector<long long>> arr(101, vector<long long>(101));
CreatSelect(arr);

cout << fun(k, a, x, b, y, arr)  << endl;

return 0;
}

5、安排机器

小Q的公司最近接到m个任务, 第i个任务需要xi的时间去完成, 难度等级为yi。
小Q拥有n台机器, 每台机器最长工作时间zi, 机器等级wi。
对于一个任务,它只能交由一台机器来完成, 如果安排给它的机器的最长工作时间小于任务需要的时间, 则不能完成,如果完成这个任务将获得200 * xi + 3 * yi收益。

对于一台机器,它一天只能完成一个任务, 如果它的机器等级小于安排给它的任务难度等级, 则不能完成。

小Q想在今天尽可能的去完成任务, 即完成的任务数量最大。如果有多种安排方案,小Q还想找到收益最大的那个方案。小Q需要你来帮助他计算一下。

输入描述:
输入包括N + M + 1行,
输入的第一行为两个正整数n和m(1 <= n, m <= 100000), 表示机器的数量和任务的数量。
接下来n行,每行两个整数zi和wi(0 < zi < 1000, 0 <= wi <= 100), 表示每台机器的最大工作时间和机器等级。
接下来的m行,每行两个整数xi和yi(0 < xi < 1000, 0 <= yi<= 100), 表示每个任务需要的完成时间和任务的难度等级。

输出描述:
输出两个整数, 分别表示最大能完成的任务数量和获取的收益。

输入例子1:
1 2
100 3
100 2
100 1

输出例子1:
1 20006

#include 
#include 
#include 
#include 
using namespace std;

struct  Node {
int time, grade;
};

bool Cmp(const Node &a, const Node &b) {
if (a.time == b.time)
return a.grade > b.grade;
return a.time > b.time;
}

// case通过率为90.00%，超时
int main() {
int n, m; //机器的数量和任务的数量 1 <= n, m <= 100000
cin >> n >> m;
vector machine(n);
vector task(m);
for (int i = 0; i < n; i++){
cin >> machine[i].time >> machine[i].grade;
}
for (int i = 0; i < m; i++){
cin >> task[i].time >> task[i].grade;
}

sort(machine.begin(), machine.end(), Cmp);
sort(task.begin(), task.end(), Cmp);

int res = 0, value = 0;

bool* flag = new bool[n];
memset(flag, true, n);
for (int i = 0; i < m; i++){
int min_grade = 101;
int min_j;
for (int j = 0; j < n; j++){
if (flag[j]){
if (task[i].time <= machine[j].time){
if (task[i].grade <= machine[j].grade && machine[j].grade < min_grade){
min_grade = machine[j].grade;
min_j = j;
}
}
else{
break;
}
}
}
if (min_grade != 101){
res++;
value += 200 * task[i].time + 3 * task[i].grade;
flag[min_j] = false;
}
}

delete[] flag;

cout << res << " " << value << endl;

return 0;
}

6、画家小Q

画家小Q又开始他的艺术创作。小Q拿出了一块有NxM像素格的画板, 画板初始状态是空白的,用’X’表示。
小Q有他独特的绘画技巧,每次小Q会选择一条斜线, 如果斜线的方向形如’/‘,即斜率为1,小Q会选择这条斜线中的一段格子,都涂画为蓝色,用’B’表示;如果对角线的方向形如’',即斜率为-1,小Q会选择这条斜线中的一段格子,都涂画为黄色,用’Y’表示。
如果一个格子既被蓝色涂画过又被黄色涂画过,那么这个格子就会变成绿色,用’G’表示。
小Q已经有想画出的作品的样子, 请你帮他计算一下他最少需要多少次操作完成这幅画。

输入描述:
每个输入包含一个测试用例。
每个测试用例的第一行包含两个正整数N和M(1 <= N, M <= 50), 表示画板的长宽。
接下来的N行包含N个长度为M的字符串, 其中包含字符’B’,’Y’,’G’,’X’,分别表示蓝色,黄色,绿色,空白。整个表示小Q要完成的作品。

输出描述:
输出一个正整数, 表示小Q最少需要多少次操作完成绘画。

输入例子1:
4 4
YXXB
XYGX
XBYY
BXXY

输出例子1:
3

例子说明1:
XXXX
XXXX
XXXX
XXXX
->
YXXX
XYXX
XXYX
XXXY
->
YXXB
XYBX
XBYX
BXXY
->
YXXB
XYGX
XBYY
BXXY

#include 
#include 
#include 

using namespace std;

int n, m; //N和M(1 <= N, M <= 50), 表示画板的长宽
vector<vector<char>> arr;

void fun_b(int i, int j){
if (i >= 0 && i < n && j >= 0 && j < m && (arr[i][j] == 'B' || arr[i][j] == 'G')){
if (arr[i][j] == 'B') 
arr[i][j] = 'X';
else 
arr[i][j] = 'Y';
fun_b(i - 1,j + 1);
fun_b(i + 1, j - 1);
}
return;
}

void fun_y(int i, int j){
if (i >= 0 && i < n && j >= 0 && j < m && (arr[i][j] == 'Y' || arr[i][j] == 'G')){
if (arr[i][j] == 'Y') 
arr[i][j] = 'X';
else 
arr[i][j] = 'B';
fun_y(i + 1, j + 1);
fun_y(i - 1, j - 1);
}
return;
}

/*
YXXB
XYGX
XBYY
BXXY
*/

int fun() {
int res = 0;
for (int i = 0; i < n; i++){
for (int j = 0; j < m; j++){
if (arr[i][j] == 'B'){
fun_b(i, j);
res++;
}
if (arr[i][j] == 'Y'){
fun_y(i, j);
res++;
}
if (arr[i][j] == 'G'){
fun_b(i, j);
fun_y(i, j);
res += 2;
}
}
}
return res;
}

int main() {
cin >> n >> m; 
arr = vector<vector<char>> (n, vector<char>(m));
string str;
for (int i = 0; i < n; i++){
cin >> str;
for (int j = 0; j < m; j++){
arr[i][j] = str[j];
}
}
 
cout << fun() << endl;

return 0;
}

腾讯2017秋招笔试编程题

1、编码

假定一种编码的编码范围是a ~ y的25个字母，从1位到4位的编码，如果我们把该编码按字典序排序，形成一个数组如下： a, aa, aaa, aaaa, aaab, aaac, … …, b, ba, baa, baaa, baab, baac … …, yyyw, yyyx, yyyy 其中a的Index为0，aa的Index为1，aaa的Index为2，以此类推。编写一个函数，输入是任意一个编码，输出这个编码对应的Index.

输入描述:
输入一个待编码的字符串,字符串长度小于等于100.

输出描述:
输出这个编码的index

输入例子1:
baca

输出例子1:
16331

#include 
#include 
#include 

using namespace std;

vector<int> loop = { 0, 1, 26, 651, 16276 };

int fun(string str) {
int res = 0, len = str.size();
for (int i = 0; i < len; i++){
res += (str[i] - 'a')*loop[4 -i]+1;
}
return res-1;
}

int main() {
string str;

while (cin >> str){
cout << fun(str) << endl;
}
return 0;
}

2、游戏任务标记

游戏里面有很多各式各样的任务，其中有一种任务玩家只能做一次，这类任务一共有1024个，任务ID范围[1,1024]。请用32个unsigned int类型来记录着1024个任务是否已经完成。初始状态都是未完成。输入两个参数，都是任务ID，需要设置第一个ID的任务为已经完成；并检查第二个ID的任务是否已经完成。输出一个参数，如果第二个ID的任务已经完成输出1，如果未完成输出0。如果第一或第二个ID不在[1,1024]范围，则输出-1。

输入描述:
输入包括一行,两个整数表示人物ID.

输出描述:
输出是否完成

输入例子1:
1024 1024

输出例子1:
1

#include 

using namespace std;

unsigned int flag[32];

// unsigned int为32位，32个unsigned int为32*32=1024
int fun(int n, int m) {
// Index(N) = N / 32 = N >> 5;
// Position(N) = N % 32 = N & 31; （对于2的幂的数才能）
int index, position;
index = (n - 1) >> 5;
position = (n-1) & 31;
flag[index] |= 1 << position;
if (m >= 1 && m <= 1024){
index = (m - 1) >> 5;
position = (m - 1) & 31;
return (flag[index]&(1<0;
}
return -1;
}

int main() {
int n,m;
cin >> n >> m;

cout << fun(n, m) << endl;
return 0;
}

3、素数对

给定一个正整数，编写程序计算有多少对质数的和等于输入的这个正整数，并输出结果。输入值小于1000。
如，输入为10, 程序应该输出结果为2。（共有两对质数的和为10,分别为(5,5),(3,7)）

输入描述:
输入包括一个整数n,(3 ≤ n < 1000)

输出描述:
输出对数

输入例子1:
10

输出例子1:
2

#include 

using namespace std;

// 质数：只能被１和本身整除，最小质数为２
bool is_zhishu(int x) {
for (int i = 2; i*i <= x; i++){
if (x%i == 0)
return false;
}
return true;
}

int fun(int n) {
int res = 0;
for (int i = 2; i <= n / 2; i++){
if (is_zhishu(i) && is_zhishu(n - i))
res++;
}
return res;
}

int main() {
int n;
cin >> n;

cout << fun(n) << endl;
return 0;
}

4、geohash编码

geohash编码：geohash常用于将二维的经纬度转换为字符串，分为两步：第一步是经纬度的二进制编码，第二步是base32转码。
此题考察纬度的二进制编码：算法对纬度[-90, 90]通过二分法进行无限逼近（取决于所需精度，本题精度为6）。注意，本题进行二分法逼近过程中只采用向下取整来进行二分，针对二分中间值属于右区间。算法举例如下：针对纬度为80进行二进制编码过程：
1) 区间[-90, 90]进行二分为[-90, 0),[0, 90]，成为左右区间，可以确定80为右区间，标记为1；
2) 针对上一步的右区间[0, 90]进行二分为[0, 45),[45, 90]，可以确定80是右区间，标记为1；
3) 针对[45, 90]进行二分为[45, 67),[67,90],可以确定80为右区间，标记为1；
4) 针对[67,90]进行二分为[67, 78),[78,90]，可以确定80为右区间，标记为1；
5) 针对[78, 90]进行二分为[78, 84),[84, 90]，可以确定80为左区间，标记为0；
6) 针对[78, 84)进行二分为[78, 81), [81, 84)，可以确定80为左区间，标记为0；

输入描述:
输入包括一个整数n,(-90 ≤ n ≤ 90)

输出描述:
输出二进制编码

输入例子1:
80

输出例子1:
111100

#include 
#include 
#include 

using namespace std;

// -66
string fun(int n) {
string res;
int k = 0;
int l = -90, r = 90;
while (k != 6){
int mid = floor((l + r) / 2.0);
if (mid <= n){
res.push_back('1');
l = mid;
}
else{
res.push_back('0');
r = mid;
}
k++;
}
return res;
}

string fun2(int n) {
string res;
int k = 0;
int l = -90, r = 90;
while (k != 6){
int mid = l + r > 0 ? floor((l + r) / 2.0) : -floor(-(l + r) / 2.0);
if (mid <= n){
res.push_back('1');
l = mid;
}
else{
res.push_back('0');
r = mid;
}
k++;
}
return res;
}

int main() {
int n; // (-90 ≤ n ≤ 90)
cin >> n;

cout << fun2(n) << endl;
return 0;
}

注：题中向下取整存在歧义

腾讯2017暑期实习生编程题

1、构造回文

给定一个字符串s，你可以从中删除一些字符，使得剩下的串是一个回文串。如何删除才能使得回文串最长呢？
输出需要删除的字符个数。

输入描述:

输入数据有多组，每组包含一个字符串s，且保证:1<=s.length<=1000.

输出描述:

对于每组数据，输出一个整数，代表最少需要删除的字符个数。

输入例子1:
abcda
google

输出例子1:
22

#include 
#include 
#include 
#include 

using namespace std;

// 求原字符串和其反串的最大公共子序列的长度
int fun(string s1, string s2) {
if (s1.size() == 1) return 1;
int len = s1.size();
vector<vector<int>> arr(len + 1, vector<int>(len + 1));
for (int i = 0; i <= len; i++){
for (int j = 0; j <= len; j++){
if (i == 0 || j == 0){
arr[i][j] =0;
}
else if (s1[i-1] == s2[j-1]){
arr[i][j] = arr[i - 1][j - 1] + 1;
}
else{
arr[i][j] = max(arr[i][j - 1], arr[i-1][j]);
}
}
}
return arr[len][len];
}

int main() {
string s; // 1 <= s.length <= 1000
while (cin >> s){
string s2 = s;
reverse(s2.begin(), s2.end());
cout << s.size()-fun(s,s2) << endl;
}

return 0;
}

2、算法基础-字符移位

小Q最近遇到了一个难题：把一个字符串的大写字母放到字符串的后面，各个字符的相对位置不变，且不能申请额外的空间。
你能帮帮小Q吗？

输入描述:

输入数据有多组，每组包含一个字符串s，且保证:1<=s.length<=1000.

输出描述:

对于每组数据，输出移位后的字符串。

输入例子1:
AkleBiCeilD

输出例子1:
kleieilABCD

#include 
#include 

using namespace std;

bool is_upper(char c){
return c >= 'A' && c <= 'Z';
}

string fun(string &s) {
if (s.size() == 1) return s;
for (int i = 0; i < s.size(); i++){
if (is_upper(s[i])){
for (int j = i + 1; j < s.size(); j++){
if (!is_upper(s[j])){
int  k = j;
char t = s[j];
while (k>i){
s[k] = s[k - 1];
k--;
}
s[i] = t;
break;
}
}
}
}
return s;
}

int main() {
string s; // 1 <= s.length <= 1000

while (cin >> s){
cout << fun(s) << endl;
}

return 0;
}

3、有趣的数字

小Q今天在上厕所时想到了这个问题：有n个数，两两组成二元组，相差最小的有多少对呢？相差最大呢？

输入描述:

输入包含多组测试数据。
对于每组测试数据：
N - 本组测试数据有n个数
a1,a2…an - 需要计算的数据
保证:
1<=N<=100000,0<=ai<=INT_MAX.

输出描述:

对于每组数据，输出两个数，第一个数表示差最小的对数，第二个数表示差最大的对数。

输入例子1:
645 12 45 32 5 6

输出例子1:
1 2

#include 
#include 
#include 

using namespace std;

void fun(int n,vector<int> &vec) {
int min_count = 0, max_count = 0;
if (n > 1){
sort(vec.begin(), vec.end());
if (vec[0] == vec[n - 1]){ // 11111
min_count = n*(n - 1) / 2;
max_count = n*(n - 1) / 2;
}
else{
// min
int min = vec[1] - vec[0];
for (int i = 0; i < n - 1; i++){
if (vec[i + 1] - vec[i] < min){
min = vec[i + 1] - vec[i];
}
}
if (min == 0){ // 11233
int time;
for (int i = 0; i < n; i++){
time = 1;
while (i + 1 < n && vec[i + 1] == vec[i]){
time++;
i++;
}
min_count += time*(time - 1)/2;
}
}
else{ // 12457
for (int i = 0; i < n - 1; i++){
if (vec[i + 1] - vec[i] == min){
min_count++;
}
}
}

// max
int max = vec[n - 1] - vec[0];
int l = 0, r = 0;
for (int i = 0; i < n; i++){
if (vec[i] == vec[0]) l++;
else break;
}
for (int i = n - 1; i >= 0; i--){
if (vec[i] == vec[n-1]) r++;
else break;
}
max_count = l*r;
}
}
cout << min_count << " " << max_count << endl;
}

int main() {
int n;
while (cin >> n){
vector<int> vec(n);
for (int i = 0; i < n; i++){
cin >> vec[i];
}
fun(n, vec);
}

return 0;
}

腾讯2016研发工程师编程题

1、生成格雷码

在一组数的编码中，若任意两个相邻的代码只有一位二进制数不同，则称这种编码为格雷码(Gray Code)，请编写一个函数，使用递归的方法生成N位的格雷码。

给定一个整数n，请返回n位的格雷码，顺序为从0开始。

测试样例：
1返回：[“0”,”1”]

/*n: 0   1    2     3
     0   0   00   000
     1   10   100
      110
      11  010
              01
  011
  111
  101
  001
*/
class GrayCode {
public:
// 题目不严谨case通过率为9.09% 
// 用例:2
// 对应输出应该为:["00","01","11","10"]
// 你的输出为:["00","10","11","01"]
    vector<string> getGray2(int n) {
        if (n == 0) return{ "0" };
        vector<string> res{ "0", "1" };
        for (int i = 1; i < n; i++){
            for (int j = 0; j < res.size(); j++){
                res[j].push_back('0');
            }
            for (int j = res.size()-1; j >=0; j--){
                string t = res[j];
                t[t.size() - 1] = '1';
                res.push_back(t);
            }
        }
        return res;
    }
vector<string> getGray(int n) {
        if (n == 0) return{ "0" };
        vector<string> res{ "0", "1" };
        for (int i = 1; i < n; i++){
            for (int j = 0; j < res.size(); j++){
                res[j]='0' + res[j];
            }
            for (int j = res.size()-1; j >=0; j--){
                string t = res[j];
                t[0] = '1';
                res.push_back(t);
            }
        }
        return res;
    }
};

2、微信红包

春节期间小明使用微信收到很多个红包，非常开心。在查看领取红包记录时发现，某个红包金额出现的次数超过了红包总数的一半。请帮小明找到该红包金额。写出具体算法思路和代码实现，要求算法尽可能高效。

给定一个红包的金额数组gifts及它的大小n，请返回所求红包的金额。

若没有金额超过总数的一半，返回0。
测试样例：
[1,2,3,2,2],5
返回：2

class Gift {
public:
    /*
     如果重复的次数超过一半的话，一定有相邻的数字相同这种情况的
     对数组同时去掉两个不同的数字，到最后剩下的一个数就是该数字
    */
    int getValue(vector<int> gifts, int n) {
        int res = gifts[0], time = 1;
        for(int i=1;i
            if(gifts[i]==res) time++;
            else{
                time--;
                if(time == 0){
                    res = gifts[i];
                }
            }
        }
        time = 0;
        for(int i=0;i
            if(gifts[i] == res) time++;
        }
        return time>gifts.size()/2?res:0;
    }
};

3D微信小游戏轮盘控制模块 three.js

2019-11-11T08:05:00.000Z

一、场景构造

three.js基础

如果是刚接触3D引擎，关于three.js的基础知识可以参考之前的博客Three.js+tween.js 基础(一) 中的基本概念篇部分。（场景、相机、渲染器、添加对象）

微信小游戏中使用three

使用微信开发者工具创建新的小游戏模板，AppID选择测试号，得到的是飞机大战的源文件，在这个基础上进行修改。

game.js:

import './js/libs/weapp-adapter'
import './js/libs/symbol'

import Main from './js/main'

new Main()

game.json:

1
2
3

{
    "deviceOrientation": "landscapeRight"
}

改为横屏游戏。

最后，清空images、audio和js文件夹。添加 libs 和main.js空文件到js文件夹。

最终得到：

代码部分的修改在main.js。

静止的场景

main.js

代码主体部分：

// 引入three
import * as THREE from 'libs/three.js'

// 一些全局变量
var Colors = { ... }
var WIDTH = window.innerWidth;
var HEIGHT = window.innerHeight;

var Sea = function () { ... }
var Cloud = function () { ... }
var Sky = function () { ... }
var AirPlane = function () { ... }
var Pilot = function () { ... }

/**
 * 游戏主函数
 */
export default class Main {
  constructor() {
    // 创建场景，相机和渲染器
    this.createScene();
    // 添加光源
    this.createLights();
    this.start()
  }
  createScene() { ... }
  createLights() { ... }
  createPlane() { ... }
  createSea() { ... }
  createSky() { ... }

  start() {
    // 添加对象 
    this.createPlane();
    this.createSea();
    this.createSky();

    window.requestAnimationFrame(this.loop.bind(this), canvas);
  }
  update() {

  }
  loop() {
    this.update()
    this.renderer.render(this.scene, this.camera);
    window.requestAnimationFrame(this.loop.bind(this), canvas);
  }
}

动画渲染

main.js

修改update()：

update() {
  // 转动大海和云
  this.sea.mesh.rotation.z += .005;
  this.sky.rotation.z += .01;

  // 更新每帧的飞机
  this.updatePlane();

  // 更新每帧的海浪
  this.sea.moveWaves();
}

添加 updatePlane()，更新每帧的飞机

updatePlane() {
    this.airplane.propeller.rotation.x += 0.3;
    this.airplane.pilot.updateHairs();
  }

为 Pilot 添加原型函数 updateHairs() ，让头发飘起来:

Pilot.prototype.updateHairs = function () {

  // 获得头发
  var hairs = this.hairsTop.children;

  // 根据 angleHairs 的角度更新头发
  var l = hairs.length;
  for (var i = 0; i < l; i++) {
    var h = hairs[i];
    // 每根头发将周期性的基础上原始大小的75%至100%之间作调整。
    h.scale.y = .75 + Math.cos(this.angleHairs + i / 3) * .25;
  }
  // 在下一帧增加角度
  this.angleHairs += 0.16;
}

更新每帧的海浪，为 Sea 添加原型函数 moveWaves() :

Sea.prototype.moveWaves = function () {

  // 获取顶点
  var verts = this.mesh.geometry.vertices;
  var l = verts.length;

  for (var i = 0; i < l; i++) {
    var v = verts[i];

    // 获取关联的值
    var vprops = this.waves[i];

    // 更新顶点的位置
    v.x = vprops.x + Math.cos(vprops.ang) * vprops.amp;
    v.y = vprops.y + Math.sin(vprops.ang) * vprops.amp;

    // 下一帧自增一个角度
    vprops.ang += vprops.speed;
  }

  // 告诉渲染器代表大海的几何体发生改变
  // 事实上，为了维持最好的性能
  // Three.js 会缓存几何体和忽略一些修改
  // 除非加上这句
  this.mesh.geometry.verticesNeedUpdate = true;

  this.mesh.rotation.z += .005;
}

二、轮盘控制

创建UI部分

main.js

轮盘控制，分数信息，技能按钮这些部分和游戏主体分开，都创建在UI部分，使用新的场景和正交相机，需要保证在各个机型位置相对不变。这里只添加轮盘控制，分数信息，技能按钮以后再写。。。。
修改 start() 、loop() ：

start() {
    // 添加对象 
    this.createPlane();
    this.createSea();
    this.createSky();
    this.createUI();

    window.requestAnimationFrame(this.loop.bind(this), canvas);
  }
loop() {
    this.update()
    this.renderer.render(this.scene, this.camera);
    this.ui.render(this.renderer);
    window.requestAnimationFrame(this.loop.bind(this), canvas);
  }

添加 createUI()

createUI() {
  // 利用新建一个场景，并创建一个正交相机
  // 把UI元素放在这个场景里，渲染的时候同时渲染多个场景
  this.ui = new UI();
  // 创建轮盘
  var controller = new Controller();
  // console.log(controller)；
  controller.mesh.position.set(30 + controller.controllerRadius - WIDTH * 0.5, 20 + controller.controllerRadius - HEIGHT * 0.5, 0);
  this.controller = controller;
  this.ui.add(this.controller.mesh);
}

添加 UI 及其原型函数 add()、render()

var UI = function () {
  this.scene = new THREE.Scene();
  this.camera = new THREE.OrthographicCamera(WIDTH / -2, WIDTH / 2, HEIGHT / 2, HEIGHT / -2, 0, 10000);
  this.camera.position.z = 10000;
}
UI.prototype.add = function (obj) {
  this.scene.add(obj);
}
UI.prototype.render = function (renderer) {
  renderer.clearDepth();
  renderer.render(this.scene, this.camera);
}

添加轮盘 Controller

var Controller = function () {
  this.mesh = new THREE.Object3D();
  var controllerRadius = HEIGHT * 0.17 > 105 ? 105 : HEIGHT * 0.17;
  this.controllerRadius = controllerRadius;

  // 创建轮盘
  var geometry = new THREE.CircleGeometry(controllerRadius, 32);
  var material = new THREE.LineBasicMaterial({ color: 0xf7d9aa });
  geometry.vertices.shift();
  var circle = new THREE.LineLoop(geometry, material);
  this.mesh.add(circle);

  var geometry = new THREE.CircleGeometry(controllerRadius, 32);
  var material = new THREE.MeshBasicMaterial({
    color: 0xffffff,
    transparent: true,
    opacity: 0.1
  });
  var bgcircle = new THREE.Mesh(geometry, material);
  this.mesh.add(bgcircle);

  // 创建当前位置
  var wheel = new THREE.Object3D();
  wheel.name = "wheel";
  var geometry = new THREE.CircleGeometry(controllerRadius * 0.33, 32);
  var material = new THREE.MeshBasicMaterial({
    color: 0xffffff,
    transparent: true,
    opacity: 0.1
  });
  var circle1 = new THREE.Mesh(geometry, material);
  wheel.add(circle1);

  var geometry = new THREE.CircleGeometry(controllerRadius * 0.33 - 2, 32);
  var material = new THREE.MeshBasicMaterial({
    color: 0x201D13,
    transparent: true,
    opacity: 0.1
  });
  var circle2 = new THREE.Mesh(geometry, material);
  wheel.add(circle2);

  this.mesh.add(wheel);

  // 创建指向标
}

轮盘控制

main.js

start()中添加事件监听，update()中更新每帧的鼠标位置和轮盘

start() {
    // 添加对象 
    this.createPlane();
    this.createSea();
    this.createSky();
    this.createUI();

    this.mousePos = { x: 0, y: 0 };
    // 初始化事件监听
    this.touchEvent();

    window.requestAnimationFrame(this.loop.bind(this), canvas);
  }
update() {
    // 转动大海和云
    this.sea.mesh.rotation.z += .005;
    this.sky.rotation.z += .01;

    // 更新每帧的飞机
    this.updatePlane();

    // 更新每帧的海浪
    this.sea.moveWaves();

    // 更新每帧的鼠标位置
    this.updatePosition();
  }

添加 touchEvent() 事件监听，实时更新 mousePos

touchEvent() {
    canvas.addEventListener('touchstart', ((e) => {
      e.preventDefault()

      var radius = this.controller.controllerRadius;

      var tx = (e.touches[0].clientX - 30 - radius) / radius;
      var ty = (HEIGHT -e.touches[0].clientY - 20 - radius) / radius;

      if (this.checkIsFingerOnController(tx, ty)) {
        this.touched = true;
        this.controller.mesh.children[2].children[1].material.opacity = 0.3;
        this.mousePos = { x: tx, y: ty };
      }

    }).bind(this))

    canvas.addEventListener('touchmove', ((e) => {
      e.preventDefault()
      if (this.touched) {
        var radius = this.controller.controllerRadius;

        var tx = (e.touches[0].clientX - 30 - radius) / radius;
        var ty = (HEIGHT-e.touches[0].clientY - 20 - radius) / radius;
        
        if (this.checkIsFingerOnController(tx, ty)){
          this.mousePos = { x: tx, y: ty };
        }
        else{
          let k = ty/tx;
          if (tx > 0 && ty > 0) {tx = 1 / Math.sqrt(k * k + 1);ty = k * tx;}
          else if (tx < 0 && ty > 0) { tx = -1 / Math.sqrt(k * k + 1); ty = k * tx; }
          else if (tx > 0 && ty < 0) { tx = 1 / Math.sqrt(k * k + 1); ty = k * tx; }
          else { tx = -1 / Math.sqrt(k * k + 1); ty = k * tx; }
          this.mousePos = { x: tx, y: ty };
        }
      }
    }).bind(this))

    canvas.addEventListener('touchend', ((e) => {
      e.preventDefault()
      this.touched = false;
      this.controller.mesh.children[2].children[1].material.opacity = 0.1;
      this.mousePos = { x: 0, y: 0 };
    }).bind(this))
  }
  
checkIsFingerOnController(x, y) {
    return x*x+y*y<1;
  }

添加 updatePosition() ，更新当前轮盘位置

updatePosition() {
    var radius = this.controller.controllerRadius;
    // 在x轴上-radius至radius之间移动点标
    // 根据鼠标的位置在-1与1之间的范围，使用 normalize 函数实现（如下）
    var targetX = this.normalize(this.mousePos.x, -1, 1, (-1 + 0.33) * radius, (1 - 0.33)*radius);
    var targetY = this.normalize(this.mousePos.y, -1, 1, (-1 + 0.33) * radius, (1 - 0.33)*radius);

    // 在每帧通过添加剩余距离的一小部分的值移动点标
    this.controller.mesh.children[2].position.x += (targetX - this.controller.mesh.children[2].position.x) * 0.25;
    this.controller.mesh.children[2].position.y += (targetY - this.controller.mesh.children[2].position.y) * 0.25;
  }
normalize(v, vmin, vmax, tmin, tmax) {
    var nv = Math.max(Math.min(v, vmax), vmin);
    var dv = vmax - vmin;
    var pc = (nv - vmin) / dv;
    var dt = tmax - tmin;
    var tv = tmin + (pc * dt);
    return tv;
  }

修改 updatePlane() ，更新当前飞机位置

updatePlane() {
    // 在x轴上-140至140之间和y轴25至175之间移动飞机
    // 根据鼠标的位置在-1与1之间的范围，使用 normalize 函数实现（如下）

    var targetX = this.normalize(this.mousePos.x, -1, 1, -140, 140);
    var targetY = this.normalize(this.mousePos.y, -1, 1, 25, 175);

    // 更新飞机的位置
    //this.airplane.mesh.position.x = targetX;

    // 在每帧通过添加剩余距离的一小部分的值移动飞机
    this.airplane.mesh.position.y += (targetY - this.airplane.mesh.position.y) * 0.1;
    this.airplane.mesh.position.x += (targetX - this.airplane.mesh.position.x) * 0.05;

    // 剩余的距离按比例转动飞机
    this.airplane.mesh.rotation.z = (targetY - this.airplane.mesh.position.y) * 0.0128;
    this.airplane.mesh.rotation.x = (this.airplane.mesh.position.y - targetY) * 0.0064;

    this.airplane.propeller.rotation.x += 0.3;
    this.airplane.pilot.updateHairs();
  }

代码主体部分：

// 引入three
import * as THREE from 'libs/three.js'

// 一些全局变量
var Colors = { ... }
var WIDTH = window.innerWidth;
var HEIGHT = window.innerHeight;

var Sea = function () { ... }
Sea.prototype.moveWaves = function () { ... }
var Cloud = function () { ... }
var Sky = function () { ... }
var AirPlane = function () { ... }
var Pilot = function () { ... }
Pilot.prototype.updateHairs = function () { ... }
var UI = function () { ... }
UI.prototype.add = function (obj) { ... }
UI.prototype.render = function (renderer) { ... }
var Controller = function () { ... }
/**
 * 游戏主函数
 */
export default class Main {
  constructor() {
    // 创建场景，相机和渲染器
    this.createScene();
    // 添加光源
    this.createLights();
    this.start()
  }
  createScene() { ... }
  createLights() { ... }
  createPlane() { ... }
  createSea() { ... }
  createSky() { ... }
  
  createUI() { ... }
  updatePlane() { ... }
  touchEvent() { ... }
  checkIsFingerOnController(x, y) { ... }
  updatePosition() { ... }
  normalize(v, vmin, vmax, tmin, tmax) { ... }

  start() {
    // 添加对象 
    this.createPlane();
    this.createSea();
    this.createSky();
    
    this.createUI();
    
    this.mousePos = { x: 0, y: 0 };
    // 初始化事件监听
    this.touchEvent();

    window.requestAnimationFrame(this.loop.bind(this), canvas);
  }
  update() {
    // 转动大海和云
    this.sea.mesh.rotation.z += .005;
    this.sky.rotation.z += .01;

    // 更新每帧的飞机
    this.updatePlane();

    // 更新每帧的海浪
    this.sea.moveWaves();

    // 更新每帧的鼠标位置
    this.updatePosition();
  }
  loop() {
    this.update()
    this.renderer.render(this.scene, this.camera);
    window.requestAnimationFrame(this.loop.bind(this), canvas);
  }
}

C++后台开发知识总结（四）操作系统/Linux 内核

2019-11-08T08:23:39.000Z

中断

为什么需要中断：提高CPU运行效率
中断是指CPU对系统发生的某个事件做出的一种反应，CPU暂停正在执行的程序，保存现场后自动去执行相应的处理程序，处理完该事件后再返回中断处继续执行原来的程序。

中断一般三类：
1.由CPU外部引起的，如I/O中断、时钟中断
2.来自CPU内部事件或程序执行中引起的中断，例如程序非法操作，地址越界、浮点溢出
3.在程序中使用了系统调用引起的。

中断处理机制
为保证系统实时性，中断服务程序必须足够简短，但实际应用中某些时候发生中断时必须处理大量的事物，这时候如果都在中断服务程序中完成，则会严重降低中断的实时性，基于这个原因，linux系统提出了一个概念：把中断服务程序分为两部分-顶半部-底半部。

顶半部
中断处理程序，功能是”登记中断”，当一个中断发生时，它进行相应地硬件读写后就把中断例程的下半部挂到该设备的下半部执行队列中去。
特点：响应速度快，不可中断

request_irq用于实现中断的注册功能:
int request_irq(unsigned int irq, void (*handler)(int, void*, struct pt_regs *), unsigned long flags, const char *devname, void *dev_id)
返回0表示成功,或者返回一个错误码
功能：向内核注册一个中断服务函数，发生中断号为irq的中断的时候，会执行handle指针函数。
中断注册(参数)
1）unsigned int irq 中断号。
2）void (*handler)(int,void *,struct pt_regs *) 中断处理函数。
3）unsigned long flags 与中断管理有关的各种选项，如快速中断，共享中断
IRQF_DISABLED(SA_INTERRUPT) 如果设置该位,表示是一个“快速”中断处理程序，保证中断处理的原子性(不被打断)，在服务该中断时,不会被其他类型的中断打断
IRQF_SHARED(SA_SHIRQ) 表明中断可以在设备间共享。共享中断就是将不同的设备挂到同一个中断信号线上。Linux对共享的支持主要是为PCI设备（如声卡、网卡、MODEM等）服务。
4）const char * devname 设备名
5）void *dev_id 共享中断时使用。
void free_irq(unsigned int irq, void *dev_id) 释放中断

底半部
中断处理的大部分工作都在底半部，它几乎做了中断处理程序的所有事情。
特点：处理与中断有相关性但是可以延后执行的任务，可中断，而且可以被新的中断打断
底半部机制主要有：tasklet、工作队列和软中断
软中断：
软中断作为下半部机制的代表，是随着SMP（share memory processor）的出现应运而生的，也是tasklet实现的基础。它的出现就是因为要满足上面所提出的上半部和下半部的区别，使得对时间不敏感的任务延后执行，产生后并不是马上可以执行，必须要等待内核的调度才能执行。而且可以在多个CPU上并行执行，使得总的系统效率可以更高。
tasklet：
由于软中断允许多个CPU同时操作，这就导致设计上的复杂度变高，如果某种应用并不需要在多个CPU上并行执行，那么软中断其实是没有必要的。因此诞生了弥补以上两个要求的tasklet。它具有以下特性：
a）一种特定类型的tasklet只能运行在一个CPU上，不能并行，只能串行执行。
b）多个不同类型的tasklet可以并行在多个CPU上。
c）软中断是静态分配的，在内核编译好之后，就不能改变。但tasklet就灵活许多，可以在运行时改变（比如添加模块时）。
如果不需要软中断的并行特性，tasklet就是最好的选择。
工作队列：
1、由内核线程去执行，换句话说总在进程上下文执行。
2、可以睡眠，阻塞。

信号

信号：对于 Linux来说，实际信号是软中断，用来通知进程发生了异步事件。一个进程收到一个信号类似与处理器收到一个中断请求。信号为 Linux 提供了一种处理异步事件的方法。比如，终端用户输入了 ctrl+c（会产生SIGINT信号，对该信号的默认反应就是进程终止）来中断程序，会通过信号机制停止一个程序。

信号的名字和编号：
每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO ”、“SIGCHLD”等等。
信号定义在signal.h头文件中，信号名都定义为正整数。

具体的信号名称可以使用kill -l来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0又特殊的应用。

信号的处理有三种方法，分别是：忽略、捕捉和默认动作
忽略信号，大多数信号可以使用这个方式来处理，但是有两种信号不能被忽略（分别是 SIGKILL和SIGSTOP）
捕捉信号：当该信号产生时，由内核来调用用户自定义的函数，以此来实现某种信号的处理。
系统默认动作，对于每个信号来说，系统都对应由默认的处理动作，当发生了该信号，系统会自动执行。不过，对系统来说，大部分的处理方式都比较粗暴，就是直接杀死该进程。
信号的使用：
常用的 kill 命令就是一个发送信号的工具，kill 9 PID来杀死进程。比如，我在后台运行了一个 top 工具，通过 ps 命令可以查看他的 PID（进程标志号），通过 kill 9 来发送了一个终止进程的信号来结束了 top 进程。

如果查看信号编号和名称，可以发现9对应的是 9) SIGKILL，正是杀死该进程的信号。而以下的执行过程实际也就是执行了9号信号的默认动作——杀死进程。

信号的种类
可靠信号与不可靠信号
不可靠信号：Linux的信号继承自早期的Unix信号，信号值小于SIGRTMIN（34）的信号都是不可靠信号。这就是”不可靠信号”的来源。它的主要问题是信号可能丢失。1-31 都是不可靠的。
可靠信号：34-64重新设计的一套信号集合，不会出现信号丢失，支持排队
实时信号与非实时信号
实时信号：就是可靠信号；非实时信号：不可靠信号

SIGCHLD信号：在一个进程终止或者停止时，将SIGCHLD信号发送给其父进程，按系统默认将忽略此信号，如果父进程希望被告知其子系统的这种状态，则应捕捉此信号。
子进程退出时向父进程发送SIGCHILD信号，父进程处理SIGCHILD信号。在信号处理函数中调用wait进行处理僵尸进程。
SIGCLD信号：
对于SIGCLD的早期处理方式如下:如果进程特地设置该信号的配置为SIG_IGN,则子进程状态信息会被丢弃，将不产生僵死进程。

进程与线程

进程是系统进行资源调度和分配的的基本单位，实现了操作系统的并发；
线程是CPU调度和分派的基本单位，用于保证程序的实时性，实现进程内部的并发；
线程是操作系统可识别的最小执行和调度单位。每个线程都独自占用一个虚拟处理器：独自的寄存器组，指令计数器和处理器状态。每个线程完成不同的任务，但是共享同一地址空间（也就是同样的动态内存，映射文件，目标代码等等），打开的文件队列和其他内核资源。

进程和线程的区别：
1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程依赖于进程而存在。
2、进程在执行过程中拥有独立的内存单元，而多个线程共享进程的内存。（资源分配给进程，同一进程的所有线程共享该进程的所有资源。同一进程中的多个线程共享代码段（代码和常量），数据段（全局变量和静态变量），扩展段（堆存储）。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量。）
3、进程是资源分配的最小单位，线程是CPU调度的最小单位。
4、进程创建/撤消或切换的开销大于线程。由于在创建或撤消进程时，系统都要为之分配或回收资源，如内存空间、I／o设备等。因此，操作系统所付出的开销将显著地大于在创建或撤消线程时的开销。类似地，在进行进程切换时，涉及到整个当前进程CPU环境的保存以及新被调度运行的进程的CPU环境的设置。而线程切换只须保存和设置少量寄存器的内容，并不涉及存储器管理方面的操作。
5、通信：由于同一进程中的多个线程具有相同的地址空间，致使它们之间的同步和通信的实现，也变得比较容易。进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。
6、进程编程调试简单可靠性高，但是创建销毁开销大；线程正相反，开销小，切换速度快，但是编程调试相对复杂。
7、一个进程崩溃，不会对其他进程产生影响；而一个线程崩溃，会让同一进程内的其他线程也死掉。
8、进程适应于多核、多机分布；线程适用于多核。
游戏服务器应该为每个用户开辟一个进程。因为同一进程间的线程会相互影响，一个线程死掉会影响其他线程，从而导致进程崩溃。因此为了保证不同用户之间不会相互影响，应该为每个用户开辟一个进程

多线程和多进程的不同
进程是资源分配的最小单位，而线程时CPU调度的最小单位。多线程之间共享同一个进程的地址空间，线程间通信简单，同步复杂，线程创建、销毁和切换简单，速度快，占用内存少，适用于多核分布式系统，但是线程间会相互影响，一个线程意外终止会导致同一个进程的其他线程也终止，程序可靠性弱。而多进程间拥有各自独立的运行地址空间，进程间不会相互影响，程序可靠性强，但是进程创建、销毁和切换复杂，速度慢，占用内存多，进程间通信复杂，但是同步简单，适用于多核、多机分布。
多进程和多线程的使用场景：
多进程，适用于CPU密集型，多线程，适用于I/O密集型的工作场景。多进程适用于多机分布式场景中，易于多机扩展，多线程适用于单机多核分布式场景。

如何设计server，使得能够接收多个客户端的请求:多线程，线程池，io复用
线程产生的原因：
进程可以使多个程序能并发执行，以提高资源的利用率和系统的吞吐量；但是其具有一些缺点：进程在同一时间只能干一件事，进程在执行的过程中如果阻塞，整个进程就会挂起，即使进程中有些工作不依赖于等待的资源，仍然不会执行。因此，操作系统引入了比进程粒度更小的线程，作为并发执行的基本单位，从而减少程序在并发执行时所付出的时空开销，提高并发性。和进程相比，线程的优势如下：
1、从资源上来讲，线程是一种非常”节俭”的多任务操作方式。在linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种”昂贵”的多任务工作方式。
2、从切换效率上来讲，运行于一个进程中的多个线程，它们之间使用相同的地址空间，而且线程间彼此切换所需时间也远远小于进程间切换所需要的时间。据统计，一个进程的开销大约是一个线程开销的30倍左右。（
3、从通信机制上来讲，线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过进程间通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其他线程所用，这不仅快捷，而且方便。
除以上优点外，多线程程序作为一种多任务、并发的工作方式，还有如下优点：
1、使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
2、改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序才会利于理解和修改。

进程间通信

进程用户空间是相互独立的，一般而言是不能相互访问的。但很多情况下进程间需要互相通信，来完成系统的某项功能。进程通过与内核及其它进程之间的互相通信来协调它们的行为。
进程通信的应用场景：
数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几兆字节之间。
共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
资源共享：多个进程之间共享同样的资源。为了作到这一点，需要内核提供锁和同步机制。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

进程间通信主要包括：管道、消息队列、信号量、信号、共享内存、以及套接字socket。管道( pipe )
主要包括无名管道和命名管道
管道可用于具有亲缘关系的父子进程间的通信，有名管道除了具有管道所具有的功能外，它还允许无亲缘关系进程间的通信
消息队列
是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标记。消息队列克服了信号传递信息少，管道只能承载无格式字节流以及缓冲区大小受限等特点。具有写权限得进程可以按照一定得规则向消息队列中添加新信息；对消息队列有读权限得进程则可以从消息队列中读取信息；
特点：
1)消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
2)消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
3)消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。
信号量( semophore )
是一个计数器，可以用来控制多个进程对共享资源的访问。信号量用于实现进程间的互斥与同步，而不用于存储进程间通信数据。
特点：
1)信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
2)信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。
3)每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。
4)支持信号量组。
信号( sinal )
是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
共享内存( shared memory )
它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等
特点：
1)共享内存是最快的一种IPC，因为进程是直接对内存进行存取
2)因为多个进程可以同时操作，所以需要进行同步
3)信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问
Linux内存共享有多种，如mmap()、Posix共享内存、System V 共享内存。
套接字( socket )
可用于不同主机之间的进程通信。

线程间通信

Posix实现的线程，需使用 -lpthread 库编译 :

1	$ g++ test.cpp -lpthread -o test

1、临界区
通过多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问；
确保在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。假如有多个线程试图同时访问临界区，那么在有一个线程进入后其他任何试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程能够继续抢占，并以此达到用原子方式操作共享资源的目的。
2、互斥量
为协调一起对一个共享资源的单独访问而设计的
对资源加锁能阻塞其他线程的访问

#include 
pthread_mutex_t sum_mutex; //互斥锁
pthread_mutex_init( &sum_mutex, NULL ); //对锁进行初始化
pthread_mutex_lock( &sum_mutex ); //加锁
pthread_mutex_unlock( &sum_mutex ); //释放锁，供其他线程使用
pthread_mutex_destroy( &sum_mutex ); //注销锁

3、信号量
它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目

pthread_mutex_t tasks_mutex; //互斥锁
pthread_cond_t tasks_cond; //条件信号量
pthread_cond_init( &tasks_cond, NULL ); //初始化条件信号量
pthread_cond_signal( &tasks_cond ); //signal:向hello1发送信号
pthread_cond_wait( &tasks_cond, &tasks_mutex ); //wait:等待信号量生效，接收到信号，向hello2发出信号，跳出wait,执行后续
pthread_cond_destroy( &tasks_cond ); //销毁条件变量

4、事件
用来通知线程有一些事件已发生，从而启动后继任务的开始

内核线程：内核线程需要系统内核支持，同时系统内核支持内核线程，内核线程只运行在内核态，不受用户态上下文的拖累，内核线程只能由系统内核管理，像普通进程一样被调度。内核线程的使用是廉价的，唯一使用的资源就是内核栈和上下文切换时保存寄存器的空间。
轻量级进程： LWP， Light-Weight Process也是一种用户线程，运行在用户态，是建立在系统内核上的，由系统内核支持的用户线程。它是内核线程的高度抽象，所以轻量级进程需要系统内核支持，同时系统内核支持内核线程。每个轻量级进程都与一个内核线程关联，轻量级进程与内核线程一对一关联。
用户级线程：完全建立在用户态空间的线程，用户线程的创建、调度、同步和销毁全部在用户态空间中完成，不需要系统内核支持，也不需要系统内核支持内核线程。
Linux使用的线程库采用的是一对一关联，一个用户线程对应一个轻量级进程，一个轻量级进程对应一个内核线程。

协程

协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，在适当的时候再返回来接着执行。
协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。
协程和线程区别
那和多线程比，协程最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。
第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

微内核与宏内核

宏内核：除了最基本的进程、线程管理、内存管理外，将文件系统，驱动，网络协议等等都集成在内核里面，例如linux内核。
优点：效率高。
缺点：稳定性差，开发过程中的bug经常会导致整个系统挂掉。

微内核：内核中只有最基本的调度、内存管理。驱动、文件系统等都是用户态的守护进程去实现的。
优点：稳定，驱动等的错误只会导致相应进程死掉，不会导致整个系统都崩溃
缺点：效率低。典型代表QNX，QNX的文件系统是跑在用户态的进程，称为resmgr的东西，是订阅发布机制，文件系统的错误只会导致这个守护进程挂掉。不过数据吞吐量就比较不乐观了。

用户态和内核态区别

用户态和内核态是操作系统的两种运行级别，两者最大的区别就是特权级不同。用户态拥有最低的特权级，内核态拥有较高的特权级。运行在用户态的程序不能直接访问操作系统内核数据结构和程序。内核态和用户态之间的转换方式主要包括：系统调用，异常和中断。

用户态到内核态的转化原理:
1、系统调用
这是用户进程主动要求切换到内核态的一种方式，用户进程通过系统调用申请操作系统提供的服务程序完成工作。
2、异常
当CPU在执行运行在用户态的程序时，发现了某些事件不可知的异常，这是会触发由当前运行进程切换到处理此异常的内核相关程序中，也就到了内核态，比如缺页异常。
3、外围设备的中断
当外围设备完成用户请求的操作之后，会向CPU发出相应的中断信号，这时CPU会暂停执行下一条将要执行的指令，转而去执行中断信号的处理程序，如果先执行的指令是用户态下的程序，那么这个转换的过程自然也就发生了有用户态到内核态的切换。比如硬盘读写操作完成，系统会切换到硬盘读写的中断处理程序中执行后续操作等。
从出发方式看，可以在认为存在前述3种不同的类型，但是从最终实际完成由用户态到内核态的切换操作上来说，涉及的关键步骤是完全一样的，没有任何区别，都相当于执行了一个中断响应的过程，因为系统调用实际上最终是中断机制实现的，而异常和中断处理机制基本上是一样的，用户态切换到内核态的步骤主要包括：
1、从当前进程的描述符中提取其内核栈的ss0及esp0信息。
2、使用ss0和esp0指向的内核栈将当前进程的cs,eip，eflags，ss,esp信息保存起来，这个过程也完成了由用户栈找到内核栈的切换过程，同时保存了被暂停执行的程序的下一条指令
3、将先前由中断向量检索得到的中断处理程序的cs，eip信息装入相应的寄存器，开始执行中断处理程序，这时就转到了内核态的程序执行了。

线程需要保存哪些上下文，SP、PC、EAX这些寄存器是干嘛用的

线程在切换的过程中需要保存当前线程Id、线程状态、堆栈、寄存器状态等信息。
其中寄存器主要包括SP PC EAX等寄存器，其主要功能如下：
SP:堆栈指针，指向当前栈的栈顶地址
PC:程序计数器，存储下一条将要执行的指令
EAX:累加寄存器，用于加法乘法的缺省寄存器

实现多线程

Win:

#include 
#include 

using namespace std;

void thread01() {
  for (int i = 0; i < 5; i++) cout << "Thread 01 is working ！" << endl;
}
void thread02() {
  for (int i = 0; i < 5; i++) cout << "Thread 02 is working ！" << endl;
}

int main()
{
  thread task01(thread01);
  thread task02(thread02);
  task01.join();
  task02.join();

  for (int i = 0; i < 5; i++)  
cout << "Main thread is working ！" << endl;
  return 0;
}

阻塞主流程:
两个子线程并行执行，join函数会阻塞主流程，所以子线程执行完成后才继续执行主线程。

从主流程中分离:
可以使用detach将子线程从主流程中分离，独立运行，不会阻塞主线程：

thread task01(thread01);
thread task02(thread02);
task01.detach();
task02.detach();

带参数线程：

1
2
3

void thread01(int n) {
  for (int i = 0; i < n; i++) cout << "Thread 01 is working ！" << endl;
}

1	thread task01(thread01,5);

多线程数据竞争:
使用线程互斥对象mutex保持数据同步。mutex类的使用需要包含头文件mutex。

#include 
mutex mu;  //线程互斥对象

void thread01() {
  while (totalNum > 0){
    mu.lock(); //同步数据锁
    cout << totalNum << endl;
    totalNum--;
    mu.unlock();  //解除锁定
  }
}
void thread02() {
  while (totalNum > 0){
    mu.lock();
    cout << totalNum << endl;
    totalNum--;
    mu.unlock();
  }
}

Linux:

#include 
#include 
using namespace std;
#define NUM_THREADS 5
// 线程的运行函数,函数返回的是函数指针，便于后面作为参数  
void* say_hello(void* args)
{
    cout << "Hello Runoob！" << endl;
}
int main()
{
    // 定义线程的 id 变量，多个变量使用数组
    pthread_t tids[NUM_THREADS];
    for(int i = 0; i < NUM_THREADS; ++i)
    {
        //参数依次是：创建的线程id，线程参数，调用的函数，传入的函数参数
        int ret = pthread_create(&tids[i], NULL, say_hello, NULL);
        if (ret != 0)
        {
           cout << "pthread_create error: error_code=" << ret << endl;
        }
    }
    pthread_exit(NULL);
}

使用 -lpthread 库编译 :

1	$ g++ test.cpp -lpthread -o test.o

传递参数：

void *PrintHello(void *threadid)
{  
   // 对传入的参数进行强制类型转换，由无类型指针变为整形数指针，然后再读取
   int tid = *((int*)threadid);
   cout << "Hello Runoob! 线程 ID, " << tid << endl;
   pthread_exit(NULL);
}

1	rc = pthread_create(&threads[i], NULL,PrintHello, (void *)&(indexes[i]));

通过结构传递多个参数

#include 
#include 
#include 
using namespace std;
#define NUM_THREADS     5
struct thread_data{
   int  thread_id;
   char *message;
};
void *PrintHello(void *threadarg)
{
   struct thread_data *my_data;
   my_data = (struct thread_data *) threadarg;
   cout << "Thread ID : " << my_data->thread_id ;
   cout << " Message : " << my_data->message << endl;
   pthread_exit(NULL);
}
int main ()
{
   pthread_t threads[NUM_THREADS];
   struct thread_data td[NUM_THREADS];
   int rc;
   int i;
   for( i=0; i < NUM_THREADS; i++ ){
      cout <<"main() : creating thread, " << i << endl;
      td[i].thread_id = i;
      td[i].message = "This is message";
      rc = pthread_create(&threads[i], NULL, PrintHello, (void *)&td[i]); //传入到参数必须强转为void*类型，即无类型指针
      if (rc){
         cout << "Error:unable to create thread," << rc << endl;
         exit(-1);
      }
   }
   pthread_exit(NULL);
}

#include 
#include 
#include 
#include 
using namespace std;
#define NUM_THREADS     5
void *wait(void *t)
{
   int i;
   long tid;
   tid = (long)t;
   sleep(1);
   cout << "Sleeping in thread " << endl;
   cout << "Thread with id : " << tid << "  ...exiting " << endl;
   pthread_exit(NULL);
}
int main ()
{
   int rc;
   int i;
   pthread_t threads[NUM_THREADS];
   pthread_attr_t attr;
   void *status;
   // 初始化并设置线程为可连接的（joinable）
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
   for( i=0; i < NUM_THREADS; i++ ){
      cout << "main() : creating thread, " << i << endl;
      rc = pthread_create(&threads[i], NULL, wait, (void *)i );
      if (rc){
         cout << "Error:unable to create thread," << rc << endl;
         exit(-1);
      }
   }
   // 删除属性，并等待其他线程
   pthread_attr_destroy(&attr);
   for( i=0; i < NUM_THREADS; i++ ){
      rc = pthread_join(threads[i], &status);
      if (rc){
         cout << "Error:unable to join," << rc << endl;
         exit(-1);
      }
      cout << "Main: completed thread id :" << i ;
      cout << "  exiting with status :" << status << endl;
   }
   cout << "Main: program exiting." << endl;
   pthread_exit(NULL);
}

并发(concurrency)和并行(parallelism)

并发（concurrency）：指宏观上看起来两个程序在同时运行，比如说在单核cpu上的多任务。但是从微观上看两个程序的指令是交织着运行的，你的指令之间穿插着我的指令，我的指令之间穿插着你的，在单个周期内只运行了一个指令。这种并发并不能提高计算机的性能，只能提高效率。
并行（parallelism）：指严格物理意义上的同时运行，比如多核cpu，两个程序分别运行在两个核上，两者之间互不影响，单个周期内每个程序都运行了自己的指令，也就是运行了两条指令。这样说来并行的确提高了计算机的效率。所以现在的cpu都是往多核方面发展。

系统调用

系统调用提供了用户程序与操作系统之间的接口（即系统调用是用户程序和内核交互的接口）。用户程序只在用户态下运行，有时需要访问系统核心功能，这时通过系统调用接口使用系统调用。危险的指令被包装成系统调用，用户程序只能调用而无权自己运行那些危险的指令。
系统调用举例：
对文件进行写操作，open和write都是系统调用。
创建进程fork，vfork等都是系统调用。

Linux虚拟内存

为了防止不同进程同一时刻在物理内存中运行而对物理内存的争夺和践踏，采用了虚拟内存。
1 每个进程有独立的虚拟地址空间，进程访问的虚拟地址并不是真正的物理地址
2 虚拟地址可通过每个进程上页表与物理地址进行映射，获得真正物理地址
3 如果虚拟地址对应物理地址不在物理内存中，则产生缺页中断，真正分配物理地址，同时更新进程的页表；如果此时物理内存已耗尽，则根据内存替换算法淘汰部分页面至物理磁盘中。

虚拟内存技术使得不同进程在运行过程中，它所看到的是自己独自占有了当前系统的4G内存。所有进程共享同一物理内存，每个进程只把自己目前需要的虚拟内存空间映射并存储到物理内存上。事实上，在每个进程创建加载时，内核只是为进程“创建”了虚拟内存的布局，具体就是初始化进程控制表中内存相关的链表，实际上并不立即就把虚拟内存对应位置的程序数据和代码（比如.text .data段）拷贝到物理内存中，只是建立好虚拟内存和磁盘文件之间的映射就好（叫做存储器映射），等到运行到对应的程序时，才会通过缺页异常，来拷贝数据。还有进程运行过程中，要动态分配内存，比如malloc时，也只是分配了虚拟内存，即为这块虚拟内存对应的页表项做相应设置，当进程真正访问到此数据时，才引发缺页异常。

优点：
1.既然每个进程的内存空间都是一致而且固定的，所以链接器在链接可执行文件时，可以设定内存地址，而不用去管这些数据最终实际的内存地址，这是有独立内存空间的好处
2.当不同的进程使用同样的代码时，比如库文件中的代码，物理内存中可以只存储一份这样的代码，不同的进程只需要把自己的虚拟内存映射过去就可以了，节省内存
3.在程序需要分配连续的内存空间的时候，只需要在虚拟内存空间分配连续空间，而不需要实际物理内存的连续空间，可以利用碎片

内存保护：每个进程运行在各自的虚拟内存地址空间，互相不能干扰对方。
虚拟内存的代价：
虚存的管理需要建立很多数据结构，这些数据结构要占用额外的内存
虚拟地址到物理地址的转换，增加了指令的执行时间。
页面的换入换出需要磁盘I/O，这是很耗时的
如果一页中只有一部分数据，会浪费内存。
操作系统中的页表寻址
页式内存管理，内存分成固定长度的一个个页片。操作系统为每一个进程维护了一个从虚拟地址到物理地址的映射关系的数据结构，叫页表，页表的内容就是该进程的虚拟地址到物理地址的一个映射。页表中的每一项都记录了这个页的基地址。通过页表，由逻辑地址的高位部分先找到逻辑地址对应的页基地址，再由页基地址偏移一定长度就得到最后的物理地址，偏移的长度由逻辑地址的低位部分决定。一般情况下，这个过程都可以由硬件完成，所以效率还是比较高的。页式内存管理的优点就是比较灵活，内存管理以较小的页为单位，方便内存换入换出和扩充地址空间。
缺页中断
malloc()和mmap()等内存分配函数，在分配时只是建立了进程虚拟地址空间，并没有分配虚拟内存对应的物理内存。当进程访问这些没有建立映射关系的虚拟内存时，处理器自动触发一个缺页异常。
缺页中断：在请求分页系统中，可以通过查询页表中的状态位来确定所要访问的页面是否存在于内存中。每当所要访问的页面不在内存时，会产生一次缺页中断，此时操作系统会根据页表中的外存地址在外存中找到所缺的一页，将其调入内存。
缺页本身是一种中断，与一般的中断一样，需要经过4个处理步骤：
1、保护CPU现场
2、分析中断原因
3、转入缺页中断处理程序进行处理
4、恢复CPU现场，继续执行
但是缺页中断是由于所要访问的页面不存在于内存时，由硬件所产生的一种特殊的中断，因此，与一般的中断存在区别：
1、在指令执行期间产生和处理缺页中断信号
2、一条指令在执行期间，可能产生多次缺页中断
3、缺页中断返回是，执行产生中断的一条指令，而一般的中断返回是，执行下一条指令。

malloc 的内存都有相应的 free ，就不会出现内存泄露了吗

free 的内存:
1 malloc 使用 mmap 分配的内存 ( 大于 128k) ， free 会调用 unmmap 系统调用马上还给 OS ，实现真正释放。
2 堆内的内存，只有释放堆顶的空间，同时堆顶总连续空闲空间大于 128k 才使用 sbrk(-SIZE) 回收内存，真正归还 OS 。
3 堆内的空闲空间，是不会归还给 OS 的。

狭义上的内存泄露是指 malloc 的内存，没有 free ，导致内存浪费，直到程序结束。而广义上的内存泄露就是进程使用内存量不断增加，或大大超出系统原设计的上限。free 了的堆空闲空间并不会马上归还 OS ，并且堆内的空洞（碎片）更是很难真正释放，除非空洞成为了新的堆顶。
因此，随着系统频繁地 malloc 和 free ，尤其对于小块内存，堆内将产生越来越多不可用的碎片，导致“内存泄露”。而这种“泄露”现象使用 valgrind 是无法检测出来的。
因此，当我们写程序时，不能完全依赖 glibc 的 malloc 和 free 的实现。更好方式是建立属于进程的内存池，即一次分配 (malloc) 大块内存，小内存从内存池中获得，当进程结束或该块内存不可用时，一次释放 (free) ，可大大减少碎片的产生。

操作系统中的结构体对齐，字节对齐

1、原因：
1）平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2）性能原因：数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
2、规则
1）数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。
2）结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。
3）结构体作为成员：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储。

// 字节对齐
struct SByte1   
{   
    double d;    // 长度8，偏移量为0；存放位置区间[0,7]
    char j;      // 长度1，偏移量为8；存放位置区间[8]
    int a;       // 长度4，偏移量12；存放位置区间[12，15] 
};    
sizeof(SByte1);  // = 16   
  
struct SByte2   
{         
    char j;      // 长度1，偏移量为0；存放位置区间[0,1]
    double d;    // 长度8，偏移量8；存放位置区间[8,15]  
    int a;       // 长度4，偏移量16；存放位置区间[16,19]
};    
sizeof(SByte2);  // = 24，为了凑成8的倍数，填充20~23  

//可以通过#pragma pack(n)来设定变量以n字节对齐方式，n=1,2,4,8,16
#pragma pack(push) //保存对齐状态   
#pragma pack(4)    //设定为4字节对齐   
class CByte   
{   
char c;       //长度1 < 4 按1对齐；偏移量为0；存放位置区间[0,1]
double d;     //长度8 > 4 按4对齐；偏移量为4；存放位置区间[4,11] 
int i;        //长度4 = 4 按4对齐；偏移量为12；存放位置区间[12,15]
};   
#pragma pack(pop)  //恢复对齐状态   
sizeof(CByte); // = 16  

#pragma pack(2)
struct AA {
int a; //长度4 > 2 按2对齐；偏移量为0；存放位置区间[0,3]
char b; //长度1 < 2 按1对齐；偏移量为4；存放位置区间[4]
short c; //长度2 = 2 按2对齐；偏移量要提升到2的倍数6；存放位置区间[6,7]
char d; //长度1 < 2 按1对齐；偏移量为7；存放位置区间[8]；共九个字节
};
#pragma pack()

软链接和硬链接区别

为了解决文件共享问题，Linux引入了软链接和硬链接。除了为Linux解决文件共享使用，还带来了隐藏文件路径、增加权限安全及节省存储等好处。
硬链接：若1个inode号对应多个文件名
软连接：若文件用户数据块中存放的内容是另一个文件的路径名指向
1，软链接可以理解成快捷方式。它和windows下的快捷方式的作用是一样的。
2，硬链接等于cp -p 加同步更新。
对文件jys建立软链接和硬链接：

软链接：ln -s 源文件目标文件
硬链接：ln 源文件目标文件
区别:
软链接文件的大小和创建时间和源文件不同。硬链接文件和源文件的大小和创建时间一样。
删除源文件多软链接和硬链接的影响：查看软链接文件，查看的文件不存在。但是删除源文件，硬链接文件还可以查看。
i节点是文件和目录的唯一标识，删除了jys,只是删除了从920586到jys的映射关系，不影响它和jys.hard的映射关系。此图也解释了硬链接的同步更新，对源文件修改，操作系统只认i节点，于是操作系统就将修改内容写进所有i节点相同名字不同的文件。

什么是大端小端以及如何判断大端小端

小端就是低位字节放在内存的低地址端, 大端就是低位字节放在内存的高地址端

int JudgeSystem(void)
{
int a = 1;
char * p = (char *)&a;
 
//如果是小端则返回1，如果是大端则返回0
return *p;
}

或者根据联合体来判断该系统是大端还是小端。因为联合体变量总是从低地址存储。

Linux 常用命令

ls命令
ls –l # 以详情模式(long listing fashion)列出文件夹的内容。
ls –a # 列出文件夹里的所有内容，包括以”.”开头的隐藏文件。
mkdir命令
“mkdir”(Make directory)命令在命名路径下创建新的目录。然而如果目录已经存在了，那么它就会返回一个错误信息”不能创建文件夹，文件夹已经存在了”(“cannot create folder, folder already exists”)
grep命令
通常用于对一些命令的输出进行筛选加工
grep [-acinv] [–color=auto] ‘查找字符串’ filename
ls -l | grep -i file # 把ls -l的输出中包含字母file（不区分大小写）的内容输出
cp命令
cp -a file1 file2 #连同文件的所有特性把文件file1复制成文件file2
cp file1 file2 file3 dir #把文件file1、file2、file3复制到目录dir中
mv命令
mv file1 file2 file3 dir # 把文件file1、file2、file3移动到目录dir中
mv file1 file2 # 把文件file1重命名为file2
rm命令
rm -i file # 删除文件file，在删除之前会询问是否进行该操作
rm -fr dir # 强制删除目录dir中的所有文件
ps命令
ps aux # 查看系统所有的进程数据
vim命令
用于文本编辑
输入 i ，退出命令模式，进入INSERT模式
开始修改内容……
按 esc 键，退出INSERT模式，进入命令模式
再输入 :wq，保存文件，退出vi编辑器
time命令
$ time date
Sun Mar 26 22:45:34 GMT-8 2006 # 命令”date”的执行结果
real 0m0.136s # 实际时间
user 0m0.010s # 用户CPU时间
sys 0m0.070s # 系统CPU时间
touch 命令
“touch”命令代表了将文件的访问和修改时间更新为当前时间。touch命令只会在文件不存在的时候才会创建它。如果文件已经存在了，它会更新时间戳，但是并不会改变文件的内容。
chmod 命令
chmod 777 abc.sh # 为拥有者，用户所在组和其它用户提供读，写，执行权限。
tar命令
tar -zxvf abc.tar.gz # (记住’z’代表了.tar.gz)
tar -jxvf abc.tar.bz2 # (记住’j’代表了.tar.bz2) 压缩的更好但是也更慢

awk的使用

awk [-F field-separator] ‘commands’ input-file(s)
1、找到当前文件夹下所有的文件和子文件夹,并显示文件大小

$ ls –l | awk ‘{print $5 “\t” $9}’

2、找到当前文件夹下所有的文件和子文件夹，并显示文件大小，并显示排序
> ls -l | awk ‘BEGIN {COUNT = -1; print “BEGIN COUNT”}
{COUNT = COUNT + 1; print COUNT”\t”$5”\t”$9}
END {print “END, COUNT = “COUNT}’

3、找到当前文件夹下所有的子文件夹,并显示排序
> ls -l | awk ‘BEGIN {print “BEGIN COUNT”} /4096/{print NR”\t”$5”\t”$9}
END {print “END”}’

Linux下怎么得到一个文件的100到200行

sed -n ‘100,200p’ inputfile
awk ‘NR>=100&&NR<=200{print}’ inputfile
head -200 inputfile|tail -100

OS缺页置换算法

当访问一个内存中不存在的页，并且内存已满，则需要从内存中调出一个页或将数据送至磁盘对换区，替换一个页，这种现象叫做缺页置换。当前操作系统最常采用的缺页置换算法如下：
先进先出(FIFO)算法：置换最先调入内存的页面，即置换在内存中驻留时间最久的页面。按照进入内存的先后次序排列成队列，从队尾进入，从队首删除。
最近最少使用（LRU）算法: 置换最近一段时间以来最长时间未访问过的页面。根据程序局部性原理，刚被访问的页面，可能马上又要被访问；而较长时间内没有被访问的页面，可能最近不会被访问。
当前最常采用的就是LRU算法。

虚拟内存置换的方式

比较常见的内存替换算法有：FIFO，LRU，LFU，LRU-K，2Q。
1、FIFO（先进先出淘汰算法）
思想：最近刚访问的，将来访问的可能性比较大。
实现：使用一个队列，新加入的页面放入队尾，每次淘汰队首的页面，即最先进入的数据，最先被淘汰。
弊端：无法体现页面冷热信息
2、LFU（最不经常访问淘汰算法）
思想：如果数据过去被访问多次，那么将来被访问的频率也更高。
实现：每个数据块一个引用计数，所有数据块按照引用计数排序，具有相同引用计数的数据块则按照时间排序。每次淘汰队尾数据块。
开销：排序开销。
弊端：缓存颠簸。
3、LRU（最近最少使用替换算法）
思想：如果数据最近被访问过，那么将来被访问的几率也更高。
实现：使用一个栈，新页面或者命中的页面则将该页面移动到栈底，每次替换栈顶的缓存页面。
优点：LRU算法对热点数据命中率是很高的。
缺陷：
1）缓存颠簸，当缓存（1，2，3）满了，之后数据访问（0，3，2，1，0，3，2，1。。。）。
2）缓存污染，突然大量偶发性的数据访问，会让内存中存放大量冷数据。
4、LRU-K（LRU-2、LRU-3）
思想：最久未使用K次淘汰算法。
LRU-K中的K代表最近使用的次数，因此LRU可以认为是LRU-1。LRU-K的主要目的是为了解决LRU算法“缓存污染”的问题，其核心思想是将“最近使用过1次”的判断标准扩展为“最近使用过K次”。
相比LRU，LRU-K需要多维护一个队列，用于记录所有缓存数据被访问的历史。只有当数据的访问次数达到K次的时候，才将数据放入缓存。当需要淘汰数据时，LRU-K会淘汰第K次访问时间距当前时间最大的数据。
实现：
1）数据第一次被访问，加入到访问历史列表；
2）如果数据在访问历史列表里后没有达到K次访问，则按照一定规则（FIFO，LRU）淘汰；
3）当访问历史队列中的数据访问次数达到K次后，将数据索引从历史队列删除，将数据移到缓存队列中，并缓存此数据，缓存队列重新按照时间排序；
4）缓存数据队列中被再次访问后，重新排序；
5）需要淘汰数据时，淘汰缓存队列中排在末尾的数据，即：淘汰“倒数第K次访问离现在最久”的数据。
针对问题：
LRU-K的主要目的是为了解决LRU算法“缓存污染”的问题，其核心思想是将“最近使用过1次”的判断标准扩展为“最近使用过K次”。
5、2Q
类似LRU-2。使用一个FIFO队列和一个LRU队列。
实现
1）新访问的数据插入到FIFO队列；
2）如果数据在FIFO队列中一直没有被再次访问，则最终按照FIFO规则淘汰；
3）如果数据在FIFO队列中被再次访问，则将数据移到LRU队列头部；
4）如果数据在LRU队列再次被访问，则将数据移到LRU队列头部；
5）LRU队列淘汰末尾的数据。
针对问题：LRU的缓存污染
弊端：
当FIFO容量为2时，访问负载是：ABCABCABC会退化为FIFO，用不到LRU。

linux常见的调度算法

调度算法：根据系统的资源分配策略所规定的资源分配算法。调度，当有多个进程(或多个进程发出的请求)要使用这些资源时，因为资源的有限性，必须按照一定的原则选择进程(请求)来占用资源。
1、先来先去服务（队列）
如果早就绪的进程排在就绪队列的前面，迟就绪的进程排在就绪队列的后面，那么先来先服务(FCFS: first come first service)总是把当前处于就绪队列之首的那个进程调度到运行状态。也就说，它只考虑进程进入就绪队列的先后，而不考虑它的下一个CPU周期的长短及其他因素。
有利于长作业以及CPU繁忙的作业，不利于短作业以及I/O繁忙的作业
2、最短优先（优先队列）
对预计执行时间短的作业（进程）优先分派处理机.通常后来的短作业不抢先正在执行的作业.
比FCFS缩短作业的等待时间；长作业的运行得不到保证。
3、轮转法(RoundRobin)
将系统中所有的就绪进程按照FCFS原则，排成一个队列。每次调度时将CPU分派给队首进程，让其执行一个时间片。时间片的长度从几个ms到几百ms。当进程用完分给它的时间片后，调度程序便停止该进程的运行，并把它放入就绪队列的末尾。
让每个进程在就绪队列中的等待时间与享受服务的时间成正比例。
4、多级反馈队列算法
设置多个就绪队列，分别赋予不同的优先级。新进程进入内存后，先投入队列1的末尾，按FCFS算法调度;若按队列1一个时间片未能执行完，则降低投入到队列2的末尾，同样按FCFS算法调度;如此下去，降低到最后的队列，则按”时间片轮转”算法调度直到完成。仅当较高优先级的队列为空，才调度较低优先级的队列中的进程执行。如果进程执行时有新进程进入较高优先级的队列，则抢先执行新进程，并把被抢先的进程投入原队列的末尾。
优点：
为提高系统吞吐量和缩短平均周转时间而照顾短进程。
为获得较好的I/O设备利用率和缩短响应时间而照顾I/O型进程。
不必估计进程的执行时间，动态调节。

linux文件系统

Linux ext2, ext3, ext4 文件系统：
Ext，全称extended file system, extfs，即扩展文件系统，Ext2就代表第二代文件扩展系统，
Linux ext2/ext3文件系统使用索引节点来记录文件信息，作用像windows的文件分配表。索引节点是一个结构，它包含了一个文件的长度、创建及修改时间、权限、所属关系、磁盘中的位置等信息。一个文件系统维护了一个索引节点的数组，每个文件或目录都与索引节点数组中的唯一一个元素对应。
Ext3/Ext4，是Ext2的升级版，只不过为了快速恢复文件系统，减少一致性检查的时间，增加了日志功能，所以Ext2被称为索引式文件系统，而Ext3/Ext4被称为日志式文件系统。

Ext家族是Linux支持度最广、最完整的文件系统，当我们格式化磁盘后，就已经为我们规划好了所有的inode/block/metadate等数据，这样系统可以直接使用，不需要再进行动态的配置，这也是它最优秀的特点，不过这也是它最显著的缺点，磁盘容量越大，格式化越慢，centos7.x已经选用xfs作为默认文件系统，xfs是一种适合大容量磁盘和处理巨型文件的文件系统。

虚拟文件系统（Virtual File System, 简称 VFS），是 Linux 内核中的一个软件层，用于给用户空间的程序提供文件系统接口。正是由于在内核中引入了VFS，跨文件系统的文件操作才能实现，“一切皆是文件” 的口号才能承诺。

目录	描述
/ (root 文件系统)	root 文件系统是文件系统的顶级目录。
/bin	/bin 目录包含用户的可执行文件。
/boot	包含启动 Linux 系统所需要的静态引导程序和内核可执行文件以及配置文件。
/dev	该目录包含每一个连接到系统的硬件设备的设备文件。这些文件不是设备驱动，而是代表计算机上的每一个计算机能够访问的设备。
/etc	包含主机计算机的本地系统配置文件。
/home	主目录存储用户文件，每一个用户都有一个位于 /home 目录中的子目录（作为其主目录）。
/lib	包含启动系统所需要的共享库文件。
/media	一个挂载外部可移动设备的地方，比如主机可能连接了一个 USB 驱动器。
/mnt	一个普通文件系统的临时挂载点（如不可移动的介质），当管理员对一个文件系统进行修复或在其上工作时可以使用。
/opt	可选文件，比如供应商提供的应用程序应该安装在这儿。
/root	这不是 root（/）文件系统。它是 root 用户的主目录。
/sbin	系统二进制文件。这些是用于系统管理的可执行文件。
/tmp	临时目录。被操作系统和许多程序用来存储临时文件。用户也可能临时在这儿存储文件。注意，存储在这儿的文件可能在任何时候在没有通知的情况下被删除。
/usr	该目录里面包含可共享的、只读的文件，包括可执行二进制文件和库、man 文件以及其他类型的文档。
/var	可变数据文件存储在这儿。这些文件包括日志文件、MySQL 和其他数据库的文件、Web 服务器的数据文件、邮件以及更多。

《深入理解linux内核》第12章：虚拟文件系统以及第18章：Ext2和Ext3文件系统以及第16章：访问文件，可以让你深入了解linux文件系统

如何修改文件最大句柄数

linux默认最大文件句柄数是1024个，在linux服务器文件并发量比较大的情况下，系统会报”too many open files”的错误。故在linux服务器高并发调优时，往往需要预先调优Linux参数，修改Linux最大文件句柄数。
有两种方法：

ulimit -n <可以同时打开的文件数>，将当前进程的最大句柄数修改为指定的参数（注：该方法只针对当前进程有效，重新打开一个shell或者重新开启一个进程，参数还是之前的值）
首先用ulimit -a查询Linux相关的参数，如下所示：
1
2
3
max locked memory (kbytes, -l) 64
max memory size (kbytes, -m) unlimited
open files (-n) 1024

其中，open files就是最大文件句柄数，默认是1024个。
修改Linux最大文件句柄数： ulimit -n 2048，将最大句柄数修改为 2048个。

对所有进程都有效的方法，修改Linux系统参数
vi /etc/security/limits.conf 添加

*　　soft　　nofile　　65536
*　　hard　　nofile　　65536
将最大句柄数改为65536
修改以后保存，注销当前用户，重新登录，修改后的参数就生效了

System V、Posix IPC

Posix是“可移植操作系统接口（Portable Operating System Interface ）的首字母简写，但它并不是一个单一的标准，而是IEEE开发的一系列标准，System v是Unix操作系统众多版本的一个分支。将这两个名词放在一起讨论的一般是在Linux的进程间通信中，如在信号量编程中，有Posix信号量和System V信号量。
Posix信号量是基于内存的，即信号量值是放在共享内存中的。而System v信号量测试基于内核的，它放在内核里面，相同点都是它们都可以用于进程或者线程间的同步。
“Posix 信号量”，指的是单个计数信号量；“System v信号量”时，所指的是计数信号量集。

死锁产生的四个必要条件及如何预防

死锁是指两个或两个以上进程在执行过程中，因争夺资源而造成的下相互等待的现象。
死锁发生的四个必要条件：
互斥：一个资源每次只能被一个进程使用。
请求与保持：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不可剥夺: 进程已获得的资源，在末使用完之前，不能强行剥夺，只能在使用后自己释放
循环等待: 若干进程之间形成一种头尾相接的循环等待资源关系。

通过破坏死锁产生的4个必要条件来预防死锁，由于资源互斥是资源使用的固有特性是无法改变的。
破坏”请求与保持条件“：
第一种方法静态分配：每个进程在开始执行时就申请他所需要的全部资源。
第二种是动态分配：每个进程在申请所需要的资源时他本身不占用系统资源。
破坏“不可剥夺”条件：
一个进程不能获得所需要的全部资源时便处于等待状态，等待期间他占有的资源将被隐式的释放重新加入到系统的资源列表中，可以被其他的进程使用。
破坏“循环等待”条件：
采用资源有序分配，将系统中的所有资源顺序编号，将紧缺的，稀少的采用较大的编号，每个进程按编号递增的请求资源，释放则相反

Linux的4种锁机制

互斥锁：mutex，用于保证在任何时刻，都只能有一个线程访问该对象。当获取锁操作失败时，线程会进入睡眠，等待锁释放时被唤醒
读写锁：rwlock，分为读锁和写锁。处于读操作时，可以允许多个线程同时获得读操作。但是同一时刻只能有一个线程可以获得写锁。其它获取写锁失败的线程都会进入睡眠状态，直到写锁释放时被唤醒。注意：写锁会阻塞其它读写锁。当有一个线程获得写锁在写时，读锁也不能被其它线程获取；写者优先于读者（一旦有写者，则后续读者必须等待，唤醒时优先考虑写者）。适用于读取数据的频率远远大于写数据的频率的场合。
自旋锁：spinlock，在任何时刻同样只能有一个线程访问对象。但是当获取锁操作失败时，不会进入睡眠，而是会在原地自旋，直到锁被释放。这样节省了线程从睡眠状态到被唤醒期间的消耗，在加锁时间短暂的环境下会极大的提高效率。但如果加锁时间过长，则会非常浪费CPU资源。
RCU：即read-copy-update，在修改数据时，首先需要读取数据，然后生成一个副本，对副本进行修改。修改完成后，再将老数据update成新的数据。使用RCU时，读者几乎不需要同步开销，既不需要获得锁，也不使用原子指令，不会导致锁竞争，因此就不用考虑死锁问题了。而对于写者的同步开销较大，它需要复制被修改的数据，还必须使用锁机制同步并行其它写者的修改操作。在有大量读操作，少量写操作的情况下效率非常高。
互斥锁和读写锁的区别：
1）读写锁区分读者和写者，而互斥锁不区分
2）互斥锁同一时间只允许一个线程访问该对象，无论读写；读写锁同一时间内只允许一个写者，但是允许多个读者同时读对象。

怎么实现线程池

1.设置一个生产者消费者队列，作为临界资源
2.初始化n个线程，并让其运行起来，加锁去队列取任务运行
3.当任务队列为空的时候，所有线程阻塞
4.当生产者队列来了一个任务后，先对队列加锁，把任务挂在到队列上，然后使用条件变量去通知阻塞中的一个线程

如何实现linux的高并发，线程池的思想

线程池：
线程的开启和回收是要消耗系统性能的，对于大量使用线程的场景，使用线程池来进行管理，实现单个线程的复用，提高并发效率。
线程池里面的线程都是现成的而且能够重复使用，我们不需要临时创建大量线程，然后在任务结束时又销毁大量线程。一个理想的线程池能够合理地动态调节池内线程数量，既不会因为线程过少而导致大量任务堆积，也不会因为线程过多了而增加额外的系统开销。

线程池的处理流程如下：
1、判断线程池里的工作线程（线程池中实际执行任务的线程）是否都在执行任务，如果不是（工作线程空闲或者还有工作线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。
2、线程池判断工作队列（用来存放没有处理的任务，提供一种缓冲机制）是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。
3、判断线程池里的线程是否都处于工作状态（线程的闲与忙的状态是通过互斥量实现的），如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。
因为这里涉及到多个线程同时访问一个队列的问题，所以我们需要互斥锁来保护队列

生产者消费者并发程序

死循环+来连接时新建线程的方法效率有点低，怎么改进？
提前创建好一个线程池，用生产者消费者模型，创建一个任务队列，队列作为临界资源，有了新连接，就挂在到任务队列上，队列为空所有线程睡眠。改进死循环：使用select epoll这样的技术。
生产者消费者并发程序要求能够写得出来
生产者（producer）和消费者（consumer）问题是并发处理中最常见的一类问题，是一个多线程同步问题的经典案例。
有一个或者多个生产者产生某种类型的数据，并放置在固定大小的缓冲区中，一个消费者从缓冲区中取数据，每次取一项。任何时候，只有一个生产者或者消费者可以访问缓冲区；同时，消费者只能在缓冲区不为空的时候从缓冲区中读数据，生产者只能在缓冲区不为满的时候向缓冲区写入数据。
第一是缓冲区的互斥访问问题，任意时刻最多只能有一个线程访问缓冲区，Linux下可以使用互斥量pthread_mutex_t mutex对访问缓冲区的临界区代码进行保护。
第二是生产者和消费者对缓冲区访问的同步问题，生产者在缓冲区满时不能向缓冲区中写入数据，同时消费者在缓冲区空时不能读取数据，这里采用两个信号量sem_t room_sem（表示缓冲区有可用空间）和sem_t product_sem（表示缓冲区有可用产品）来对缓冲区进行同步。

#include
#include 
#include // POSIX 操作系统 API 的访问功能
#include //线程
#include //信号量
 
#define PRODUCER_NUM 5 //生产者数目
#define CONSUMER_NUM 5 //消费者数目
#define POOL_SIZE  11  //缓冲池大小
int pool[POOL_SIZE];  //缓冲区
int head=0; //缓冲池读取指针
int rear=0; //缓冲池写入指针
sem_t room_sem;   //同步信号量，表示缓冲区有可用空间
sem_t product_sem;    //同步信号量，表示缓冲区有可用产品
pthread_mutex_t mutex; //互斥量
void producer_fun(void *arg)
{
  while (1)
  {
    sleep(1);
    sem_wait(&room_sem);
    pthread_mutex_lock(&mutex);
    //生产者往缓冲池中写入数据
    pool[rear] = 1;
    rear = (rear + 1) % POOL_SIZE;
    printf("producer %d write to pool\n", (int)arg);
    printf("pool size is %d\n",(rear-head+POOL_SIZE)%POOL_SIZE);
    pthread_mutex_unlock(&mutex);
    sem_post(&product_sem);
  }
}
 
void consumer_fun(void *arg)
{
  while (1)
  {
    int data;
    sleep(10);
    sem_wait(&product_sem);
pthread_mutex_lock(&mutex);
    //消费者从缓冲池读取数据
    data = pool[head];
    head = (head + 1) % POOL_SIZE;
    printf("consumer %d read from pool\n", (int)arg);
    printf("pool size is %d\n",(rear-head+POOL_SIZE)%POOL_SIZE);
    pthread_mutex_unlock(&mutex);
    sem_post(&room_sem);
  }
}
 
int main()
{
  pthread_t producer_id[PRODUCER_NUM];
  pthread_t consumer_id[CONSUMER_NUM];
  pthread_mutex_init(&mutex, NULL); //初始化互斥量
  int ret = sem_init(&room_sem, 0, POOL_SIZE-1);  //初始化信号量room_sem为缓冲池大小
  if (ret != 0)
  {
    printf("sem_init error");
    exit(0);
  }
  ret = sem_init(&product_sem, 0, 0); //初始化信号量product_sem为0，开始时缓冲池中没有数据
  if (ret != 0)
  {
    printf("sem_init error");
    exit(0);
  }
  for (int i = 0; i < PRODUCER_NUM; i++)
  {
    //创建生产者线程
    ret =pthread_create(&producer_id[i], NULL, producer_fun, (void*)i);
    if (ret != 0)
    {
      printf("producer_id error");
      exit(0);
    }
    //创建消费者线程
    ret = pthread_create(&consumer_id[i], NULL, consumer_fun, (void*)i);
    if (ret != 0)
    {
      printf("consumer_id error");
      exit(0);
    }
  }
  for(int i=0;i
  {
    pthread_join(producer_id[i],NULL);
    pthread_join(consumer_id[i],NULL);
  }
 
  exit(0);
}

惊群效应

惊群是指多个进程/线程在等待同一资源时，每当资源可用，所有的进程/线程都来竞争资源的现象。
春天来了, 公园出现了很多麻雀. 而你恰巧有一个玉米粒. 扔出去，立马无数麻雀过来争抢.而最终只有一只麻雀得到了.而那些没有抢到的麻雀很累…….
对于操作系统来说，多个进程/线程在等待同一资源是，也会产生类似的效果，其结果就是每当资源可用，所有的进程/线程都来竞争资源，造成的后果：
1）系统对用户进程/线程频繁的做无效的调度、上下文切换，系统系能大打折扣。
2）为了确保只有一个线程得到资源，用户必须对资源操作进行加锁保护，进一步加大了系统开销。
accept惊群
多线程或多进程调用accept就会出现如下情况，当前多个进程阻塞在accept中，此时有客户端连接时，内核就会通知阻塞在accept的所有进程，这时就会造成惊群现象，也就是所有accept都会返回但是只有一个能拿到有效的文件描述符，其他进程最后都会返回无效描述符。但在linux kernel 版本2.6 以上时，accept惊群的问题已经解决，大致方案就是选一个阻塞在accept的进程返回。
epoll惊群
但是在IO复用中， select/poll/epoll 还是存在这种现象，其原因就是这些阻塞函数造成了以上同样的问题。
如果多个进程/线程阻塞在监听同一个监听socket fd的epoll_wait上，当有一个新的连接到来时，所有的进程都会被唤醒。
避免惊群：Nginx采用互斥锁

fork、vfork、clone的区别

fork,vfork,clone都是linux的系统调用，主要用来linux创建新的子进程或线程（vfork创造出来的是线程）。
fork
fork:创建一个和当前进程映像一样的进程可以通过fork( )系统调用：

1
2
3

#include 
#include 
pid_t fork(void);

由于fork()后会产生一个和父进程完全相同的子进程，fork函数调用一次返回两次，子进程返回值为0，父进程返回子进程的进程ID，返回类型为pid_t。但子进程在此后多会exec系统调用，出于效率考虑，linux中引入了“写时复制技术-Copy-On-Write”。
写时复制 fork子进程完全复制父进程的栈空间，也复制了页表，但没有复制物理页面，所以这时虚拟地址相同，物理地址也相同，但是会把父子共享的页面标记为“只读”，如果父子进程一直对这个页面是同一个页面，直到其中任何一个进程要对共享的页面“写操作”，这时内核会复制一个物理页面给这个进程使用，同时修改页表。而把原来的只读页面标记为“可写”，留给另外一个进程使用。
fork之后内核一般会通过将子进程放在队列的前面，以让子进程先执行，因为很多情况下子进程要马上执行exec，会清空栈、堆，这些和父进程共享的空间，加载新的代码段。exec将新程序代码加载（拷贝）到子进程的内存空间，替换掉原有的与父进程一模一样的代码和数据，让子进程空间运行全新的程序。

#include
#include
#include
int main()
{
    pid_t pid;
    pid = fork();
    if(pid<0)
        printf("error in fork!\n");
    else if(pid == 0)
        printf("I am the child process,ID is %d\n",getpid());
    else 
        printf("I am the parent process,ID is %d\n",getpid());
    return 0;
}

Wait():我们用fork启动一个进程时，子进程就有了自己的生命，并将独立地运行。有时，我们需要知道某个子进程是否已经结束了，我们可以通过wait函数安排父进程在子进程之后结束。wait系统调用会使父进程暂停执行，直到它的一个子进程结束为止。返回的是子进程的PID
Vfork
在实现写时复制之前，Unix的设计者们就一直很关注在fork后立刻执行exec所造成的地址空间的浪费。BSD的开发者们在3.0的BSD系统中引入了vfork( )系统调用。

1
2
3

#include 
#include 
pid_t vfork(void);

vfork创建出的子进程（线程）共享了父进程的变量，内存资源不独立，这一次是指针复制，2者的指针指向了同一个内存，所以子进程修改了变量，父进程的变量同样受到了影响。另外由vfork创造出来的子进程还会导致父进程挂起，除非子进程exit或者exec才会唤起父进程。
fork和vfork的区别：
1.fork( )的子进程拷贝父进程的数据段和代码段；vfork( )的子进程与父进程共享数据段

fork( )的父子进程的执行次序不确定；vfork( )保证子进程先运行，在调用exec或exit之前与父进程数据是共享的，在它调用exec或exit之后父进程才可能被调度运行。
vfork( )保证子进程先运行，在它调用exec或exit之后父进程才可能被调度运行。如果在调用这两个函数之前子进程依赖于父进程的进一步动作，则会导致死锁。
fork( )当需要改变共享数据段中变量的值，则拷贝父进程。

clone
clone函数功能强大，带了众多参数，因此由他创建的进程要比前面2种方法要复杂。clone可以让你有选择性的继承父进程的资源，你可以选择想vfork一样和父进程共享一个虚存空间，从而使创造的是线程，你也可以不和父进程共享，你甚至可以选择创造出来的进程和父进程不再是父子关系，而是兄弟关系。
int clone(int (*fn)(void *), void *child_stack, int flags, void *arg);
fn是函数指针，指向程序的指针，child_stack是为子进程分配系统堆栈空间，flags是标志用来描述你需要从父进程继承那些资源，arg就是传给子进程的参数
CLONE_VFORK 父进程被挂起，直至子进程释放虚拟内存资源
CLONE_VM 子进程与父进程运行于相同的内存空间

int FIBER_STACK = 8192;
void * stack = malloc(FIBER_STACK);//为子进程申请系统堆栈
clone(&do_something, (char *)stack + FIBER_STACK, CLONE_VM|CLONE_VFORK, 0);
int do_something(){}

僵尸进程

1）正常进程
正常情况下，子进程是通过父进程创建的，子进程再创建新的进程。子进程的结束和父进程的运行是一个异步过程，即父进程永远无法预测子进程到底什么时候结束。当一个进程完成它的工作终止之后，它的父进程需要调用wait()或者waitpid()系统调用取得子进程的终止状态。
waitt和waitpid区别和联系 在一个子进程终止前， wait 使其调用者阻塞，而waitpid 有一选择项，可使调用者不阻塞。waitpid并不等待第一个终止的子进程—它有若干个选择项，可以控制它所等待的特定进程。实际上wait函数是waitpid函数的一个特例。
unix提供了一种机制可以保证只要父进程想知道子进程结束时的状态信息，就可以得到：在每个进程退出的时候，内核释放该进程所有的资源，包括打开的文件，占用的内存等。但是仍然为其保留一定的信息，直到父进程通过wait / waitpid来取时才释放。保存信息包括：
1进程号the process ID
2退出状态the termination status of the process
3运行时间the amount of CPU time taken by the process等
2）孤儿进程
一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。
3）僵尸进程
一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵尸进程。
僵尸进程是一个进程必然会经过的过程：这是每个子进程在结束时都要经过的阶段。
如果子进程在exit()之后，父进程没有来得及处理，这时用ps命令就能看到子进程的状态是“Z”。如果父进程能及时处理，可能用ps命令就来不及看到子进程的僵尸状态，但这并不等于子进程不经过僵尸状态。
如果父进程在子进程结束之前退出，则子进程将由init接管。init将会以父进程的身份对僵尸状态的子进程进行处理。
危害：
如果进程不调用wait / waitpid的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵死进程，将因为没有可用的进程号而导致系统不能产生新的进程。
外部消灭：
通过kill发送SIGTERM或者SIGKILL信号消灭产生僵尸进程的进程，它产生的僵死进程就变成了孤儿进程，这些孤儿进程会被init进程接管，init进程会wait()这些孤儿进程，释放它们占用的系统进程表中的资源
内部解决：
1、子进程退出时向父进程发送SIGCHILD信号，父进程处理SIGCHILD信号。在信号处理函数中调用wait进行处理僵尸进程。
2、fork两次，原理是将子进程成为孤儿进程，从而其的父进程变为init进程，通过init进程可以处理僵尸进程。

杀死僵死进程：

1	$ kill -HUP `ps -A -ostat,ppid,pid \|grep -e '^[Zz]' \| awk'{print $2}'`

(1) 检查当前僵尸进程信息：

1	$ ps -ef \| grep defunct \| grep -v grep \| wc -l

1	$ top \| head -2

(2) 获得杀僵尸进程语句

1 2	$ ps -ef \| grep defunct \| grep -v grep \| awk '{print "kill -9 " $2,$3}' //僵尸进程数会大大减少

(3）过一会儿检查当前僵尸进程信息

1	$ ps -ef \| grep defunct \| grep -v grep \| wc -l

(4) 再次获得杀僵尸进程语句

1 2	$ ps -ef \| grep defunct \| grep -v grep \| awk '{print "kill -18 " $3}' //使用信号量18杀其父进程, 僵尸进程应该会全部消失

清除ZOMBIE(僵尸)进程原理:

1	$ kill -18 PPID

PPID是其父进程, 这个信号是告诉父进程, 该子进程已经死亡了, 请收回分配给他的资源.如果还不行则看先看其父进程又无其他子进程, 如果有, 可能需要先kill其他子进程, 也就是兄弟进程.方法是:

1 2	$ kill -15 PID1 PID2 //PID1,PID2是僵尸进程的父进程的其它子进程.: $ kill -15 PPID //再kill父进程

杀死进程：
Kill 234 //杀死pid 为234的进程
kill -TERM 234 //杀死进程和子进程 -15
kill -9 323 //彻底杀死进程
kill -HUP 456 //重跑 (restart) 进程
killall python //通过进程名字结束进程

5种IO模型

1.阻塞IO:
调用者调用了某个函数，等待这个函数返回，期间什么也不做，不停的去检查这个函数有没有返回，必须等这个函数返回才能进行下一步动作
2.非阻塞IO:
非阻塞等待，每隔一段时间就去检测IO事件是否就绪。没有就绪就可以做其他事。
3.信号驱动IO:
linux用套接口进行信号驱动IO，安装一个信号处理函数，进程继续运行并不阻塞，当IO时间就绪，进程收到SIGIO信号。然后处理IO事件。
4.IO复用/多路转接IO:
linux用select/poll函数实现IO复用模型，这两个函数也会使进程阻塞，但是和阻塞IO所不同的是这两个函数可以同时阻塞多个IO操作。而且可以同时对多个读操作、写操作的IO函数进行检测。知道有数据可读或可写时，才真正调用IO操作函数
5.异步IO:
linux中，可以调用aio_read函数告诉内核描述字缓冲区指针和缓冲区的大小、文件偏移及通知的方式，然后立即返回，当内核将数据拷贝到缓冲区后，再通知应用程序。

阻塞，非阻塞，同步，异步

阻塞和非阻塞：调用者在事件没有发生的时候，一直在等待事件发生，不能去处理别的任务这是阻塞。调用者在事件没有发生的时候，可以去处理别的任务这是非阻塞。
同步和异步：调用者必须循环自己去查看事件有没有发生，这种情况是同步。调用者不用自己去查看事件有没有发生，而是等待着注册在事件上的回调函数通知自己，这种情况是异步

异步编程的事件循环

事件循环就是不停循环等待事件的发生，然后将这个事件的所有处理器，以及他们订阅这个事件的时间顺序依次依次执行。当这个事件的所有处理器都被执行完毕之后，事件循环就会开始继续等待下一个事件的触发，不断往复。当同时并发地处理多个请求时，以上的概念也是正确的，可以这样理解：在单个的线程中，事件处理器是一个一个按顺序执行的。即如果某个事件绑定了两个处理器，那么第二个处理器会在第一个处理器执行完毕后，才开始执行。在这个事件的所有处理器都执行完毕之前，事件循环不会去检查是否有新的事件触发。在单个线程中，一切都是有顺序地一个一个地执行的！

page cache

加快从磁盘读取文件的速率。page cache中有一部分磁盘文件的缓存，因为从磁盘中读取文件比较慢，所以读取文件先去page cache中去查找，如果命中，则不需要去磁盘中读取，大大加快读取速度。在 Linux 内核中，文件的每个数据块最多只能对应一个 Page Cache 项，它通过两个数据结构来管理这些 Cache项，一个是radix tree，另一个是双向链表。Radix tree 是一种搜索树，Linux内核利用这个数据结构来通过文件内偏移快速定位Cache 项

select、poll、epoll的区别

IO多路复用：一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。Linux中的 select，poll，epoll 都是IO多路复用的机制。
epoll跟select都能提供多路I/O复用的解决方案。在现在的Linux内核里有都能够支持，其中epoll是Linux所特有，而select则应该是POSIX所规定，一般操作系统均有实现。

select 时间复杂度O(n)
select本质上是通过设置或者检查存放fd标志位的数据结构来进行下一步处理。
缺点：单个进程可监视的fd数量被限制；线性扫描，即采用轮询的方法，效率较低；需要维护一个用来存放大量fd的数据结构，用户空间和内核空间在传递该结构时复制开销大。
它仅仅知道了，有I/O事件发生了，却并不知道是哪那几个流，只能无差别轮询所有流，找出能读出数据，或者写入数据的流，对他们进行操作。

poll 时间复杂度O(n)
poll本质上和select没有区别，它将用户传入的数组拷贝到内核空间，然后查询每个fd对应的设备状态，但是它没有最大连接数的限制，原因是它是基于链表来存储的。
poll还有一个特点是“水平触发”，如果报告了fd后，没有被处理，那么下次poll时会再次报告该fd。

epoll 时间复杂度O(1)
epoll可以理解为event poll，epoll会把哪个流发生了怎样的I/O事件通知我们。
epoll支持水平触发和边缘触发，最大的特点在于边缘触发，它只告诉进程哪些fd刚刚变为就需态，并且只会通知一次。
水平触发——只要满足条件，就触发一个事件(只要有数据没有被获取，内核就不断通知你)；
边缘触发——每当状态变化时，触发一个事件。
epoll的优点：
1、没有最大并发连接的限制，能打开的FD的上限远大于1024（1G的内存上能监听约10万个端口）；
2、效率提升，不是轮询的方式，不会随着FD数目的增加效率下降。只有活跃可用的FD才会调用callback函数；即Epoll最大的优点就在于它只管你“活跃”的连接，而跟连接总数无关，因此在实际的网络环境中，Epoll的效率就会远远高于select和poll。
3、epoll使用mmap减少复制开销。

epoll怎么实现的

Linux epoll机制是通过红黑树和双向链表实现的。3个epoll系统调用:

1
2
3

int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);

Linux epoll机制是通过红黑树和双向链表实现的。首先通过epoll_create()系统调用在内核中创建一个eventpoll类型的句柄，其中包括红黑树根节点和双向链表头节点。然后通过epoll_ctl()系统调用，向epoll对象的红黑树结构中添加、删除、修改感兴趣的事件，返回0标识成功，返回-1表示失败。最后通过epoll_wait()系统调用判断双向链表是否为空，如果为空则阻塞。当文件描述符状态改变，fd上的回调函数被调用，该函数将fd加入到双向链表中，此时epoll_wait函数被唤醒，返回就绪好的事件。

进程状态转换图，动态就绪，静态就绪，动态阻塞，静态阻塞

1、进程的五种基本状态：

创建状态：进程正在被创建
就绪状态：进程被加入到就绪队列中等待CPU调度运行
执行状态：进程正在被运行
等待阻塞状态：进程因为某种原因，比如等待I/O，等待设备，而暂时不能运行。
终止状态：进程运行完毕
2、交换技术
当多个进程竞争内存资源时，会造成内存资源紧张，并且，如果此时没有就绪进程，处理机会空闲，I/0速度比处理机速度慢得多，可能出现全部进程阻塞等待I/O。
针对以上问题，提出了两种解决方法：
1）交换技术：换出一部分进程到外存，腾出内存空间。
2）虚拟存储技术：每个进程只能装入一部分程序和数据。
在交换技术上，将内存暂时不能运行的进程，或者暂时不用的数据和程序，换出到外存，来腾出足够的内存空间，把已经具备运行条件的进程，或进程所需的数据和程序换入到内存。
从而出现了进程的挂起状态：进程被交换到外存，进程状态就成为了挂起状态。
3、活动阻塞，静止阻塞，活动就绪，静止就绪
1）活动阻塞：进程在内存，但是由于某种原因被阻塞了。
2）静止阻塞：进程在外存，同时被某种原因阻塞了。
3）活动就绪：进程在内存，处于就绪状态，只要给CPU和调度就可以直接运行。
4）静止就绪：进程在外存，处于就绪状态，只要调度到内存，给CPU和调度就可以运行。
从而出现了：
活动就绪 —— 静止就绪（内存不够，调到外存）
活动阻塞 —— 静止阻塞（内存不够，调到外存）
执行 —— 静止就绪（时间片用完）

伙伴系统、slab缓存

伙伴系统、slab缓存是linux系统物理内存分配时所用到的技术。Linux内核内存管理的一项重要工作就是如何在频繁申请释放内存的情况下，避免碎片的产生。Linux采用伙伴系统解决外部碎片的问题，采用slab解决内部碎片的问题。
伙伴系统 （分配的大小由一个页框4k到1024个页框4M）
使用场景：内核中很多时候要求分配连续页，为快速检测内存中的连续区域采用的一种技术。
Linux内核引入了伙伴系统，把所有的空闲页框分组为11个块链表，每个块链表分别包含大小为1、2、4、8、16、32、64、128、256、512和1024个连续页框的页框块。最大可以申请1024个连续页框，也即4MB大小的连续空间。
假设要申请一个256个页框的块，先从256个页框的链表中查找空闲块，如果没有，就去512个页框的链表中找，找到了即将页框分为两个256个页框的块，一个分配给应用，另外一个移到256个页框的链表中。如果512个页框的链表中仍没有空闲块，继续向1024个页框的链表查找，如果仍然没有，则返回错误。
页框块在释放时，会主动将两个连续的页框块合并成一个较大的页框块。
slab缓存
适用场景：内核本身经常需要比完整页帧小的多的内存块。
slab的目的在于避免内部碎片。从buddy系统获取的内存至少是一个页，也就是4K，如果仅仅需要8字节的内存，显然巨大的内部碎片无法容忍。
slab从buddy系统申请空间，将较大的连续内存拆分成一系列较小的内存块。申请空间时从slab中获取大小最相近的小块内存，这样可以有效减少内部碎片。在slab最大的块为8K，slab中所有块在物理上也是连续的。
slab分配器是基于对象进行管理的，相同类型的对象归为一类(如进程描述符就是一类)，每当要申请这样一个对象，slab分配器就从一个slab列表中分配一个这样大小的单元出去，而当要释放时，将其重新保存在该列表中，而不是直接返回给伙伴系统，从而避免这些内碎片。

在内核中想要分配一段连续的内存，首先向slab系统申请，如果不满足（超过两个页面，也就是8K），直接向buddy系统申请。如果还不满足（超过4M，也就是1024个页面），将无法获取到连续的物理地址。可以通过vmalloc获取虚拟地址空间连续，但物理地址不连续的更大的内存空间。

linux内核中的Timer 定时器机制

hrtimer采用红黑树进行高精度定时器的管理，而不是时间轮；

高精度时钟定时器不在依赖系统的tick中断，而是基于事件触发。
旧内核的定时器实现依赖于系统定时器硬件定期的tick，基于该tick，内核会扫描timer wheel处理超时事件，会更新jiffies，wall time(墙上时间，现实时间)，process的使用时间等等工作。
新的内核不再会直接支持周期性的tick，新内核定时器框架采用了基于事件触发，而不是以前的周期性触发。新内核实现了hrtimer(high resolution timer)：于事件触发。
hrtimer的工作原理：
通过将高精度时钟硬件的下次中断触发时间设置为红黑树中最早到期的Timer 的时间，时钟到期后从红黑树中得到下一个 Timer 的到期时间，并设置硬件，如此循环反复。

docker

下次单独出篇博客总结。。。。。

C++后台开发知识总结（三）计算机网络

2019-09-26T17:01:31.000Z

OSI与TCP/IP各层的结构与功能，都有哪些协议

OSI七层模型及其包含的协议如下:
物理层：
在物理媒体上传输原始的数据比特流,传输单位为bit，主要包括的协议为：IEE802.3 CLOCK RJ45

数据链路层：
将数据分成一个个数据帧，以数据帧为单位传输。有应有答，遇错重发。传输单位为帧,主要包括的协议为MAC VLAN PPP
网络层：
负责数据包从源到宿的传递和网际互连，传输单位为包,主要包括的协议为IP ARP ICMP
传输层：
提供端到端的可靠报文传递和错误恢复，传输单位为报文,主要包括的协议为TCP UDP

会话层： 建立、管理和终止会话，传输单位为SPDU，主要包括的协议为RPC NFS
表示层： 对数据进行翻译、加密和压缩,传输单位为PPDU，主要包括的协议为JPEG ASII
应用层： 允许访问OSI环境的手段,传输单位为APDU，主要包括的协议为FTP HTTP DNS

TCP/IP 4层模型包括：
网络接口层：MAC VLAN
网络层:IP ARP ICMP
传输层:TCP UDP
应用层:HTTP DNS SMTP

TCP/IP/数据链路层的交互过程

网络层等到数据链层用mac地址作为通信目标，数据包到达网络等准备往数据链层发送的时候，首先会去自己的arp缓存表(存着ip-mac对应关系)去查找改目标ip的mac地址，如果查到了，就讲目标ip的mac地址封装到链路层数据包的包头。如果缓存中没有找到，会发起一个广播：who is ip XXX tell ip XXX,所有收到的广播的机器看这个ip是不是自己的，如果是自己的，则以单拨的形式将自己的mac地址回复给请求的机器

传递到IP层怎么知道报文该给哪个应用程序，它怎么区分UDP报文还是TCP报文

根据端口区分；
看ip头中的协议标识字段，17是udp，6是tcp

输入网址后发生了什么，用到哪些协议

http、dns、tcp、ip、arp地址解析协议、OSPF链路状态路由协议

1、首先，在浏览器地址栏中输入url
2、查看浏览器缓存-系统缓存-路由器缓存，如果缓存中有，会直接在屏幕中显示页面内容。若没有，则跳到第三步操作。
3、在发送http请求前，需要域名解析(DNS解析)解析获取相应的IP地址。
4、浏览器向服务器发起tcp连接，与浏览器建立tcp三次握手。
5、握手成功后，浏览器向服务器发送http请求，请求数据包。
6、服务器处理收到的请求，将数据返回至浏览器
7、浏览器收到HTTP响应
8、读取页面内容，浏览器渲染，解析html源码
9、生成Dom树、解析css样式、js交互
10、客户端和服务器交互
11、ajax查询

TCP三次握手和四次挥手

两个序号和三个标志位：
（1）序号：seq序号，占32位，用来标识从TCP源端向目的端发送的字节流，发起方发送数据时对此进行标记。
（2）确认序号：ack序号，只有ACK标志位为1时，确认序号字段才有效，ack=seq+1
（3）标志位：共6个，即URG、ACK、PSH、RST、SYN、FIN等，具体含义如下：
ACK：确认序号有效； SYN：发起一个新连接； FIN：释放一个连接

客户端–发送带有SYN标志的数据包–一次握手–服务端
服务端–发送带有SYN/ACK标志的数据包–二次握手–客户端
客户端–发送带有带有ACK标志的数据包–三次握手–服务端

客户端-发送一个FIN，用来关闭客户端到服务器的数据传送
服务器-收到这个FIN，它发回一个ACK，确认序号为收到的序号加1 。
服务器-关闭与客户端的连接，发送一个FIN给客户端
客户端-发回ACK报文确认，并将确认序号设置为收到序号加1
为什么要四次挥手？
任何一方都可以在数据传送结束后发出连接释放的通知，待对方确认后进入半关闭状态。当另一方也没有数据再发送的时候，则发出连接释放通知，对方确认后就完全关闭了TCP连接。

TIME_WAIT：作用以及如何避免

1：主机1发送FIN；此时，主机1进入FIN_WAIT_1状态；
2：主机2收到FIN，向主机1回一个ACK报文段；主机1进入FIN_WAIT_2状态；
3：主机2发送FIN，请求关闭连接，同时主机2进入LAST_ACK状态；
4：主机1收到主机2发送的FIN报文段，向主机2发送ACK报文段，然后主机1进入TIME_WAIT状态；主机2收到主机1的ACK报文段以后就关闭连接；此时，主机1等待2MSL后依然没有收到回复，则证明Server端已正常关闭，那好，主机1也可以关闭连接了。
MSL是指数据包在网络中的最大生存时间

为什么要有TIME_WAIT这个状态：
（1）TCP实现必须可靠地终止连接的两个方向(全双工关闭)，主机1必须进入 TIME_WAIT 状态，因为主机1可能面临重发最终ACK的情形。假设最终的ACK丢失，主机2将重发FIN，主机1必须维护TCP状态信息以便可以重发最终的ACK，否则会发送RST，结果主机2认为发生错误。
（2）避免上一个连接延迟到达的数据包被下一个连接错误接收。如果在被推迟的报文未抵达前接收方断开了连接，随后又建立了一个与之前相同IP、Port的连接，而之前被推迟的报文在这时恰好到达，而此时此新连接非彼连接，从而会发生数据错乱。

出现太多TIME_WAIT可能导致的后果：
在高并发短连接的TCP服务器上，当服务器处理完请求后立刻按照主动正常关闭连接。这个场景下，会出现大量socket处于TIMEWAIT状态。如果客户端的并发量持续很高，此时部分客户端就会显示连接不上。高并发可以让服务器在短时间范围内同时占用大量端口。短连接比如，取一个web页面，1秒钟的http短连接处理完业务，在关闭连接之后，这个业务用过的端口会停留在TIMEWAIT状态几分钟，而这几分钟，其他HTTP请求来临的时候是无法占用此端口的。服务器干正经事的时间和端口（资源）被挂着无法被使用的时间的比例是 1：几百，服务器资源严重浪费。

linux 大量的TIME_WAIT解决办法：
通过调整内核参数解决
vi /etc/sysctl.conf
编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30

net.ipv4.tcp_syncookies = 1表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；
net.ipv4.tcp_tw_reuse = 1表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；
net.ipv4.tcp_tw_recycle = 1表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。
net.ipv4.tcp_fin_timeout修改系統默认的TIMEOUT时间

TCP、UDP协议的区别

UDP在传送数据之前不需要先建立连接，远地主机在收到UDP报文后，不需要给出任何确认。虽然UDP不提供可靠交付，但在某些情况下UDP确是一种最有效的工作方式（一般用于即时通信），比如： QQ语音 QQ视频、直播等等
TCP提供面向连接的服务。在传送数据之前必须先建立连接，数据传送结束后要释放连接。TCP不提供广播或多播服务。由于TCP要提供可靠的，面向连接的运输服务（TCP的可靠体现在TCP在传递数据之前，会有三次握手来建立连接，而且在数据传递时，有确认、窗口、重传、拥塞控制机制，在数据传完后，还会断开连接用来节约系统资源），这一难以避免增加了许多开销，如确认，流量控制，计时器以及连接管理等。这不仅使协议数据单元的首部增大很多，还要占用许多处理机资源。TCP一般用于文件传输、发送和接收

TCP怎么保证可靠性

TCP保证可靠性：
（1）序列号、确认应答、超时重传
数据到达接收方，接收方需要发出一个确认应答，表示已经收到该数据段，并且确认序号会说明了它下一次需要接收的数据序列号。如果发送发迟迟未收到确认应答，那么可能是发送的数据丢失，也可能是确认应答丢失，这时发送方在等待一定时间后会进行重传。
（2）窗口控制与高速重发控制/快速重传（重复确认应答）
TCP会利用窗口控制来提高传输速度，意思是在一个窗口大小内，不用一定要等到应答才能发送下一段数据，窗口大小就是无需等待确认而可以继续发送数据的最大值。如果不使用窗口控制，每一个没收到确认应答的数据都要重发。
使用窗口控制，如果数据段1001-2000丢失，后面数据每次传输，确认应答都会不停地发送序号为1001的应答，表示我要接收1001开始的数据，发送端如果收到3次相同应答，就会立刻进行重发；但还有种情况有可能是数据都收到了，但是有的应答丢失了，这种情况不会进行重发，因为发送端知道，如果是数据段丢失，接收端不会放过它的，会疯狂向它提醒……
（3）拥塞控制
如果把窗口定的很大，发送端连续发送大量的数据，可能会造成网络的拥堵（大家都在用网，你在这狂发，吞吐量就那么大，当然会堵），甚至造成网络的瘫痪。所以TCP在为了防止这种情况而进行了拥塞控制。
慢启动：定义拥塞窗口，一开始将该窗口大小设为1，之后每次收到确认应答（经过一个rtt），将拥塞窗口大小2。
*拥塞避免：设置慢启动阈值，一般开始都设为65536。拥塞避免是指当拥塞窗口大小达到这个阈值，拥塞窗口的值不再指数上升，而是加法增加（每次确认应答/每个rtt，拥塞窗口大小+1），以此来避免拥塞。
将报文段的超时重传看做拥塞，则一旦发生超时重传，我们需要先将阈值设为当前窗口大小的一半，并且将窗口大小设为初值1，然后重新进入慢启动过程。
**快速重传：在遇到3次重复确认应答（高速重发控制）时，代表收到了3个报文段，但是这之前的1个段丢失了，便对它进行立即重传。
然后，先将阈值设为当前窗口大小的一半，然后将拥塞窗口大小设为慢启动阈值+3的大小。
这样可以达到：在TCP通信时，网络吞吐量呈现逐渐的上升，并且随着拥堵来降低吞吐量，再进入慢慢上升的过程，网络不会轻易的发生瘫痪。

GET 和 POST 的本质区别

	GET	POST
书签	可收藏为书签	不可收藏为书签
缓存	能被缓存	不能缓存
历史	参数保留在浏览器历史中	参数不会保存在浏览器历史中
对数据长度的限制	GET请求的参数是放在URL里的； URL 的最大长度是 2048 个字符	POST请求参数是放在请求body里的，无限制
对数据类型的限制	只允许 ASCII字符	没有限制。也允许二进制数据
安全性	GET的安全性较差，因为所发送的数据是URL的一部分	POST 比GET 更安全，因为参数不会被保存在浏览器历史或web服务器日志中
可见性	数据在URL中对所有人都是可见的	数据不会显示在 URL 中

本质区别:GET产生一个TCP数据包；POST产生两个TCP数据包。
对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）；而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）。

HTTP状态码

	类别	原因短语
1XX	Informational（信息性状态码）	接收的请求正在处理
2XX	Success （成功状态码）	请求正常处理完毕
3XX	Redirection （重定向状态码）	需要进行附加操作以完成请求
4XX	Client Error （客户端错误状态码）	服务器无法处理请求
5XX	Server Error （服务器错误状态码）	服务器处理请求出错
常见状态代码、状态描述的详细说明如下。
200 OK：客户端请求成功。
206 partial content服务器已经正确处理部分GET请求，实现断点续传或同时分片下载，该请求必须包含Range请求头来指示客户端期望得到的范围
300 multiple choices（可选重定向）:被请求的资源有一系列可供选择的反馈信息，由浏览器/用户自行选择其中一个。
301 moved permanently（永久重定向）：该资源已被永久移动到新位置，将来任何对该资源的访问都要使用本响应返回的若干个URI之一。
302 move temporarily(临时重定向)：请求的资源现在临时从不同的URI中获得，
304 not modified :如果客户端发送一个待条件的GET请求并且该请求以经被允许，而文档内容未被改变，则返回304,该响应不包含包体（即可直接使用缓存）。
403 Forbidden：服务器收到请求，但是拒绝提供服务。
404 not Found：请求资源不存在，举个例子：输入了错误的URL。

HTTP长连接、短连接

在HTTP/1.0中默认使用短连接。也就是说，客户端和服务器每进行一次HTTP操作，就建立一次连接，任务结束就中断连接。当客户端浏览器访问的某个HTML或其他类型的Web页中包含有其他的Web资源（如JavaScript文件、图像文件、CSS文件等），每遇到这样一个Web资源，浏览器就会重新建立一个HTTP会话。
而从HTTP/1.1起，默认使用长连接，用以保持连接特性。使用长连接的HTTP协议，会在响应头加入这行代码：Connection:keep-alive
复制代码在使用长连接的情况下，当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的TCP连接不会关闭，客户端再次访问这个服务器时，会继续使用这一条已经建立的连接。Keep-Alive不会永久保持连接，它有一个保持时间，可以在不同的服务器软件（如Apache）中设定这个时间。实现长连接需要客户端和服务端都支持长连接。

HTTP和HTTPS的区别

HTTPS即加密的HTTP，HTTPS并不是一个新协议，而是HTTP+SSL（TLS）。原本HTTP先和TCP（假定传输层是TCP协议）直接通信，所有传输的内容都是明文，客户端和服务器端都无法验证对方的身份。
而加了SSL后，就变成HTTP先和SSL通信，再由SSL和TCP通信，相当于SSL被嵌在了HTTP和TCP之间，所有传输的内容都经过加密，加密采用对称加密，但对称加密的密钥用服务器方的证书进行了非对称加密。此外客户端可以验证服务器端的身份，如果配置了客户端验证，服务器方也可以验证客户端的身份.

HTTPS协议需要服务端申请证书，浏览器端安装对应的根证书
HTTP协议端口是80，HTTPS协议端口是443

HTTPS优点：
HTTPS传输数据过程中使用密钥进行加密，所以安全性更高
HTTPS协议可以认证用户和服务器，确保数据发送到正确的用户和服务器
HTTPS缺点：
HTTPS握手阶段延时较高：由于在进行HTTP会话之前还需要进行SSL握手，因此HTTPS协议握手阶段延时增加
HTTPS部署成本高：一方面HTTPS协议需要使用证书来验证自身的安全性，所以需要购买CA证书；另一方面由于采用HTTPS协议需要进行加解密的计算，占用CPU资源较多，需要的服务器配置或数目高

数字证书是什么，里面都包含那些内容

数字证书是在一个身份和该身份的持有者所拥有的公/私钥对之间建立了一种联系，由认证中心（CA）或者认证中心的下级认证中心颁发的。
数字证书颁发过程如下：用户产生了自己的密钥对，并将公共密钥及部分个人身份信息传送给一家认证中心。认证中心在核实身份后，将执行一些必要的步骤，以确信请求确实由用户发送而来，然后，认证中心将发给用户一个数字证书，该证书内附了用户和他的密钥等信息，同时还附有对认证中心公共密钥加以确认的数字证书。当用户想证明其公开密钥的合法性时，就可以提供这一数字证书。

各种协议与HTTP协议之间的关系

IP地址作用，以及MAC地址作用

MAC地址是一个硬件地址，用来定义网络设备的位置，主要由数据链路层负责。而IP地址是IP协议提供的一种统一的地址格式，为互联网上的每一个网络和每一台主机分配一个逻辑地址，以此来屏蔽物理地址的差异。

流量控制

流量控制：防止发送方发的太快，耗尽接收方的资源，从而使接收方来不及处理
依据：接收端缓冲区的大小
实现流量控制：
滑动窗口：在确认应答策略中，对每一个发送的数据段，都要给一个ACK确认应答，收到ACK后再发送下一个数据段，这样做有一个比较大的缺点，就是性能比较差，尤其是数据往返的时间长的时候，使用滑动窗口，就可以一次发送多条数据，从而就提高了性能。
（1）接收端将自己可以接收的缓冲区大小放入TCP首部中的“窗口大小”字段，通过ACK来通知发送端
（2）窗口大小指的是不需要接收端的应答，可以一次连续的发送数据
（3）操作系统内核为了维护滑动窗口，需要开辟发送缓冲区，来记录当前还有那些数据没有应答，只有确认应答过的数据，才能从缓冲区删掉
（4）滑动窗口中的数据类型：发送了尚未确认的，没有发送，但是等待发送的。接收端窗口就是等待确认的数据序号组成。

拥塞控制

拥塞控制：防止发送方发的太快，使得网络来不及处理，从而导致网络拥塞
拥塞控制的表现：丢包、延时变长
拥塞控制是防止过多的数据注入网络，使得网络中的路由器或者链路过载。流量控制是点对点的通信量控制，而拥塞控制是全局的网络流量整体性的控制。发送双方都有一个拥塞窗口——cwnd。拥塞窗口的大小取决于网络的拥塞情况，并且是动态变化的，发送方一般让自己的发送窗口不大于拥塞窗口。
1、慢开始
TCP 连接开始，cwnd设置为1，字节未超过阈值ssthresh，接到确认呈指数型增长
2、拥塞避免
超过阈值变为线性增长。一旦发现网络拥塞，就把慢开始门限设为当前值的一半，并且重新设置cwnd为1，重新慢启动。
3、快重传
接收方每次收到一个失序的报文段后就立即发出重复确认，发送方只要连续收到三个重复确认就立即重传（尽早重传未被确认的报文段）。
4、快恢复
当发送方连续收到了三个重复确认（为什么是3个？因为1-2个重复ACK，很有可能是乱序，只有在3个及以上的时候才是有可能丢包了）时，把慢开始门限减半，由于发送方现在认为网络很可能没有发生拥塞，跳过指数增加，直接使拥塞窗口的线性增大。

采用快恢复算法时，慢开始只在建立连接和网络超时才使用。
采用慢开始和拥塞避免算法的时候
1.一旦cwnd>慢开始门限，就采用拥塞避免算法，减慢增长速度
2.一旦出现丢包的情况，就重新进行慢开始，减慢增长速度
采用快恢复和快重传算法的时候
1.一旦cwnd>慢开始门限，就采用拥塞避免算法，减慢增长速度
2.一旦发送方连续收到了三个重复确认，就采用拥塞避免算法，减慢增长速度
流量控制和拥塞控制的区别
相同点：
现象都是丢包；
实现机制都是让发送方发的慢一点，发的少一点
不同点：
（1）丢包位置：流量控制丢包位置是在接收端上、拥塞控制丢包位置是在路由器上
（2）作用的对象：流量控制的对象是接收方，怕发送方发的太快，使得接收方来不及处理
拥塞控制的对象是网络，怕发送发发的太快，造成网络拥塞，使得网络来不及处理

Ddos

Dos拒绝服务攻击攻击原理：DoS攻击就是利用合理的服务请求来占用过多的服务资源，从而使合法用户无法得到服务的响应。dos攻击与ddos攻击的区别就是，它是一对一的攻击，而ddos是分布式的攻击。
最常见的DoS攻击有对计算机网络的带宽攻击和连通性攻击。
带宽攻击： 指以极大的通信量冲击网络，使得所有可用网络资源都被消耗殆尽，最后导致合法的用户请求无法通过。
连通性攻击： 指用大量的连接请求冲击计算机，使得所有可用的操作系统资源都被消耗殆尽，最终计算机无法再处理合法用户的请求。
传统上，攻击者所面临的主要问题是网络带宽，由于较小的网络规模和较慢的网络速度的限制，攻击者无法发出过多的请求。大多数的DoS攻击还是需要相当大的带宽的，而以个人为单位的黑客们很难使用高带宽的资源。为了克服这个缺点，DoS攻击者开发了分布式的攻击。攻击者简单利用工具集合许多的网络带宽来同时对同一个目标发动大量的攻击请求，这就是DDoS攻击
SYN泛洪：
攻击主机C(地址伪装后为C)—–大量SYN包—->被攻击主机
C<——-SYN/ACK包—-被攻击主机
由于C地址不可达，被攻击主机等待超时。攻击主机通过发大量SYN包填满未连接队列，导致正常SYN包被拒绝服务。（防范：给每一个请求连接的IP地址分配一个Cookie）
常见的dos攻击：
死亡之ping：故意产生畸形的测试Ping包，声称自己的尺寸超过64KB上限，使未采取保护措施的网络系统出现内存分配错误，导致TCP/IP协议栈崩溃，最终接收方宕机。
泪滴：某些TCP/IP协议栈在收到含有重叠偏移的伪造分段时将崩溃。
UDP泛洪：伪造与某一主机的Chargen服务之间的一次的UDP连接，回复地址指向开着Echo服务的一台主机，通过将Chargen和Echo服务互指，来回传送毫无用处且占满带宽的垃圾数据
常见的Ddos攻击：
Smurf攻击：用一个伪造的源地址连续ping一个或多个计算机网络，这就导致所有计算机所响应的那个计算机并不是实际发送这个信息包的那个计算机。这个伪造的源地址，实际上就是攻击的目标，它将被极大数量的响应信息量所淹没。

XSS和 CSRF

XSS
跨站脚本攻击，这些可执行的脚本由攻击者提供，最终为用户浏览器加载，不同于大多数攻击，有存储型和反射型。
防御方式:编码，过滤，解码
CSRF
跨站请求伪造（攻击者盗用你的身份，以你的身份发送恶意请求），一次CSRF攻击的步骤：
登录受信任的网站A，并在本地生成cookie
在不登出A的情况下，访问危险网站B
防御的方法：总的思想在客户端页面增加伪随机值
Cookie Hashing 所有的表单都包含一个伪随机值
验证码
不同的表单包含一个不同的伪随机值

socket编程

什么是 socket
socket 的原意是“插座”，在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。
UNIX/Linux 中的 socket
在 UNIX/Linux 系统中，为了统一对各种硬件的操作，简化接口，不同的硬件设备也都被看成一个文件。对这些文件的操作，等同于对磁盘上普通文件的操作。为了表示和区分已经打开的文件，UNIX/Linux 会给每个文件分配一个 ID，这个 ID 就是一个整数，被称为文件描述符（File Descriptor）。

通过 socket() 函数来创建一个网络连接，或者说打开一个网络文件，socket() 的返回值就是文件描述符。有了文件描述符，我们就可以使用普通的文件操作函数来传输数据了，例如：
用 read() 读取从远程计算机传来的数据；
用 write() 向远程计算机写入数据。

socket有哪些类型
流格式套接字（SOCK_STREAM）
SOCK_STREAM 是一种可靠的、双向的通信数据流，数据可以准确无误地到达另一台计算机，如果损坏或丢失，可以重新发送。使用了 TCP 协议（The Transmission Control Protocol，传输控制协议）
应用场景：浏览器所使用的 http 协议就基于面向连接的套接字
数据报格式套接字（SOCK_DGRAM）
计算机只管传输数据，不作数据校验，如果数据在传输中损坏，或者没有到达另一台计算机，是没有办法补救的。也就是说，数据错了就错了，无法重传。因为数据报套接字所做的校验工作少，所以在传输效率方面比流格式套接字要高。使用 UDP 协议（User Datagram Protocol，用户数据报协议）。
应用场景：QQ 视频聊天和语音聊天

常用函数：

1 2	#include #include

1、socket()描述字建立函数

1 2	//int socket(int domain, int type, int protocol); int serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

domain 指明所使用的协议族，通常为AF_INET，表示互联网协议族（TCP/IP协议族）
AF_INET IPv4因特网域，AF_INET6 IPv6因特网域，AF_UNIX Unix域，AF_ROUTE 路由套接字，AF_KEY 密钥套接字，AF_UNSPEC 未指定
type 指定socket的类型
SOCK_STREAM，SOCK_DGRAM，SOCK_RAW protocol
protocol 通常赋值”0“。 0 选择type类型对应的默认协议，IPPROTO_TCP TCP传输协议，IPPROTO_UDP UDP传输协议，IPPROTO_SCTP SCTP传输协议，IPPROTO_TIPC TIPC传输协议

2、bind()函数：IP号端口号与相应描述字赋值函数

//int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
//将套接字和IP、端口绑定
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));  //每个字节都用0填充
serv_addr.sin_family = AF_INET;  //使用IPv4地址
serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
serv_addr.sin_port = htons(1234);  //端口
bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

//ipv4对应的是： 
/*
struct sockaddr{
unisgned short  as_family;    // 协议族
char           sa_data[14];  // IP+端口
       };
*/
//同等替换：
/*
struct sockaddr_in {
    sa_family_t      sin_family;   // 协议族
    in_port_t        sin_port;   // 端口号
    struct  in_addr  sin_addr;   // IP地址结构体
    unsigned char    sin_zero[8];  // 填充   
};
*/
//两个结构是等同的可以先互转换，第一个结构将地址和端口绑定了，第二个结构将两者分开表示*/
//IP地址结构如下：为32位字 
/*
struct in_addr {
    uint32_t       s_addr;     
};
*/

3、listen()函数：监听设置函数

1 2	//int listen(int sockfd, int backlog); listen(serv_sock, 20); //请求队列中允许的最大请求数20

4、accept()函数：用于从已完成连接队列队头返回下一个已完成连接。如果已完成连接队列为空，那么进程被投入睡眠。

//int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
//接收客户端请求
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size = sizeof(clnt_addr);
int clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size);

5、connect()函数:客户机连接主机

1 2	//int connect(int sockfd, const struct sockaddr addr,socklen_t addrlen); connect(sock, (struct sockaddr)&serv_addr, sizeof(serv_addr));

基于TCP的socket：
服务器端程序：
1创建一个socket，用函数socket()
2绑定IP地址、端口等信息到socket上，用函数bind()
3设置允许的最大连接数，用函数listen()
4接收客户端上来的连接，用函数accept()
5收发数据，用函数send()和recv()，或者read()和write()
6关闭网络连接

客户端程序：
1创建一个socket，用函数socket()
2设置要连接的对方的IP地址和端口等属性
3连接服务器，用函数connect()
4收发数据，用函数send()和recv()，或read()和write()
5关闭网络连接

socket 编程1：读取一个字符串并打印出来。

服务器端代码 server.cpp：

#include 
#include 
#include 
#include 
#include 
#include 
#include 

int main(){
    //创建套接字
    int serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    //将套接字和IP、端口绑定
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));  //每个字节都用0填充
    serv_addr.sin_family = AF_INET;  //使用IPv4地址
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
    serv_addr.sin_port = htons(1234);  //端口
    bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

    //进入监听状态，等待用户发起请求
    listen(serv_sock, 20); //请求队列中允许的最大请求数20

    //接收客户端请求
    struct sockaddr_in clnt_addr;
    socklen_t clnt_addr_size = sizeof(clnt_addr);
    int clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size);

    //向客户端发送数据
    char str[] = "http://c.biancheng.net/socket/";
    write(clnt_sock, str, sizeof(str));
   
    //关闭套接字
    close(clnt_sock);
    close(serv_sock);

    return 0;
}

客户端代码 client.cpp：

#include 
#include 
#include 
#include 
#include 
#include 

int main(){
    //创建套接字
    int sock = socket(AF_INET, SOCK_STREAM, 0);

    //向服务器（特定的IP和端口）发起请求
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));  //每个字节都用0填充
    serv_addr.sin_family = AF_INET;  //使用IPv4地址
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
    serv_addr.sin_port = htons(1234);  //端口
    connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
   
    //读取服务器传回的数据
    char buffer[40];
    read(sock, buffer, sizeof(buffer)-1);
   
    printf("Message form server: %s\n", buffer);
   
    //关闭套接字
    close(sock);

    return 0;
}

启动一个终端（Shell），先编译 server.cpp 并运行：
[admin@localhost ~]$ g++ server.cpp -o server
[admin@localhost ~]$ ./server #等待请求的到来
正常情况下，程序运行到 accept() 函数就会被阻塞，等待客户端发起请求。
接下再启动一个终端，编译 client.cpp 并运行：
[admin@localhost ~]$ g++ client.cpp -o client
[admin@localhost ~]$ ./client
Message form server: http://c.biancheng.net/socket/
client 接收到从 server发送过来的字符串就运行结束了，同时，server 完成发送字符串的任务也运行结束了。

socket 编程2：文件传输

Server端代码如下：

#include  // sockaddr_in
#include   // socket
#include  // socket
#include       // printf
#include      // exit
#include      // bzero

#define SERVER_PORT 8000
#define LENGTH_OF_LISTEN_QUEUE 20
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512

int main(void)
{
    // 声明并初始化一个服务器端的socket地址结构
    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    server_addr.sin_port = htons(SERVER_PORT);

    // 创建socket，若成功，返回socket描述符
    int server_socket_fd = socket(PF_INET, SOCK_STREAM, 0);
    if(server_socket_fd < 0)
    {
        perror("Create Socket Failed:");
        exit(1);
    }
    int opt = 1;
    setsockopt(server_socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // 绑定socket和socket地址结构
    if(-1 == (bind(server_socket_fd, (struct sockaddr*)&server_addr, sizeof(server_addr))))
    {
        perror("Server Bind Failed:");
        exit(1);
    }
    
    // socket监听
    if(-1 == (listen(server_socket_fd, LENGTH_OF_LISTEN_QUEUE)))
    {
        perror("Server Listen Failed:");
        exit(1);
    }

    while(1)
    {
        // 定义客户端的socket地址结构
        struct sockaddr_in client_addr;
        socklen_t client_addr_length = sizeof(client_addr);

        // 接受连接请求，返回一个新的socket(描述符)，这个新socket用于同连接的客户端通信
        // accept函数会把连接到的客户端信息写到client_addr中
        int new_server_socket_fd = accept(server_socket_fd, (struct sockaddr*)&client_addr, &client_addr_length);
        if(new_server_socket_fd < 0)
        {
            perror("Server Accept Failed:");
            break;
        }

        // recv函数接收数据到缓冲区buffer中
        char buffer[BUFFER_SIZE];
        bzero(buffer, BUFFER_SIZE);
        if(recv(new_server_socket_fd, buffer, BUFFER_SIZE, 0) < 0)
        {
            perror("Server Recieve Data Failed:");
            break;
        }

        // 然后从buffer(缓冲区)拷贝到file_name中
        char file_name[FILE_NAME_MAX_SIZE+1];
        bzero(file_name, FILE_NAME_MAX_SIZE+1);
        strncpy(file_name, buffer, strlen(buffer)>FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buffer));
        printf("%s\n", file_name);

        // 打开文件并读取文件数据
        FILE *fp = fopen(file_name, "r");
        if(NULL == fp)
        {
            printf("File:%s Not Found\n", file_name);
        }
        else
        {
            bzero(buffer, BUFFER_SIZE);
            int length = 0;
            // 每读取一段数据，便将其发送给客户端，循环直到文件读完为止
            while((length = fread(buffer, sizeof(char), BUFFER_SIZE, fp)) > 0)
            {
                if(send(new_server_socket_fd, buffer, length, 0) < 0)
                {
                    printf("Send File:%s Failed./n", file_name);
                    break;
                }
                bzero(buffer, BUFFER_SIZE);
            }

            // 关闭文件
            fclose(fp);
            printf("File:%s Transfer Successful!\n", file_name);
        }
        // 关闭与客户端的连接
        close(new_server_socket_fd);
    }
    // 关闭监听用的socket
    close(server_socket_fd);
    return 0;
}

客户端代码 client.cpp：

#include   // sockaddr_in
#include    // socket
#include   // socket
#include        // printf
#include       // exit
#include       // bzero
 
#define SERVER_PORT 8000
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512
 
int main()
{
    // 声明并初始化一个客户端的socket地址结构
    struct sockaddr_in client_addr;
    bzero(&client_addr, sizeof(client_addr));
    client_addr.sin_family = AF_INET;
    client_addr.sin_addr.s_addr = htons(INADDR_ANY);
    client_addr.sin_port = htons(0);
 
    // 创建socket，若成功，返回socket描述符
    int client_socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if(client_socket_fd < 0)
    {
        perror("Create Socket Failed:");
        exit(1);
    }
 
    // 绑定客户端的socket和客户端的socket地址结构 非必需
    if(-1 == (bind(client_socket_fd, (struct sockaddr*)&client_addr, sizeof(client_addr))))
    {
        perror("Client Bind Failed:");
        exit(1);
    }
 
    // 声明一个服务器端的socket地址结构，并用服务器那边的IP地址及端口对其进行初始化，用于后面的连接
    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    if(inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr) == 0)
    {
        perror("Server IP Address Error:");
        exit(1);
    }
    server_addr.sin_port = htons(SERVER_PORT);
    socklen_t server_addr_length = sizeof(server_addr);
 
    // 向服务器发起连接，连接成功后client_socket_fd代表了客户端和服务器的一个socket连接
    if(connect(client_socket_fd, (struct sockaddr*)&server_addr, server_addr_length) < 0)
    {
        perror("Can Not Connect To Server IP:");
        exit(0);
    }
 
    // 输入文件名 并放到缓冲区buffer中等待发送
    char file_name[FILE_NAME_MAX_SIZE+1];
    bzero(file_name, FILE_NAME_MAX_SIZE+1);
    printf("Please Input File Name On Server:\t");
    scanf("%s", file_name);
 
    char buffer[BUFFER_SIZE];
    bzero(buffer, BUFFER_SIZE);
    strncpy(buffer, file_name, strlen(file_name)>BUFFER_SIZE?BUFFER_SIZE:strlen(file_name));
    
    // 向服务器发送buffer中的数据
    if(send(client_socket_fd, buffer, BUFFER_SIZE, 0) < 0)
    {
        perror("Send File Name Failed:");
        exit(1);
    }
 
    // 打开文件，准备写入
    FILE *fp = fopen(file_name, "w");
    if(NULL == fp)
    {
        printf("File:\t%s Can Not Open To Write\n", file_name);
        exit(1);
    }
 
    // 从服务器接收数据到buffer中
    // 每接收一段数据，便将其写入文件中，循环直到文件接收完并写完为止
    bzero(buffer, BUFFER_SIZE);
    int length = 0;
    while((length = recv(client_socket_fd, buffer, BUFFER_SIZE, 0)) > 0)
    {
        if(fwrite(buffer, sizeof(char), length, fp) < length)
        {
            printf("File:\t%s Write Failed\n", file_name);
            break;
        }
        bzero(buffer, BUFFER_SIZE);
    }
 
    // 接收成功后，关闭文件，关闭socket
    printf("Receive File:\t%s From Server IP Successful!\n", file_name);
    close(fp);
    close(client_socket_fd);
    return 0;
}

C++后台开发知识总结（二）数据库

2019-09-26T14:36:00.000Z

数据库索引

索引是存储引擎快速找到记录的一种数据结构。
添加索引原则：
在查询中很少使用或者参考的列不应该创建索引。

只有很少数据值的列也不应该增加索引。
定义为text、image和bit数据类型的列不应该增加索引。
当修改性能远远大于检索性能时，不应该创建索引。这是因为，修改性能和检索性能是互相矛盾的。

目前大部分数据库系统及文件系统都采用B-Tree或其变种B+Tree作为索引结构
B-Tree
B-Tree是一种平衡的多路查找(又称排序)树，在文件系统中和数据库系统中有所应用。主要用作文件的索引。其中的B就表示平衡(Balance) 。
定义一条数据记录为一个二元组[key, data]，key为记录的键值，对于不同数据记录，key是互不相同的；data为数据记录除key外的数据。那么B-Tree是满足下列条件的数据结构：1.d>=2，即B-Tree的度；
2.h为B-Tree的高；
3.每个非叶子结点由n-1个key和n个指针组成，其中d<=n<=2d；
4.每个叶子结点至少包含一个key和两个指针，最多包含2d-1个key和2d个指针，叶结点的指针均为NULL；
5.所有叶结点都在同一层，深度等于树高h；
6.key和指针相互间隔，结点两端是指针；
7.一个结点中的key从左至右非递减排列；
8.如果某个指针在结点node最左边且不为null，则其指向结点的所有key小于v(key1)，其中v(key1)为node的第一个key的值。
9.如果某个指针在结点node最右边且不为null，则其指向结点的所有key大于v(keym)，其中v(keym)为node的最后一个key的值。
10.如果某个指针在结点node的左右相邻key分别是keyi和keyi+1且不为null，则其指向结点的所有key小于v(keyi+1)且大于v(keyi)。
一个d=2的B-Tree示意图:

B-Tree是一个非常有效率的索引数据结构。这主要得益于B-Tree的度可以非常大，高度会变的非常小，只需要二分几次就可以找到数据。例如一个度为d的B-Tree，设其索引N个key，则其树高h的上限为logd((N+1)/2))，检索一个key，其查找节点个数的渐进复杂度为O(logdN)。
索引本身也很大，不可能全部存储在内存中，因此索引往往以索引文件的形式存储的磁盘上。这样的话，索引查找过程中就要产生磁盘I/O消耗。索引的结构组织要尽量减少查找过程中磁盘I/O的存取次数。
B+Tree的特性
区别于B-Tree:
每个节点的指针上限为2d而不是2d+1
内节点不存储data，只存储key；叶子节点不存储指针
带有顺序访问指针的B+Tree

数据库添加索引

1.普通索引：
仅加速查询最基本的索引，没有任何限制，是大多数情况下使用到的索引。CREATE INDEX index_name on user_info(name)

#创建表的时候同时创建索引：

create table healerjean (
  id   bigint(20)  NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT  '主键',
  name  VARCHAR(32) NOT NULL COMMENT '姓名',
  email VARCHAR(64) NOT NULL COMMENT  '邮箱',
  message text DEFAULT  NULL COMMENT '个人信息',
  INDEX index_name (name) COMMENT '索引name'
) COMMENT  = '索引测试表';

#在存在的表上创建索引

1	create index index_name on healerjean(name)

#对于创建索引时如果是blob 和 text 类型，必须指定length。

1 2	create index ix_extra on in1(message(200)); alter table employee add index emp_name (name);

2.唯一索引：
与普通索引类型不同的是：加速查询 + 列值唯一（可以有null）CREATE UNIQUE INDEX mail on user_info(name)
3.全文索引：
全文索引（FULLTEXT）仅可以适用于MyISAM引擎的数据表；作用于CHAR、VARCHAR、TEXT数据类型的列。
4.组合索引：
将几个列作为一条索引进行检索，使用最左匹配原则。
create index ind_sales2_companyid_moneys on sales2(company_id,moneys)

想要查看表有几个字段设置了索引, show index from healerjean

MySQL索引实现

MyISAM索引实现
MyISAM引擎使用B+Tree作为索引结构，叶结点的data域存放的是数据记录的地址。

MyISAM中索引检索的算法为首先按照B+Tree搜索算法搜索索引，如果指定的Key存在，则取出其data域的值，然后以data域的值为地址，读取相应数据记录。MyISAM的索引方式也叫做“非聚集”的。
在MyISAM中，主索引和辅助索引（Secondary key）在结构上没有任何区别，只是主索引要求key是唯一的，而辅助索引的key可以重复。

InnoDB索引实现
InnoDB的数据文件本身就是索引文件。MyISAM索引文件和数据文件是分离的，索引文件仅保存数据记录的地址。

叶结点包含了完整的数据记录。这种索引叫做聚集索引。因为InnoDB的数据文件本身要按主键聚集，所以InnoDB要求表必须有主键（MyISAM可以没有），如果没有显式指定，则MySQL系统会自动选择一个可以唯一标识数据记录的列作为主键，如果不存在这种列，则MySQL自动为InnoDB表生成一个隐含字段作为主键，这个字段长度为6个字节，类型为长整形。
InnoDB的辅助索引data域存储相应记录主键的值而不是地址。换句话说，InnoDB的所有辅助索引都引用主键作为data域。

数据库事务：底层如何实现事务

数据库事务(Database Transaction) ，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。
一个数据库事务通常包含了一个序列的对数据库的读/写操作。作用：
1.为数据库操作序列提供了一个从失败中恢复到正常状态的方法，同时提供了数据库即使在异常状态下仍能保持一致性的方法。
2.当多个应用程序在并发访问数据库时，可以在这些应用程序之间提供一个隔离方法，以防止彼此的操作互相干扰。
当事务被提交给了DBMS（数据库管理系统），则DBMS（数据库管理系统）需要确保该事务中的所有操作都成功完成且其结果被永久保存在数据库中，如果事务中有的操作没有成功完成，则事务中的所有操作都需要被回滚，回到事务执行前的状态;同时，该事务对数据库或者其他事务的执行无影响。
一个逻辑工作单元要成为事务，必须满足ACID（原子性、一致性、隔离性和持久性） 属性。
原子性（Atomicity）：
事务作为一个整体被执行，事物的所有操作要不成功，要不失败回滚而回滚可以通过日志来实现，日志记录着事务所执行的修改操作，在回滚时反向执行这些修改操作。
一致性（Consistency）：
数据库在事务执行前后都保持一致性状态，在一致性状态下，所有事务对一个数据的读取结果都是相同的。
隔离性（Isolation）：
多个事务并发执行时，一个事务的执行不应影响其他事务的执行。
持久性（Durability）：
一旦事务提交，则其所做的修改将会永远保存到数据库中。

数据库事务隔离

同一时间，只允许一个事务请求同一数据，不同的事务之间彼此没有任何干扰。比如A正在从一张银行卡中取钱，在A取钱的过程结束前，B不能向这张卡转账。

MySQL 4 种隔离级别

未提交读READ UNCOMMITTED：
一个事务在提交之前，对其他事务是可见的，即事务可以读取未提交的数据。存在“脏读”（读到了脏数据）问题；
提交读READ COMMITTED：
事务在提交之前，对其它事务是不可见的。存在“不可重复读”（两次查询的得到的结果可能不同，即可能在查询的间隙，有事务提交了修改）问题。解决了“脏读”问题。
可重复读REPEATABLE READ：
在同一事务中多次读取的数据是一致的。解决了脏读和不可重复读问题，存在“幻读”（在事务两次查询间隙，有其他事务又插入或删除了新的记录）。— MySQL默认隔离级别。可串行化SERIALIZABLE：
强制事务串行化执行。即一个事物一个事物挨个来执行，可以解决上述所有问题。

mysql的MVCC机制

MVCC是一种多版本并发控制机制，是MySQL的InnoDB存储引擎实现隔离级别的一种具体方式，用于实现提交读和可重复读这两种隔离级别。MVCC是通过保存数据在某个时间点的快照来实现该机制，其在每行记录后面保存两个隐藏的列，分别保存这个行的创建版本号和删除版本号，然后Innodb的MVCC使用到的快照存储在Undo日志中，该日志通过回滚指针把一个数据行所有快照连接起来。

SQL优化

在经常性的检索列上，建立必要索引，以加快搜索速率，避免全表扫描（索引覆盖扫描）；
多次查询同样的数据，可以考虑缓存该组数据；
审视select * form tables, 你需要所有列数据吗？
切分查询（大查询切分成为小查询，避免一次性锁住大量数据）
分解关联查询（单表查询，结果在应用程序中进行关联，可以减少处理过程中的锁争用）
尽量先做单表查询；

inner join和left join

left join(左联接) 返回包括左表中的所有记录和右表中联结字段相等的记录
right join(右联接) 返回包括右表中的所有记录和左表中联结字段相等的记录
inner join(等值连接) 只返回两个表中联结字段相等的行
表A、 B记录如下：
| aID　 | 　aNum | |bID | |
|–|–|-|–|–|
| 1 | a20050111 | | 1| 2006032401|
| 2 | a20050112|| 2|2006032402 |
| 3 | a20050113 || 3|2006032403 |
| 4 | a20050114|| 4| 2006032404|
| 5 | a20050115| |8 | 2006032408|
sql语句如下:

1
2
3

select * from A
left join B 
on A.aID = B.bID

结果如下:
| aID　 | 　aNum | |bID | |
|–|–|-|–|–|
| 1 | a20050111 | | 1| 2006032401|
| 2 | a20050112|| 2|2006032402 |
| 3 | a20050113 || 3|2006032403 |
| 4 | a20050114|| 4| 2006032404|
| 5 | a20050115| |NULL | NULL|

数据库引擎innoDB与MyISAM

数据库引擎是用于存储、处理和保护数据的核心服务。在Mysql数据库中，常用的引擎为innoDB和MyISAM（MySQL5.6版本开始Innodb已经成为Mysql的默认引擎，之前是MyISAM）。

数据库引擎 innoDB与MyIASM区别：
1.InnoDB支持事务，支持外键，MyISAM都不支持;
2.InnoDB是聚集索引，数据文件是和索引绑在一起的，必须要有主键，通过主键索引效率很高。但是辅助索引需要两次查询，先查询到主键，然后再通过主键查询到数据。因此，主键不应该过大，因为主键太大，其他索引也都会很大。
MyISAM是非聚集索引，数据文件是分离的，索引保存的是数据文件的指针。主键索引和辅助索引是独立的;

行数保存： InnoDB不保存表的具体行数，执行select count(*) from table时需要全表扫描。MyISAM用一个变量保存了整个表的行数，执行上述语句时只需要读出该变量即可，速度很快；
Innodb不支持全文索引，MyISAM支持全文索引，查询效率上MyISAM要高于Innodb；

如何选择存储引擎
如果在应用中执行大量select(查询)操作，应该选MyIASM，如果在应用中执行大量的insert（插入）和update（更新）操作，应该选择innoDB
如果要提供提交、回滚、崩溃恢复能力的事物安全（ACID兼容）能力，并要求实现并发控制，InnoDB是一个好的选择

#查看数据库支持的存储引擎
show engines

#查看数据库当前使用的存储引擎,就是默认引擎是什么。
show variables like 'storage_engine'
也可以在MySQL配置文件中查看。
windows - my.ini Linux - my.cnf

#查看数据库表所用的存储引擎
show create table table_name

#创建表指定存储引擎
create table table_name (column_name column_type) engine = engine_name

#修改表的存储引擎
alter table table_name engine=engine_name

#修改默认的存储引擎
在MySQL配置文件中修改下述内容：default-storage-engine=INNODB
MySQL的端口号是多少，如何修改这个端口号
查看端口号:
登录mysql: mysql -u root –p
查看端口号: show global variables like 'port'
mysql的默认端口是3306。（补充：sqlserver默认端口号为：1433；oracle默认端口号为：1521；DB2默认端口号为：5000；PostgreSQL默认端口号为：5432）
修改端口号：编辑/etc/my.cnf文件，早期版本有可能是my.conf文件名，增加端口参数，并且设定端口，注意该端口未被使用，保存退出。重启mysql。

存储过程

存储过程简单来说，就是为以后的使用而保存的一条或多条MySQL语句的集合。
目的：把处理封装，简化复杂的操作；所有开发人员和应用程序都使用同一存储过程，防止错误保证了数据的一致性；简化对变动的管理，只需要更改存储过程的代码。

#创建存储过程

create procedure porcedureName () 
begin 
    select name from user; 
end;

#调用存储过程：

1	call procedureName ();

#删除存储过程

1	DROP PROCEDURE IF EXISTS porcedureName;

#含参数

create procedure getTotalById ( 
    in userId int, 
    out total decimal(8,2) 
) 
BEGIN 
    select SUM(r.price) from order r 
    where r.u_id = userId 
    into total; 
END;

调用

1 2	call getTotalById(1, @total); select @total;

数据库的第一二三范式

第一范式（1NF）
数据库表的每一列都是不可分割的原子数据项，而不能是集合，数组，记录等非原子数据项。
通俗讲就是：一个字段只存储一项信息。
第二范式
如果关系模式R满足第一范式，并且R得所有非主属性都完全依赖于R的每一个候选关键属性，称R满足第二范式（属性完全依赖于每一个主键）。满足第一范式前提，当一个主键由多个属性共同组成时，才会发生不符合第二范式的情况。比如有两个属性的主键，不能存在这样的属性，它只依赖于主键中的一个属性，这就是不符合第二范式。
非主键列是否完全依赖于主键，还是依赖于主键的一部分？
第三范式
定义：第三范式（属性不能传递依赖于主属性）。满足第二范式前提，如果某一属性依赖于其他非主键属性，而其他非主键属性又依赖于主键，那么这个属性就是间接依赖于主键，这被称作传递依赖于主属性。
非主键列是直接依赖于主键，还是直接依赖于非主键列？

delete、truncate、drop的区别及应用场所

1、delete属于DML（数据库操作语言），DELETE语句执行删除的过程是每次从表中删除一行，并且同时将该行的删除操作作为事务记录在日志中保存以便进行进行回滚操作，truncate、drop属于DDL（数据库定义语言），不能回滚
2、在速度上，一般来说，drop> truncate > delete
3、TRUNCATE 和DELETE只删除数据， DROP则删除整个表（结构和数据）
4、Truncate table 表名 速度快,而且效率高,因为: truncate table 在功能上与不带 WHERE 子句的 DELETE 语句相同：二者均删除表中的全部行。但 TRUNCATE TABLE 比 DELETE 速度快，且使用的系统和事务日志资源少。DELETE 语句每次删除一行，并在事务日志中为所删除的每行记录一项。TRUNCATE TABLE 通过释放存储表数据所用的数据页来删除数据，并且只在事务日志中记录页的释放。
实例：删除学生表
1、当你不再需要该表时，用 drop;
2、当你仍要保留该表，但要删除所有记录时，用 truncate;
3、当你要删除部分记录时，用 delete。
drop table table_name : 删除表全部数据和表结构，立刻释放磁盘空间，不管是 Innodb 和 MyISAM;
truncate table table_name : 删除表全部数据，保留表结构，立刻释放磁盘空间，不管是 Innodb 和 MyISAM;
delete from table_name :删除表全部数据，表结构不变，对于 MyISAM 会立刻释放磁盘空间，InnoDB 不会释放磁盘空间;
delete from table_name where xxx : 带条件的删除，表结构不变，不管是 innodb 还是 MyISAM 都不会释放磁盘空间;
delete 操作以后，使用 optimize table table_name 会立刻释放磁盘空间，不管是 innodb 还是 myisam;

DELETE FROM users WHERE name = ‘Mike’ ORDER BY id DESC LIMIT 6;

Redis数据类型

Redis通常被称为数据结构服务器
Redis支持五种数据类型：
1）String: 字符串：整数值、embstr编码的简单动态字符串、简单动态字符串（SDS)
2）List: 列表：压缩列表、双端链表
3）Hash: 哈希：压缩列表、字典
4）Set: 集合：整数集合、字典
5）Sorted Set: 有序集合：压缩列表、跳跃表和字典

mongodb和redis的区别

内存管理机制上： Redis 数据全部存在内存，定期写入磁盘，当内存不够时，可以选择指定的 LRU 算法删除数据。MongoDB 数据存在内存，由 linux系统 mmap 实现，当内存不够时，只将热点数据放入内存，其他数据存在磁盘。
支持的数据结构上： Redis 支持的数据结构丰富，包括hash、set、list等。
MongoDB 数据结构比较单一，但是支持丰富的数据表达，索引，最类似关系型数据库，支持的查询语言非常丰富

Redis是单线程的，但是为什么这么高效呢?

I/O多路复用监听多个套接字
完全基于内存，内存操作快速
单进程单线程不用考虑切换/锁的问题

单进程多线程模型：MySQL、Memcached、Oracle（win）
多进程模型：Oracle（Linux）

Redis的rehash怎么做的，为什么要渐进rehash，渐进rehash又是怎么实现的?

因为redis是单线程，当K很多时，如果一次性将键值对全部rehash，庞大的计算量会影响服务器性能，甚至可能会导致服务器在一段时间内停止服务。不可能一步完成整个rehash操作，所以redis是分多次、渐进式的rehash。渐进性哈希分为两种：
1）操作redis时，额外做一步rehash
对redis做读取、插入、删除等操作时，会把位于table[dict->rehashidx]位置的链表移动到新的dictht中，然后把rehashidx做加一操作，移动到后面一个槽位。
2）后台定时任务调用rehash
后台定时任务rehash调用链，同时可以通过server.hz控制rehash调用频率

C++后台开发知识总结（一）C++基础

2019-09-26T11:13:52.000Z

extern “C”的作用

extern “C”的主要作用就是为了能够正确实现C++代码调用其他C语言代码。加上extern “C”后，会指示编译器这部分代码按C语言（而不是C++）的方式进行编译。

原因是：C++支持函数重载，因此编译器编译函数的过程中会将函数的参数类型也加到编译后的代码中，而不仅仅是函数名；
而C语言并不支持函数重载，因此编译C语言代码的函数时不会带上函数的参数类型，一般只包括函数名。

#ifndef __INCvxWorksh /*防止该头文件被重复引用*/
#define __INCvxWorksh
#ifdef __cplusplus  //告诉编译器，这部分代码按C语言的格式进行编译，而不是C++的
extern "C"{
#endif
 /*…*/
#ifdef __cplusplus
}
#endif
#endif /*end of __INCvxWorksh*/

C++和C的区别

设计思想上：
C++是面向对象的语言，而C是面向过程的结构化编程语言
语法上：
C++具有封装、继承和多态三种特性
C++相比C，增加多许多类型安全的功能，比如强制类型转换
C++支持范式编程，比如模板类、函数模板等

C/C++ const关键字

（1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；可以阻止用户修改返回值。返回值也要相应的付给一个常量或常指针。
（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量。

C/C++ static关键字

1.全局静态变量
在全局变量前加上关键字static，全局变量就定义成一个全局静态变量.
静态存储区，在整个程序运行期间一直存在。
初始化：未经初始化的全局静态变量会被自动初始化为0
作用域：全局静态变量在声明他的文件之外是不可见的，准确地说是从定义之处开始，到文件结尾。
2.局部静态变量
在局部变量之前加上关键字static，局部变量就成为一个局部静态变量。
内存中的位置：静态存储区
初始化：未经初始化的全局静态变量会被自动初始化为0
作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域结束。但是当局部静态变量离开作用域后，并没有销毁，而是仍然驻留在内存当中，只不过我们不能再对它进行访问，直到该函数再次被调用，并且值不变；

int fun(){
    static int count = 10; //在第一次进入这个函数的时候，变量a被初始化为10！并接着自减1
    return count--; //以后每次进入该函数，a就不会被再次初始化了，仅进行自减1的操作   
}

3.静态函数
在函数返回类型前加static，函数就定义为静态函数。函数的定义和声明在默认情况下都是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用。
函数的实现使用static修饰，那么这个函数只可在本cpp内使用，不会同其他cpp中的同名函数引起冲突；warning：不要再头文件中声明static的全局函数，不要在cpp内声明非static的全局函数，如果你要在多个cpp中复用该函数，就把它的声明提到头文件里去，否则cpp内部声明需加上static修饰；
4.类的静态成员及静态成员函数
对象与对象之间的成员变量是相互独立的。要想共用数据，则需要使用静态成员和静态方法。
只要在类中声明静态成员变量，即使不定义对象，也可以为静态成员变量分配空间，进而可以使用静态成员变量。
静态成员变量是在程序编译时分配空间，而在程序结束时释放空间。
初始化静态成员变量要在类的外面进行。不能用参数初始化表，对静态成员变量进行初始化。

在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员（这点非常重要）。
可以通过类名/对象名直接访问类的公有静态成员函数

class test
{
private:
    static int m_value;   //定义私有类的静态成员变量
 
public:
    static int getValue()   //定义类的静态成员函数
    {
      return m_value;
    }
};
int test::m_value = 0;    //类的静态成员变量需要在类外分配内存空间
 
int main()
{
    test t1;
    test t2;
    test t3;

    //通过类名直接调用公有静态成员函数，获取对象个数
    cout << "test::m_value2 = " << test::getValue() << endl;  
    //通过对象名调用静态成员函数获取对象个数
    cout << "t3.getValue() = " << t3.getValue() << endl;
    system("pause");
}

C/C++ volatile关键字

volatile是“易变的”、“不稳定”的意思。volatile是C的一个较为少用的关键字，它用来解决变量在“共享”环境下容易出现读取错误的问题
变量可能会被意想不到地改变，即在你程序运行过程中一直会变，你希望这个值被正确的处理，凡是申明为volatile的变量，每次都是从内存中读取变量的值，而不是在某些情况下直接从寄存器中取值。（有可能被其他的程序（如中断程序、另外的线程等）所修改）

应用场景：
（1）并行设备的硬件寄存器（如状态寄存器）反复读操作，编译器在优化后，也许读操作只做了一次
（2）一个中断服务子程序中访问到的变量
（3）多线程应用中被多个任务共享的变量
当多个线程共享某一个变量时，该变量的值会被某一个线程更改，应该用 volatile 声明。作用是防止编译器优化把变量从内存装入CPU寄存器中，当一个线程更改变量后，未及时同步到其它线程中导致程序出错。

（1）一个参数既可以是const还可以是volatile吗？为什么？
是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
（2）一个指针可以是volatile吗？为什么？
是的。尽管这并不很常见。一个例子是当一个中断服务子程序修该一个指向一个buffer的指针时
（3）下面的函数有什么错误？

int square(volatile int *ptr) 
{ 
    return *ptr * *ptr; 
}
//正确的代码如下：
long square(volatile int *ptr) 
{ 
    int a; 
    a = *ptr; 
    return a * a; 
}

volatile能够避免编译器优化带来的错误，但使用volatile的同时，也需要注意频繁地使用volatile很可能会增加代码尺寸和降低性能，因此要合理的使用volatile。

C/C++ restrict关键字

1 2	const int a=10; int * b=&a; //警告：初始化丢弃了指针目标类型的限定

b失去了对目标对象的const的限定，并且可以通过指针b更改它们共同指向的空间。
const是无法保证某个对象不被更改的，restrict关键字是修饰指针的，对该指针指向的空间的访问，只能从这个指针进入。

什么是右值引用，跟左值又有什么区别？

主要目的有两个方面：
1.消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。
2.能够更简洁明确地定义泛型函数。
左值：能对表达式取地址、或具名对象/变量。一般指表达式结束后依然存在的持久对象。
右值：不能对表达式取地址，或匿名对象。一般指表达式结束就不再存在的临时对象。右值引用和左值引用的区别：
（1）左值可以寻址，而右值不可以。
（2）左值可以被赋值，右值不可以被赋值，可以用来给左值赋值。
（3）左值可变,右值不可变（仅对基础类型适用，用户自定义类型右值引用可以通过成员函数改变）。

1	int i = getVar();

从getVar()函数获取一个整形值，然而，这行代码会产生两种类型的值，一种是左值i，一种是函数getVar()返回的临时值，这个临时值在表达式结束后就销毁了，而左值i在表达式结束后仍然存在，这个临时值就是右值。区分左值和右值的一个简单办法是：看能不能对表达式取地址，如果能，则为左值，否则为右值。

1	int i = 0;

i 是左值，0 是字面量，就是右值。在上面的代码中，i 可以被引用，0 就不可以了。

1	int&& k = getVar();

对右值的引用就是右值引用，getVar()产生的临时值不会像第一行代码那样，在表达式结束之后就销毁了，而是会被“续命”，他的生命周期将会通过右值引用得以延续，和变量k的声明周期一样长。

C++11有哪些新特性

1.auto关键字
编译器可以根据初始值自动推导出类型。但是不能用于函数传参以及数组类型的推导
2.nullptr关键字
nullptr是一种特殊类型的字面值，它可以被转换成任意其它的指针类型；而NULL一般被宏定义为0，在遇到重载时可能会出现问题。
3.智能指针
C++11新增了std::shared_ptr、std::weak_ptr等类型的智能指针，用于解决内存管理的问题。
4.初始化列表
使用初始化列表来对类进行初始化

class Line
{
   public:
      double getLength( void );
      Line(double len);  
 
   private:
      double length;
};
// 成员函数定义，包括构造函数
Line::Line( double len)
{
    cout << "Object is being created, length = " << len << endl;
    length = len;
}
// 等同于
Line::Line( double len): length(len)
{
    cout << "Object is being created, length = " << len << endl;
}

5.右值引用
基于右值引用可以实现移动语义和完美转发，消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率
6.lambda
Lambda表达式定义一个匿名函数，并且可以捕获一定范围内的变量
[捕获列表] (参数列表) mutable或exception声明 ->返回值类型 {函数体}
[捕获列表]，捕获上下文变量以供lambda使用。标识一个Lambda的开始，这部分必须存在，不能省略。
(参数列表)，与普通函数的参数列表一致，如果不需要传递参数，则可以连通括号一起省略。参数可以通过按值（如：(a,b)）和按引用（如：(&a,&b)）两种方式进行传递。
mutable是修饰符，默认情况下lambda函数总是一个const函数，Mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略。
->返回值类型, 当返回值为void，或者函数体中只有一处return的地方（此时编译器可以自动推断出返回值类型）时，这部分可以省略。
{函数体}，内容与普通函数一样，除了可以使用参数之外，还可以使用所捕获的变量。
Lambda表达式与普通函数最大的区别就是其可以通过捕获列表访问一些上下文中的数据。

vector<int> vctTemp;
vctTemp.push_back(1);
vctTemp.push_back(2);

{ // 无函数对象参数，输出：1 2
  for_each(vctTemp.begin(), vctTemp.end(), [](int v){ cout << v << endl; });
}

{ // 以值方式传递作用域内所有可见的局部变量（包括this），输出：11 12
  int a = 10;
  for_each(vctTemp.begin(), vctTemp.end(), [=](int v){ cout << v+a << endl; });
}

{ // 以引用方式传递作用域内所有可见的局部变量（包括this），输出：11 13 12
  int a = 10;
  for_each(vctTemp.begin(), vctTemp.end(), [&](int v)mutable{ cout << v+a << endl; a++; });
  cout << a << endl;
}

{ // 以值方式传递局部变量a，输出：11 13 10
  int a = 10;
  for_each(vctTemp.begin(), vctTemp.end(), [a](int v)mutable{ cout << v+a << endl; a++; });
  cout << a << endl;
}

{ // 以引用方式传递局部变量a，输出：11 13 12
  int a = 10;
  for_each(vctTemp.begin(), vctTemp.end(), [&a](int v){ cout << v+a << endl; a++; });
  cout << a << endl;
}

{ // 传递this，输出：21 22
  for_each(vctTemp.begin(), vctTemp.end(), [this](int v){ cout << v+m_nData << endl; });
}

{ // 除b按引用传递外，其他均按值传递，输出：11 12 17
  int a = 10;
  int b = 15;
  for_each(vctTemp.begin(), vctTemp.end(), [=, &b](int v){ cout << v+a << endl; b++; });
  cout << b << endl;
}

{ // 操作符重载函数参数按引用传递，输出：2 3
  for_each(vctTemp.begin(), vctTemp.end(), [](int &v){ v++; });
  for_each(vctTemp.begin(), vctTemp.end(), [](int v){ cout << v << endl; });
}

{ // 空的Lambda表达式
  [](){}();
  []{}();
}

7.可变参数模板
C++11的可变参数模板，对参数进行了高度泛化，可以表示任意数目、任意类型的参数，其语法为：在class或typename后面带上省略号。
通过递归函数展开参数包，需要提供一个参数包展开的函数和一个递归终止函数。

//递归终止函数
template<typename T>
void myprint(T end)//递归到最后一次，调用单参数函数
{
  cout << "parameter " << end << endl;
}

//展开函数
template<typename T, class ...Args>
void myprint(T head, Args... rest)
{
  cout << "parameter " << head << endl;
  myprint(rest...);
}

int main()
{
  myprint(1, 2, 3, 4);
  return 0;
}

8.atomic原子操作用于多线程资源互斥操作
9.新增STL容器array以及tuple

C++智能指针

智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。C++ 11中最常用的智能指针类型为shared_ptr,它采用引用计数的方法，记录当前内存资源被多少个智能指针引用。该引用计数的内存在堆上分配。当新增一个时引用计数加1，当过期时引用计数减一。只有引用计数为0时，智能指针才会自动释放引用的内存资源。
对shared_ptr进行初始化时不能将一个普通指针直接赋值给智能指针，因为一个是指针，一个是类。可以通过make_shared函数或者通过构造函数传入普通指针。并可以通过get函数获得普通指针。
C++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11支持，并且第一个已经被11弃用。#include
1.unique_ptr（替换auto_ptr）
保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露(例如“以new创建对象后因为发生异常而忘记调用delete”)特别有用。

1
2
3

unique_ptr<string> p3 (new string ("auto"));   //#4
unique_ptr<string> p4；                       //#5
p4 = p3;//此时会报错！！

编译器认为p4=p3非法，避免了p3不再指向有效数据的问题。因此，unique_ptr比auto_ptr更安全。
当程序试图将一个 unique_ptr 赋值给另一个时，如果源 unique_ptr 是个临时右值，编译器允许这么做；如果源 unique_ptr 将存在一段时间，编译器将禁止这么做，比如：

unique_ptr<string> pu1(new string ("hello world"));
unique_ptr<string> pu2;
pu2 = pu1;                                      // #1 not allowed
unique_ptr<string> pu3;
pu3 = unique_ptr<string>(new string ("You"));   // #2 allowed

其中#1留下悬挂的unique_ptr(pu1)，这可能导致危害。而#2不会留下悬挂的unique_ptr，因为它调用 unique_ptr 的构造函数，该构造函数创建的临时对象在其所有权让给 pu3 后就会被销毁。这种随情况而已的行为表明，unique_ptr 优于允许两种赋值的auto_ptr 。
注：如果确实想执行类似与#1的操作，要安全的重用这种指针，可给它赋新值。C++有一个标准库函数std::move()，能够将一个unique_ptr赋给另一个。

shared_ptr
多个智能指针可以指向相同对象，该对象和其相关资源会在“最后一个引用被销毁”时候释放。资源可以被多个指针共享，它使用计数机制来表明资源被几个指针共享。可以通过成员函数use_count()来查看资源的所有者个数。除了可以通过new来构造，还可以通过传入auto_ptr, unique_ptr,weak_ptr来构造。当我们调用release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。
shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计数的机制上提供了可以共享所有权的智能指针。
成员函数：

use_count 返回引用计数的个数
unique 返回是否是独占所有权( use_count 为 1)
swap 交换两个 shared_ptr 对象(即交换所拥有的对象)
reset 放弃内部对象的所有权或拥有对象的变更, 会引起原有对象的引用计数的减少
get 返回内部对象(指针), 由于已经重载了()方法, 因此和直接使用对象是一样的.如 shared_ptr sp(new int(1)); sp 与 sp.get()是等价的

weak_ptr
weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是那个强引用的 shared_ptr.
weak_ptr只是提供了对管理对象的一个访问手段。weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。weak_ptr是用来解决shared_ptr相互引用时的死锁问题,如果说两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，它可以通过调用lock函数来获得shared_ptr。

class B;
class A
{
  public:
  shared_ptr pb_;
  ~A(){
    cout<<"A delete\n";
  }
};
class B
{
  public:
  shared_ptr pa_;
  ~B(){
    cout<<"B delete\n";
  }
};
void fun()
{
  shared_ptr pb(new B());
  shared_ptr pa(new A());
  pb->pa_ = pa;
  pa->pb_ = pb;
  cout<endl; //2
  cout<endl; //2
}
int main()
{
  fun();
  return 0;
}

可以看到fun函数中pa ，pb之间互相引用，两个资源的引用计数为2，当要跳出函数时，智能指针pa，pb析构时两个资源引用计数会减一，但是两者引用计数还是为1，导致跳出函数时资源没有被释放（A B的析构函数没有被调用），如果把其中一个改为weak_ptr就可以了，我们把类A里面的shared_ptr pb_; 改为weak_ptr pb_; 运行结果如下，这样的话，资源B的引用开始就只有1，当pb析构时，B的计数变为0，B得到释放，B释放的同时也会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。
注意的是我们不能通过weak_ptr直接访问对象的方法，比如B对象中有一个方法print(),我们不能这样访问，pa->pb_->print(); 因为pb_是一个weak_ptr，应该先把它转化为shared_ptr,如：

1 2	shared_ptr p = pa->pb_.lock(); p->print();

隐式类型转换

隐式转换指的是不需要用户干预，编译器私下进行的类型转换行为。
首先，对于内置类型，低精度的变量给高精度变量赋值会发生隐式类型转换。如： int 到 double

//混合类型的算术运算表达式中
int a = 3;
double b = 4.5;
double c = a + b;     // a 将被自动转换为 double 类型，再加法。
//不同类型的赋值操作中//
int a = true;         // bool 类型转换为 int 类型
int *ptr = null;      // null 被转换为 int * 类型
//函数参数传值
void func(double a) {};
func(1);               // 1 被隐式的转换为 double 类型1.0
//函数返回值
double add(int a, int b)
{
    return a + b;      // 运算的结果会被隐式的转换为 double 类型再返回
}

其次，对于只存在单个参数的构造函数的对象构造来说，函数调用可以直接使用该参数传入，编译器会自动调用其构造函数生成临时对象。

BOOK A("A-A-A");
BOOK B("B-B-B");
cout<endl;   //正经地进行比较，无需发生转换
cout<string("A-A-A"))<<endl; //此处即发生一个隐式转换：string类型-->BOOK类型，借助BOOK的构造函数进行转换，以满足isSameISBN函数的参数期待。

禁止隐式转换：explicit，该关键字只能用来修饰类内部的构造函数；

1	explicit BOOK(string ISBN,float price=0.0f):_bookISBN(ISBN),_price(price){}

C++四种类型转换

C风格的强制类型转换很简单，均用 Type b = (Type)a 形式转换。
C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用
1、const_cast 去掉类型的const或volatile属性
去掉类型的const或volatile属性

struct T {
    int i;
};

const T a;
//a.i = 10;  //直接修改const类型，编译错误
T &b = const_cast(a);
b.i = 10;

2、static_cast 无条件转换，静态类型转换
基类和子类之间的转换：其中子类指针转换为父类指针是安全的，但父类指针转换为子类指针是不安全的（基类和子类之间的动态类型转换建议用dynamic_cast）。
基本数据类型转换，enum，struct，int，char，float等。static_cast不能进行无关类型（如非基类和子类）指针之间的转换。
把任何类型的表达式转换成void类型。
3、dynamic_cast 有条件转换，动态类型转换，运行时检查类型安全
更多使用static_cast，dynamic本身只能用于存在虚函数的父子关系的强制类型转换，对于指针，转换失败则返回nullptr，对于引用，转换失败会抛出异常
4、reinterpret_cast 仅重新解释类型，但没有进行二进制的转换
可以用于任意类型的指针之间的转换，对转换的结果不做任何保证
为什么不使用C的强制转换？
C的强制转换表面上看起来功能强大什么都能转，但是转化不够明确，不能进行错误检查，容易出错。

C++源文件从文本到可执行文件经历的过程

对于C++源文件，从文本到可执行文件一般需要四个过程：
预处理阶段：主要处理源代码文件中的以“#”开头的预编译指令。对源代码文件中文件包含关系（头文件）、预编译语句（宏定义）进行分析和替换，生成预编译文件。
编译阶段：将经过预处理后的预编译文件转换成特定汇编代码，生成汇编文件
汇编阶段：将编译阶段生成的汇编文件转化成机器码，生成可重定位目标文件
链接阶段：将多个目标文件及所需要的库连接成最终的可执行目标文件

静态链接和动态链接

1、静态链接：
函数和数据被编译进一个二进制文件。在使用静态库的情况下，在编译链接可执行文件时，链接器从库中复制这些函数和数据并把它们和应用程序的其它模块组合起来创建最终的可执行文件。
空间浪费：因为每个可执行程序中对所有需要的目标文件都要有一份副本，所以如果多个程序对同一个目标文件都有依赖，会出现同一个目标文件都在内存存在多个副本；
更新困难：每当库函数的代码修改了，这个时候就需要重新进行编译链接形成可执行程序。
运行速度快：但是静态链接的优点就是，在可执行程序中已经具备了所有执行程序所需要的任何东西，在执行的时候运行速度快。2、动态链接：
动态链接的基本思想是把程序按照模块拆分成各个相对独立部分，在程序运行时才将它们链接在一起形成一个完整的程序，而不是像静态链接一样把所有程序模块都链接成一个单独的可执行文件。
共享库：就是即使需要每个程序都依赖同一个库，但是该库不会像静态链接那样在内存中存在多分，副本，而是这多个程序在执行时共享同一份副本；
更新方便：更新时只需要替换原来的目标文件，而无需将所有的程序再重新链接一遍。当程序下一次运行时，新版本的目标文件会被自动加载到内存并且链接起来，程序就完成了升级的目标。
性能损耗：因为把链接推迟到了程序运行时，所以每次执行程序都需要进行链接，所以性能会有一定损失。

include头文件的顺序以及双引号””和尖括号<>的区别

Include头文件的顺序：对于include的头文件来说，如果在文件a.h中声明一个在文件b.h中定义的变量，而不引用b.h。那么要在a.c文件中引用b.h文件，并且要先引用b.h，后引用a.h,否则汇报变量类型未声明错误。
双引号和尖括号的区别：编译器预处理阶段查找头文件的路径不一样。
对于使用双引号包含的头文件，查找头文件路径的顺序为：
当前头文件目录 -> 编译器设置的头文件路径（编译器可使用-I显式指定搜索路径 -> 系统变量CPLUS_INCLUDE_PATH/C_INCLUDE_PATH指定的头文件路径
对于使用尖括号包含的头文件，查找头文件的路径顺序为：
编译器设置的头文件路径（编译器可使用-I显式指定搜索路径）-> 系统变量CPLUS_INCLUDE_PATH/C_INCLUDE_PATH指定的头文件路径

什么时候会发生段错误

段错误通常发生在访问非法内存地址的时候，具体来说分为以下几种情况：
使用野指针(指向一个不存在的对象或者未申请访问受限内存区域的指针)
试图修改字符串常量的内容

C++ 模板

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。
模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。每个容器都有一个单一的定义，比如向量，我们可以定义许多不同类型的向量，比如 vector 或 vector
函数模板

#include 
#include 
 
using namespace std;
 
template <typename T>
inline T const& Max (T const& a, T const& b) 
{ 
    return a < b ? b:a; 
} 
int main ()
{
    int i = 39;
    int j = 20;
    cout << "Max(i, j): " << Max(i, j) << endl;  //Max(i, j): 39
 
    double f1 = 13.5; 
    double f2 = 20.7; 
    cout << "Max(f1, f2): " << Max(f1, f2) << endl;  //Max(f1, f2): 20.7
 
    string s1 = "Hello"; 
    string s2 = "World"; 
    cout << "Max(s1, s2): " << Max(s1, s2) << endl;  //Max(s1, s2): World
 
   return 0;
}

类模板

#include 
#include 
#include 
#include 
#include 
 
using namespace std;
 
template <class T>
class Stack { 
  private: 
    vector elems;   // 元素 
 
  public: 
    void push(T const&);  // 入栈
    void pop();   // 出栈
    T top() const;   // 返回栈顶元素
    bool empty() const{   // 如果为空则返回真
        return elems.empty(); 
    } 
}; 
 
template <class T>
void Stack::push (T const& elem) 
{ 
    // 追加传入元素的副本
    elems.push_back(elem);    
} 
 
template <class T>
void Stack::pop () 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::pop(): empty stack"); 
    }
    // 删除最后一个元素
    elems.pop_back();         
} 
 
template <class T>
T Stack::top () const 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::top(): empty stack"); 
    }
    // 返回最后一个元素的副本 
    return elems.back();      
} 
 
int main() 
{ 
    try { 
        Stack<int> intStack;   // int 类型的栈 
        Stack<string> stringStack;   // string 类型的栈 
 
        // 操作 int 类型的栈 
        intStack.push(7); 
        cout << intStack.top() <<endl; //7
 
        // 操作 string 类型的栈 
        stringStack.push("hello"); 
        cout << stringStack.top() << std::endl; //hello
        stringStack.pop(); 
        stringStack.pop(); Exception: Stack<>::pop(): empty stack
    } 
    catch (exception const& ex) { 
        cerr << "Exception: " << ex.what() <<endl; 
        return -1;
    } 
}

C++ string实现原理

#include 
#include 
using namespace std;
 
class String
{ 
  public: 
  String(const char *str = NULL); // 普通构造函数 
  String(const String &other); // 拷贝构造函数 
  ~ String(void); // 析构函数 
  String & operator =(const String &other); // 赋值函数 
  private: 
  char *m_data; // 用于保存字符串 
};
 
//普通构造函数
String::String(const char *str) 
{
  if(str==NULL) 
  {
    m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的空
    //加分点：对m_data加NULL 判断
    *m_data = '\0'; 
  } 
  else
  {
    int length = strlen(str); 
    m_data = new char[length+1]; 
    strcpy(m_data, str); 
  }
}
// String的析构函数
String::~String(void) 
{
  delete [] m_data; // 或delete m_data;
}
//拷贝构造函数
String::String(const String &other) 　　　// 得分点：输入参数为const型
{ 
  int length = strlen(other.m_data); 
  m_data = new char[length+1]; 　　　　
  strcpy(m_data, other.m_data); 
}
//赋值函数
String & String::operator =(const String &other) // 得分点：输入参数为const型
{ 
  if(this == &other) 　　//得分点：检查自赋值
  return *this; 
  delete [] m_data; 　　　　//得分点：释放原有的内存资源
  int length = strlen( other.m_data ); 
  m_data = new char[length+1]; 　
  strcpy( m_data, other.m_data ); 
  return *this; 　　　　　　　　//得分点：返回本对象的引用
}
 
int main(char argc, char *argv)
{
  String s1;
  String s2("222");
  s1 = s2;

  return 0;
}

C++ map、set实现原理:红黑树

1、红黑树：
红黑树是一种二叉查找树，但在每个节点增加一个存储位表示节点的颜色，可以是红或黑（非红即黑）。通过对任何一条从根到叶子的路径上各个节点着色的方式的限制，红黑树保证最长路径不超过最短路径的二倍，因而近似平衡。红黑树是一种弱平衡二叉树，相对于要求严格的AVL树来说，它的旋转次数少，所以对于搜索，插入，删除操作较多的情况下，通常使用红黑树。性质：
(1)每个节点非红即黑
(2)根节点是黑的;
(3)每个叶节点（叶节点即树尾端NULL指针或NULL节点）都是黑的;
(4)如果一个节点是红色的，则它的子节点必须是黑色的。
(5)对于任意节点而言，其到叶子点树NULL指针的每条路径都包含相同数目的黑节点;2、平衡二叉树（AVL树）：
红黑树是在AVL树的基础上提出来的。平衡二叉树又称为AVL树，是一种特殊的二叉排序树。其左右子树都是平衡二叉树，且左右子树高度之差不超过1。3、红黑树较AVL树的优点：
AVL 树是高度平衡的，频繁的插入和删除，会引起频繁的rebalance，导致效率下降；红黑树不是高度平衡的，算是一种折中，插入最多两次旋转，删除最多三次旋转。所以红黑树在查找，插入删除的性能都是O(logn)，且性能稳定，所以STL里面很多结构包括set、map底层实现都是使用的红黑树。
4、红黑树旋转：
旋转：红黑树的旋转是一种能保持二叉搜索树性质的搜索树局部操作。有左旋和右旋两种旋转，通过改变树中某些结点的颜色以及指针结构来保持对红黑树进行插入和删除操作后的红黑性质。
左旋：对某个结点x做左旋操作时，假设其右孩子为y：以x到y的链为“支轴”进行。使y成为该子树新的根结点，x成为y的左孩子，y的左孩子成为x的右孩子。

右旋：对某个结点x做右旋操作时，假设其左孩子为y而不是T.nil：以x到y的链为“支轴”进行。使y成为该子树新的根结点，x成为y的右孩子，y的右孩子成为x的左孩子。

哈夫曼编码

JPEG中就应用了哈夫曼编码。哈夫曼编码是哈夫曼树的一种应用，广泛用于数据文件压缩。
哈夫曼树又称最优二叉树，是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点的权值乘上其到根结点的路径长度（若根结点为0层，叶结点到根结点的路径长度为叶结点的层数）。树的带权路径长度记为WPL= (W1L1 + W2L2 + W3L3 + … + WnLn)，N个权值Wi(i=1,2,…n)构成一棵有N个叶结点的二叉树，相应的叶结点的路径长度为Li(i=1,2,…n)。可以证明哈夫曼树的WPL是最小的。
哈夫曼编码步骤：
一、对给定的n个权值{W1,W2,W3,…,Wi,…,Wn}构成n棵二叉树的初始集合F= {T1,T2,T3,…,Ti,…,Tn}，其中每棵二叉树Ti中只有一个权值为Wi的根结点，它的左右子树均为空。（为方便在计算机上实现算法，一般还要求以Ti的权值Wi的升序排列。）
二、在F中选取两棵根结点权值最小的树作为新构造的二叉树的左右子树，新二叉树的根结点的权值为其左右子树的根结点的权值之和。
三、从F中删除这两棵树，并把这棵新的二叉树同样以升序排列加入到集合F中。
四、重复二和三两步，直到集合F中只有一棵二叉树为止。
哈夫曼编码是一种无前缀编码。解码时不会混淆。其主要应用在数据压缩，加密解密等场合。
a b c d e :5 4 3 2 1

vector、list、deque、set、map的应用场景

1、set和map
共同点：都是C++的关联容器,只是通过它提供的接口对里面的元素进行访问，底层都是采用红黑树实现
不同点：
set：用来判断某一个元素是不是在一个组里面，使用的比较少；
map：映射，相当于字典，把一个值映射成另一个值，可以创建字典
优点：查找某一个数的时间为O(logn)；遍历时采用iterator，效果不错
缺点：每次插入值的时候，都需要调整红黑树，效率有一定影响
2、vector
是动态数组，在堆中分配内存，元素连续存放，有保留内存，如果减少大小后，内存也不会释放；如果新值大于当前大小时才会重新分配内存。
特点：拥有一段连续的内存空间，并且起始地址不变，因此能够非常好的支持随机存取，即[]操作符；
对头部和中间进行添加删除元素操作需要移动内存，如果元素是结构或类，那么移动的同时还会进行构造和析构操作，所以性能不高；
对任何元素的访问时间都是O(1)，所以常用来保存需要经常进行随机访问的内容，并且不需要经常对中间元素进行添加删除操作
3、list
双向链表，元素也存放在堆中，每个元素都是放在一块内存中，他的内存空间可以是不连续的，通过指针来进行数据的访问，这个特点使得它的随机存取变得非常没有效率，因此它没有提供[]操作符的重载。但是由于链表的特点，它可以很有效率的支持任意地方的删除和插入操作。
特点
在哪里添加删除元素性能都很高，不需要移动内存，当然也不需要对每个元素都进行构造与析构了，所以常用来做随机插入和删除操作容器；
访问开始和最后两个元素最快，其他元素的访问时间都是O(n)
4、deque
分段连续线性空间，支持[]操作符，也就是支持随机存取，有比较高的随机存取速度，由于deque需要处理内部跳转，因此速度上没有vector快

	deque	vector
组织方式	按页或块来分配存储器的，每页包含固定数目的元素	分配一段连续的内存来存储内容
效率	即使在容器的前端也可以提供常数时间的insert和erase操作，而且在体积增长方面也比vector更具有效率	只是在序列的尾端插入元素时才有效率，但是随机访问速度要比deque快

vector和list的区别

1）vector底层实现是数组；list是双向链表。
2）vector是顺序内存,支持随机访问，list不行。
4）vector在中间节点进行插入删除会导致内存拷贝，list不会。
5）vector一次性分配好内存，不够时才进行2倍扩容；list每次插入新节点都会进行内存申请。
6）vector随机访问性能好，插入删除性能差；list随机访问性能差，插入删除性能好。

vector、list、map、set迭代器失效

解决方式1： iter =cont.erase(iter)

//要求只是删除值为偶数的节点 , vector vec{ 1, 2, 3, 4, 5 };
 vector<int> ::iterator it1 = vec.begin();

 //错误实现：链表删除节点导致的迭代器失效，容易造成访问野指针的问题，导致程序崩溃
 while (it1 != vec.end()) {
   if (*it1 % 2 == 0){
     vec.erase(it1); 
   }
   it1++;
 }

 //正确实现：利用erase()函数的返回值为iterator，返回的是删除节点的下一个位置的迭代器
 while (it1 != vec.end()) {
   if (*it1 % 2 == 0){
     it1 = vec.erase(it1); //重点！！！
   }
   else{
     it1++;
   }
 }

解决方式2：erase(iter++)

//要求删除键值为偶数的键值对
map<int, int>::iterator it = m.begin();

//错误实现：
while (it != m.end()){
  if(it->second % 2 == 0){
    m.erase(it);
  }
  it++;
}

//正确实现：
while (it != m.end()){
  if(it->second % 2 == 0){
    m.erase(it++); //重点！！！
  }
  else{
    it++;
  }
}

C++内存分配管理

在C++中，虚拟内存分为text代码段、data数据段、bss段、heap堆区、文件映射区以及stack栈区六部分。3G用户空间和1G内核空间
代码段 包括只读存储区和文本区，其中只读存储区存储字符串常量，文本区存储程序的机器代码。
数据段 存储程序中已初始化的全局变量和静态变量
bss 段 存储未初始化的全局变量和静态变量（局部+全局），以及所有被初始化为0的全局变量和静态变量。
堆区调用new/malloc函数时在堆区动态分配内存，同时需要调用delete/free来手动释放申请的内存。
映射区 存储动态链接库以及调用mmap函数进行的文件映射
栈使用栈空间存储函数的返回地址、参数、局部变量、返回值

内存分配方式有三种：
[1]从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
[2]在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
[3]从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由程序员决定，使用非常灵活，但如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，频繁地分配和释放不同大小的堆空间将会产生堆内碎块。

A* a = new A; a->i = 10;在内核中的内存分配上发生了什么？

1）A *a：a是一个局部变量，类型为指针，故而操作系统在程序栈区开辟4/8字节的空间（0x000m），分配给指针a。
2）new A：通过new动态的在堆区申请类A大小的空间（0x000n）。
3）a = new A：将指针a的内存区域填入栈中类A申请到的地址的地址。即*（0x000m）=0x000n。
4）a->i：先找到指针a的地址0x000m，通过a的值0x000n和i在类a中偏移offset，得到a->i的地址0x000n + offset，进行*(0x000n + offset) = 10的赋值操作，即内存0x000n + offset的值是10。

给你一个类，里面有static，virtual，之类的，来说一说这个类的内存分布

1、static修饰符
1）static修饰成员变量
无论类被定义了多少个，静态数据成员都只有一份拷贝，为该类型的所有对象所共享(包括其派生类)。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新。
因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以它不属于特定的类对象，在没有产生类对象前就可以使用。
2）static修饰成员函数
与普通的成员函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上来说，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，只能调用其他的静态成员函数。
Static修饰的成员函数，在代码区分配内存。

2、C++继承和虚函数
C++多态分为静态多态和动态多态。静态多态是通过重载和模板技术实现，在编译的时候确定。动态多态通过虚函数和继承关系来实现，执行动态绑定，在运行的时候确定。
动态多态实现有几个条件：
(1) 虚函数；
(2) 一个基类的指针或引用指向派生类的对象；
基类指针在调用成员函数(虚函数)时，就会去查找该对象的虚函数表。虚函数表的地址在每个对象的首地址。查找该虚函数表中该函数的指针进行调用。
每个对象中保存的只是一个虚函数表的指针，C++内部为每一个类维持一个虚函数表，该类的对象的都指向这同一个虚函数表。
虚函数表中为什么就能准确查找相应的函数指针呢？因为在类设计的时候，虚函数表直接从基类也继承过来，如果覆盖了其中的某个虚函数，那么虚函数表的指针就会被替换，因此可以根据指针准确找到该调用哪个函数。

3、virtual修饰符
如果一个类是局部变量则该类数据存储在栈区，如果一个类是通过new/malloc动态申请的，则该类数据存储在堆区。如果该类是virutal继承而来的子类，则该类的虚函数表指针和该类其他成员一起存储。虚函数表指针指向只读数据段中的类虚函数表，虚函数表中存放着一个个函数指针，函数指针指向代码段中的具体函数。
如果类中成员是virtual属性，会隐藏父类对应的属性。

静态变量什么时候初始化

静态变量存储在虚拟地址空间的数据段和bss段，C语言中其在代码执行之前初始化，属于编译期初始化。而C++中由于引入对象，对象生成必须调用构造函数，因此C++规定全局或局部静态对象当且仅当对象首次用到时进行构造

STL的allocator

STL的分配器用于封装STL容器在内存管理上的底层细节。
在C++中，其内存配置和释放如下：
new运算分两个阶段：(1)调用::operator new配置内存;(2)调用对象构造函数构造对象内容
delete运算分两个阶段：(1)调用对象析构函数；(2)掉用::operator delete释放内存

为了精密分工，STL allocator将两个阶段操作区分开来：
内存配置由alloc::allocate()负责，内存释放由alloc::deallocate()负责；
对象构造由::construct()负责，对象析构由::destroy()负责。

同时为了提升内存管理的效率，减少申请小内存造成的内存碎片问题，SGI STL采用了两级配置器，当分配的空间大小超过128B时，会使用第一级空间配置器，使用malloc()、realloc()、free()函数进行内存空间的分配和释放；当分配的空间大小小于128B时，将使用第二级空间配置器，采用了内存池技术，通过空闲链表来管理内存。

malloc的原理，另外brk系统调用和mmap系统调用的作用分别是什么？

Malloc函数用于动态分配内存。为了减少内存碎片和系统调用的开销，malloc其采用内存池的方式，先申请大块内存作为堆区，然后将堆区分为多个内存块，以块作为内存管理的基本单位。当用户申请内存时，直接从堆区分配一块合适的空闲块。Malloc在申请内存时，一般会通过brk或者mmap系统调用进行申请。其中当申请内存小于128K时，会使用系统函数brk在堆区中分配；而当申请内存大于128K时，会使用系统函数mmap(内存映射)在映射区分配。

C++ STL 的内存优化

1）二级配置器结构
STL内存管理使用二级内存配置器。
1、第一级配置器分配的区块大于128bytes
第一级配置器以malloc()，free()，realloc()等C函数执行实际的内存配置、释放、重新配置等操作，并且能在内存需求不被满足的时候，调用一个指定的函数。
2、第二级配置器分配的区块小于128bytes
在STL的第二级配置器中多了一些机制，避免太多小区块造成的内存碎片，小额区块带来的不仅是内存碎片，配置时还有额外的负担。
内存池管理: 每次配置一大块内存，并维护对应的16个空闲链表（free-list）。下次若有相同大小的内存需求，则直接从free-list中取。如果有小额区块被释放，则由配置器回收到free-list中。
当用户申请的空间小于128字节时，将字节数扩展到8的倍数，然后在自由链表中查找对应大小的子链表
如果在自由链表查找不到或者块数不够，则向内存池进行申请，一般一次申请20块
如果内存池空间足够，则取出内存
如果不够分配20块，则分配最多的块数给自由链表
如果一块都无法提供，则把剩余的内存挂到自由链表，然后向系统heap申请空间，如果申请失败，则看看自由链表还有没有可用的块，如果也没有，则最后调用一级空间配置器

2）二级内存池

二级内存池采用了16个空闲链表，这里的16个空闲链表分别管理大小为8、16、24……120、128的数据块。这里空闲链表节点的设计十分巧妙，这里用了一个联合体既可以表示下一个空闲数据块（存在于空闲链表中）的地址，也可以表示已经被用户使用的数据块（不存在空闲链表中）的地址。
如何分配内存：
它的内存分配主要分为以下几种情况：
1、对应的free_list不为空
所需空间大小提升为8的倍数后(如需要13bytes空间，我们会给它分配16bytes大小)，所对应的free_list不为空时，直接从对应的free_list中拔出，第一位置向后移动指向。
2、对应的free_list为空，其内存池不为空时：
（1）先检验它剩余空间是否够20个节点大小（即所需内存大小(提升后) *20），若足够则直接从内存池中拿出20个节点大小空间，将其中一个分配给用户使用，另外19个当作自由链表中的区块挂在相应的free_list下，这样下次再有相同大小的内存需求时，可直接从 free-list 中拨出。
（2）如果不够20个节点大小，则看它是否能满足1个节点大小，如果够的话则直接拿出一个分配给用户，然后从剩余的空间中分配尽可能多的节点挂在相应的free_list中。
（3）如果连一个节点内存都不能满足的话，则将内存池中剩余的空间挂在相应的free_list中（找到相应的free_list），然后再给内存池申请内存。
3、内存池为空，申请内存
此时二级空间配置器会使用malloc()从heap上申请内存。
4、malloc没有成功
在第三种情况下，如果malloc()失败了，说明heap上没有足够空间分配给我们了，这时，二级空间配置器会从比所需节点空间大的free_list中一一搜索，从任意一个比它所需节点空间大的free_list中拔除一个节点来使用。
5、查找失败，调用一级空间配置器
释放内存
用户调用deallocate释放内存空间，如果要求释放的内存空间大于128bytes，直接调用free。
否则按照其大小找到合适的自由链表，并将其插入。

new/delete和 malloc/free的区别

1、new/delete是C++关键字支持重载，需要编译器支持。malloc/free是库函数，需要头文件stdlib.h支持。
2、new分配内存按照数据类型进行分配，malloc分配内存按照指定的大小分配；
3、new返回的是指定对象的指针，而malloc返回的是void*，因此malloc的返回值一般都需要进行类型转化。
4、new不仅分配一段内存，而且会调用构造函数，malloc不会。
5、new分配的内存要用delete销毁，malloc要用free来销毁；delete销毁的时候会调用对象的析构函数，而free则不会。
6、malloc分配的内存不够的时候，可以用realloc扩容。扩容的原理？new没用这样操作。
7、new如果分配失败了会抛出bad_malloc的异常，而malloc失败了会返回NULL。
8、new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。
自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。自由存储区不等于堆

//申请ArraySize大小的数组
int* Array = (int*)malloc(ArraySize * sizeof(int)); // 在堆中申请内存
memset(Array, 0, ArraySize * sizeof(int)); // 初始化数组全为 0
free(Array); // 释放内存

int* Array = new int[ArraySize]; // 申请内存，不初始化
//int* Array = new int[ArraySize](); // 初始化数组全为 0
//int* Array = new int[5]{ 1,2,3,4,5 }; // 初始化数组为 1,2,3,4,5（VS2015支持）
//int* Array = new int[5]{ 1 }; // 初始化数组为 1,0,0,0,0
memset(Array, 1, ArraySize * sizeof(int)); // 初始化数组全为 1
delete[] Array; // 释放内存

memory leak，内存泄漏

内存泄漏(memory leak)是指由于疏忽或错误造成了程序未能释放掉不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。可以使用Valgrind, mtrace进行内存泄漏检查。

内存泄漏的分类：
1.堆内存泄漏（Heap leak）。对内存指的是程序运行中根据需要分配通过malloc,realloc new等从堆中分配的一块内存，再是完成后必须通过调用对应的 free或者delete 删掉。如果程序的设计的错误导致这部分内存没有被释放，那么此后这块内存将不会被使用，就会产生Heap Leak.
2.系统资源泄露（Resource Leak）。主要指程序使用系统分配的资源比如 Bitmap,handle ,SOCKET等没有使用相应的函数释放掉，导致系统资源的浪费，严重可导致系统效能降低，系统运行不稳定。
3.没有将基类的析构函数定义为虚函数。当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确是释放，因此造成内存泄露。

STL有什么基本组成

算法、容器、迭代器

STL中map与unordered_map

底层实现：
map底层是基于红黑树实现的，因此map内部元素排列是有序的。而unordered_map底层则是基于哈希表实现的，因此其元素的排列顺序是杂乱无序的。
map ：
优点：
1)有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作
2)map的查找、删除、增加等一系列操作时间复杂度稳定，都为O(logn )
缺点：查找、删除、增加等操作平均时间复杂度较慢，与n相关
unordered_map：
优点：
查找、删除、添加的速度快，时间复杂度为常数级O(c )
unordered_map 缺点：
因为unordered_map内部基于哈希表，以（key,value）对的形式存储，因此空间占用率高
unordered_map的查找、删除、添加的时间复杂度不稳定，平均为O(c )，取决于哈希函数。极端情况下可能为O(n)

STL中迭代器的作用，有指针为何还要迭代器

Iterator类的访问方式就是把不同集合类的访问逻辑抽象出来，使得不用暴露集合内部的结构而达到循环遍历集合的效果。
迭代器和指针的区别:
迭代器不是指针，是类模板，表现的像指针。他模拟了指针的一些功能，通过重载了指针的一些操作符，->、*、++、- -等，提供了比指针更高级的行为，可以根据不同类型的数据结构来实现不同的++，- -等操作。

STL里resize和reserve的区别

resize()：改变当前容器内含有元素的数量(size())

1
2
3

vector<int>v{1 ,2}; 
v.resize(4);
v.push_back(5); //1 2 0 0 5

v的size变为len,如果原来v的size小于len，那么容器新增（len-size）个元素，元素的值为默认为0.当v.push_back(3);之后，则是3是放在了v的末尾，即下标为len，此时容器是size为len+1；

reserve()：改变当前容器的最大容量（capacity）
如果reserve(len)的值大于当前的capacity()，那么会重新分配一块能存len个对象的空间，然后把之前v.size()个对象通过copy construtor复制过来，销毁之前的内存；

注意：当v.resize(len)中len>v.capacity()，则v中的size和capacity均设置为len；

当v.resize(len) 中len<=v.capacity()，则v中的size设置为len，而capacity不变;
如果此时len当v.reserve(len)中len<=v.capacity()，则v中的capacity不变，size不变，即不对容器做任何改变。

vector<int> a;
a.reserve(100);
a.resize(50);
cout<"  "<endl; //50  100
a.resize(150);
cout<"  "<endl; //150  150
a.reserve(50);
cout<"  "<endl; //150  150
a.resize(50);
cout<"  "<endl; //50  150

size可能改变capacity，但capacity不会改变size

C++函数重载、覆盖、隐藏

重载:
函数重载：两个函数名相同，但是参数列表不同（个数，类型），返回值类型没有要求，在同一作用域中
运算符重载：Box operator+(const Box&); //返回类型 Box
覆盖/重写:
子类继承了父类，父类中的函数是虚函数，在子类中重新定义了这个虚函数，这种情况是重写
隐藏:
派生类的函数屏蔽了与其同名的基类函数。

不能重载的运算符：
“.” “.*” “?:” “sizeof()” “typeid()” “static_cast<>” “dynamic_cast<>” “const_cast<>” “#” “##”

C++编译时多态与运行时多态

多态的实现主要分为静态多态和动态多态，静态多态主要是重载，在编译的时候就已经确定；动态多态是用虚函数机制实现的，在运行期间动态绑定。
一个父类类型的指针指向一个子类对象时候，使用父类的指针去调用子类中重写了的父类中的虚函数的时候，会调用子类重写过后的函数。
静态多态

int Add(int left, int right)
{
    return left + right;
}
double Add(double left, int right)
{
    return left + right;
}

int main()
{
    Add(10, 20);
    Add(10.0,20);  //正常代码
    return 0;
}

动态多态

class Father{
public:
    virtual void Say(){ //重点！！！
        cout << "Father say hello" << endl;
    }
};

class Son:public Father{
public:     
    void Say(){
        cout << "Son say hello" << endl;
    }
};

void main(){
    Father *pFather;
    Son son;
    pFather = &son; 
    pFather->Say(); //Son say hello
}

虚函数的实现

在有虚函数的类中，类的最开始部分是一个虚函数表的指针，这个指针指向一个虚函数表，表中放了虚函数的地址，实际的虚函数在代码段(.text)中。当子类继承了父类的时候也会继承其虚函数表，当子类重写父类中虚函数时候，会将其继承到的虚函数表中的地址替换为重新写的函数地址。使用了虚函数，会增加访问内存开销，降低效率。

如何实现只能动态分配类对象，不能静态分配

动态分配就是用运算符new来创建一个类的对象，在堆上分配内存。
静态分配就是A a;这样来由编译器来创建一个对象，在栈上分配内存。
1、动态分配（在堆上分配内存）
将类的构造函数和析构函数设为protected属性，这样类对象不能够访问，但是派生类能够访问，能够正常的继承。同时创建另外两个create和destory函数类创建对象。（将create设为static原因是：创建对象的时候是A *p = A::create(); 只有静态成员函数才能够通过类名来访问。）

class A  
{  
protected:  
    A(){}  
    ~A(){}  
public:  
    static A* create()  
    {  
        return new A();  
    }  
    void destory()  
    {  
        delete this;  
    }  
};

2、只能静态创建对象
只有使用new运算符，对象才会被建立在堆上。因此只要限制new运算符就可以实现类对象只能建立在栈上。可以将new运算符设为私有，实现如下：

class A  
{  
private:  
     void* operator new(size_t t){}
     void operator delete(void* ptr){} 
public:  
     A(){}  
     ~A(){}  
};

C++中类成员的访问权限

C++通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限，它们分别表示公有的、受保护的、私有的，被称为成员访问限定符。
在类的内部（定义类的代码内部），无论成员被声明为 public、protected 还是 private，都是可以互相访问的，没有访问权限的限制。
在类的外部（定义类的代码之外），只能通过对象访问成员，并且通过对象只能访问 public 属性的成员，不能访问 private、protected 属性的成员。

无论共有继承、私有和保护继承，私有成员不能被“派生类”访问，基类中的共有和保护成员能被“派生类”访问。
对于共有继承，只有基类中的共有成员能被“派生类对象”访问，保护和私有成员不能被“派生类对象”访问。对于私有和保护继承，基类中的所有成员不能被“派生类对象”访问。

C++类内可以定义引用数据成员吗？

可以，必须通过成员函数初始化列表初始化。

动态链接库与静态链接库的区别

1、静态链接库的后缀名为lib，动态链接库的导入库的后缀名也为lib。不同的是，静态库中包含了函数的实际执行代码，而对于导入库而言，其实际的执行代码位于动态库中，导入库只包含了地址符号表等，确保程序找到对应函数的一些基本地址信息；
2、由于静态库是在编译期间直接将代码合到可执行程序中，而动态库是在执行期时调用DLL中的函数体，所以执行速度比动态库要快一点；
3、静态库链接生成的可执行文件体积较大，且包含相同的公共代码，造成内存浪费；
4、使用动态链接库的应用程序不是自完备的，它依赖的DLL模块也要存在，如果使用载入时动态链接，程序启动时发现DLL不存在，系统将终止程序并给出错误信息。而使用运行时动态链接，系统不会终止，但由于DLL中的导出函数不可用，程序会加载失败；
5、 DLL文件与EXE文件独立，只要输出接口不变（即名称、参数、返回值类型和调用约定不变），更换DLL文件不会对EXE文件造成任何影响，因而极大地提高了可维护性和可扩展性，适用于大规模的软件开发，使开发过程独立、耦合度小，便于不同开发者和开发组织之间进行开发和测试。

C++中struct和class的区别

在c中，struct不能包含任何函数, 在C++中struct得到了很大的扩充：1.struct可以包括成员函数2.struct可以实现继承3.struct可以实现多态。在C++中struct和class的区别并不是很大，两者之间有很大的相似性。那么为什么还要保留struct,这是因为C++是向下兼容的，因此C++中保留了很多C的东西。
区别：
1.默认的继承访问权。struct的默认继承权限和默认访问权限是public，而class的默认继承权限和默认访问权限是private。
2.另外，class还可以定义模板类形参，比如template 。

C++接口（抽象类）

如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类，纯虚函数是通过在声明中使用 “= 0” 来指定的。设计抽象类的目的，是为了给其他类提供一个可以继承的适当的基类。抽象类不能被用于实例化对象，它只能作为接口使用。

class soapBase
{
  public:
  virtual ~soapBase(){};
  virtual void show() = 0;
};
 
class SFJSoap:public soapBase
{
  public:
  void show() {cout<<"SFJ Soap!"<<endl;}
};
 
class XSLSoap:public soapBase
{
  public:
  void show() {cout<<"XSL Soap!"<<endl;}
};

虚函数与纯虚函数区别

C++的虚函数主要作用是“运行时多态”，父类中提供虚函数的实现，为子类提供默认的函数实现。子类可以重写父类的虚函数实现子类的特殊化。
C++中的纯虚函数更像是“只提供申明，没有实现”，是对子类的约束，是“接口继承”。 C++中包含纯虚函数的类，被称为是“抽象类”。抽象类不能使用new出对象，只有实现了这个纯虚函数的子类才能new出对象。

构造函数、析构函数

构造函数会在每次创建类的新对象时执行。构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
使用初始化列表来初始化字段

1	C::C( double a, double b, double c): X(a), Y(b), Z(c){....}

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
当对象结束其生命周期，如对象所在的函数已调用完毕时，系统会自动执行析构函数。如果用户没有编写析构函数，编译系统会自动生成一个缺省的析构函数（即使自定义了析构函数，编译器也总是会为我们合成一个析构函数，并且如果自定义了析构函数，编译器在执行时会先调用自定义的析构函数再调用合成的析构函数），它也不进行任何操作。所以许多简单的类中没有用显式的析构函数。
如果一个类中有指针，且在使用的过程中动态的申请了内存，那么最好显示构造析构函数在销毁类之前，释放掉申请的内存空间，避免内存泄漏。
类析构顺序：1）派生类本身的析构函数；2）对象成员析构函数；3）基类析构函数。

class Line {
   public:
      void setLength( double len );
      double getLength( void );
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line(void){
    cout << "Object is being created" << endl;
}
Line::~Line(void) {
    cout << "Object is being deleted" << endl;
}
 
void Line::setLength( double len ) {
    length = len;
}
 
double Line::getLength( void ) {
    return length;
}

为什么析构函数必须是虚函数？
将可能会被继承的父类的析构函数设置为虚函数，可以保证当我们new一个子类，然后使用基类指针指向该子类对象，释放基类指针时可以释放掉子类的空间，防止内存泄漏。

为什么C++默认的析构函数不是虚函数
C++默认的析构函数不是虚函数是因为虚函数需要额外的虚函数表和虚表指针，占用额外的内存。而对于不会被继承的类来说，其析构函数如果是虚函数，就会浪费内存。因此C++默认的析构函数不是虚函数，而是只有当需要当作父类时，设置为虚函数。

静态函数和虚函数的区别

静态函数在编译的时候就已经确定运行时机，虚函数在运行的时候动态绑定。虚函数因为用了虚函数表机制，调用的时候会增加一次内存开销

指针和引用的区别

1 2	int a=1;int *p=&a; int a=1;int &b=a;

指针是一个变量，存储的是一个地址，指向内存的一个存储单元；而引用跟原来的变量实质上是同一个东西，是原变量的一个别名。
区别：
1、指针有自己的一块空间，而引用只是一个别名；
2、使用sizeof看一个指针的大小是4（32位），而引用则是被引用对象的大小；
3、指针可以被初始化为NULL，而引用必须被初始化且必须是一个已有对象的引用；
4、作为参数传递时，指针需要被解引用才可以对对象进行操作，而直接对引用的修改都会改变引用所指向的对象；
5、可以有const指针，但是没有const引用；
6、指针在使用中可以指向其它对象，但是引用只能是一个对象的引用，不能被改变；
7、指针可以有多级指针（**p），而引用至于一级；
8、指针和引用使用++运算符的意义不一样。

实际上”引用”可以做的任何事情”指针”也都能够做，为什么还要”引用”这东西？
答案是指针能够毫无约束地操作内存中的任何东西，尽管指针功能强大，但是非常危险。
如果的确只需要借用一下某个对象的”别名”，那么就用”引用”，而不要用”指针”，以免发生意外。

数组和指针的区别

指针

数组

保存数据的地址

保存数据

间接访问数据，首先获得指针的内容，然后将其作为地址，从该地址中提取数据

直接访问数据

通常用于动态的数据结构

通常用于固定数目且数据类型相同的元素

通过Malloc分配内存，free释放内存

隐式的分配和删除

通常指向匿名数据，操作匿名函数

自身即为数据名

# 函数指针

函数指针是指向函数的指针变量。

函数指针本身首先是一个指针变量，该指针变量指向一个具体的函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数

bool LengthCompare(const string &,const string &)
//想要声明一个指向改函数的指针，只需要用指针替换函数名即可
bool (*pf)(const string&, const string&);//未初始化　
pf=LengthCompare;
//pf=&LengthCompare;
bool b1=pf("hello","goodbye");
bool b2=(*pf)("hello","goodbye");
bool b3=LengthCompare("hello","goodbye");
//三个等价调用

const char ，char ，const char crr[]，char drr[]

const char * arr = "123";
//字符串123保存在常量区，const本来是修饰arr指向的值不能通过arr去修改
//但是字符串“123”在常量区，本来就不能改变，所以加不加const效果都一样
char * brr = "123";
//字符串123保存在常量区，这个arr指针指向的是同一个位置，同样不能通过brr去修改"123"的值
const char crr[] = "123";
//这里123本来是在栈上的，但是编译器可能会做某些优化，将其放到常量区
char drr[] = "123";
//字符串123保存在栈区，可以通过drr去修改

C++里是怎么定义常量的？常量存放在内存的哪个位置？

常量在C++里的定义const加上对象类型，常量定义必须初始化。
对于局部常量，存放在栈区；
对于全局常量，编译期一般不分配内存，放在符号表中以提高访问效率；
字面值常量，比如字符串，放在常量区。

sizeof

sizeof和new、delete等一样，是关键字，不是函数或者宏
sizeof返回内存中分配的字节数，它和操作系统的位数有关。例如在常见的32位系统中，int类型占4个字节；但是在16位系统中，int类型占2个字节。

// 在32位系统中不同类型的内存分配
// 基本类型
sizeof(int);        // = 4   
sizeof(double);     // = 8   
sizeof(char);       // = 1   
sizeof(bool);       // = 1   
sizeof(short);      // = 2   
sizeof(float);      // = 4   
sizeof(long);       // = 4  
// 指针
sizeof(int *);         // = 4   
sizeof(double *);      // = 4   
sizeof(char *);        // = 4  
//函数
void fn() { }   
sizeof(fn); // error：函数   
sizeof(fn()); // error：不能确定类型  
//sizeof对函数调用求值结果是函数返回值类型的大小，函数并不会被调用
int fun() { return 3;}   
sizeof(fun);  // = sizeof(int) = 4
// 数组 
int ai[] = {1, 2};  //数组的sizeof返回整个数组所占的字节数，即（数组元素个数×每个元素所占字节）。
sizeof(ai);         // = 2*4 = 8  
// 常量字符串与字符数组的内存分配方式相同
char ac[] = "abcd";  //注意数组末尾的字符串终结符'\0'   
sizeof(ac);          // = 5*1 = 5   //注意！！！
sizeof("abcd");      // = 5*1 = 5  
// 数组和指针所占的字节数不同
int *pi = new int[10]; //这是指针   
sizeof(pi);            // = 4   
int ai[10];   
int *p = ai;           //这还是指针   
sizeof(p);             // = 4   
  
double* (*a)[3][6];    //看成(double *) (*a)[3][6]，即一个3×6的二维数组，数组元素为指针，指向double类型。   
sizeof(a);             // = 4，a为指向上述二维数组的指针   
sizeof(*a);            // = sizeof(double *)*3*6 = 72，*a表示上述二维数组       
sizeof(**a);           // = sizeof(double *)*6 = 24，**a即*(*a)，表示double*[6]，是元素为double指针的一维数组。   
sizeof(***a);          // = sizeof(double *) = 4，表示上述一维数组中的第一个元素，元素类型为double指针。   
sizeof(****a);         // = sizeof(double) = 8，表示上述数组首元素指向的double类型。 
// 函数形式参数中的数组会蜕变为指针，原因是数组参数“传址调用”
void aif(int p[])       //参数类型是int[]，表示指向int的指针   
{   
    sizeof( p );        // = 4   
}   
void pif(int (*p)[6])   //参数类型是int (*)[6]，表示指向int数组的指针   
{   
    sizeof( p);         // = 4   
    sizeof( *p );       // = sizeof(int)*6 = 24   
}   
void ppf(int *p[6])     //参数类型是int *[]，表示指向int指针的指针   
{   
    sizeof( p );        // = 4   
    sizeof( *p );       // = 4   
}  
// 32位 类和结构体的内存分配
// 空类或空结构体占一个字节
class CEmpty { };   
sizeof(CEmpty); // = 1   
struct SEmpty { };   
sizeof(SEmpty); // = 1 
// 非空类和结构体所占字节为所有成员占字节的和，但是不包括成员函数和静态成员所占的空间
class CInt : public CEmpty { int i;};   
sizeof(CInt); // = 4;   
  
class CFunc { void f(){} };   
sizeof(CFunc); // = 1;   
  
struct SInt : SEmpty { static int i;};   
sizeof(SInt); // = 1;  
// 字节对齐
struct SByte1   
{   
    double d;    // 长度8，偏移量为0；存放位置区间[0,7]
    char j;      // 长度1，偏移量为8；存放位置区间[8]
    int a;       // 长度4，偏移量12；存放位置区间[12，15] 
};    
sizeof(SByte1);  // = 16   
  
struct SByte2   
{         
    char j;      // 长度1，偏移量为0；存放位置区间[0,1]
    double d;    // 长度8，偏移量8；存放位置区间[8,15]  
    int a;       // 长度4，偏移量16；存放位置区间[16,19]
};    
sizeof(SByte2);  // = 24，为了凑成8的倍数，填充20~23  
//可以通过#pragma pack(n)来设定变量以n字节对齐方式，n=1,2,4,8,16
#pragma pack(push) //保存对齐状态   
#pragma pack(4)    //设定为4字节对齐   
class CByte   
{   
    char c;       //长度1 < 4 按1对齐；偏移量为0；存放位置区间[0,1]
    double d;     //长度8 > 4 按4对齐；偏移量为4；存放位置区间[4,11] 
    int i;        //长度4 = 4 按4对齐；偏移量为12；存放位置区间[12,15]
};   
#pragma pack(pop)  //恢复对齐状态   
sizeof(CByte); // = 16 
// 联合
union U   
{   
    int i;   
    char c;   
    double d;   
};   
sizeof(U); // = Max(sizeof(i), sizeof(c), sizeof(d)) = sizeof(d) = 8

空类的大小是多少，如果是派生类呢

为何空类的大小不是0呢？
为了确保两个不同对象的地址不同，必须如此。
类的实例化是在内存中分配一块地址，每个实例在内存中都有独一无二的二地址。同样，空类也会实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化后就有独一无二的地址了。所以，空类的sizeof为1，而不是0.

class A{ virtual void f(){} }; //4 具有虚函数表的地址
class B:public A{} //4 具有虚函数的类sizeof都是4

class A{}; //1 A是空类，其大小为1
class B:public virtual A{}; //4 

class Father1{}; class Father2{}; //1 1
class Child:Father1, Father2{}; //1 多重继承的空类的大小也是1

何时共享虚函数地址表：
如果派生类继承的第一个是基类，且该基类定义了虚函数地址表，则派生类就共享该表首址占用的存储单元。对于除前述情形以外的其他任何情形，派生类在处理完所有基类或虚基类后，根据派生类是否建立了虚函数地址表，确定是否为该表首址分配存储单元。

class X{}; //sizeof(X):1
class Y : public virtual X {}; //sizeof(Y):4
class Z : public virtual X {}; //sizeof(Z):4
class A : public virtual Y {}; //sizeof(A):8
class B : public Y, public Z{}; //sizeof(B):8
class C : public virtual Y, public virtual Z {}; //sizeof(C):12
class D : public virtual C{}; //sizeof(D):16

C语言是怎么进行函数调用的

eip是指令指针，即指向下一条即将执行的指令的地址；
ebp为基址指针，常用来指向栈底；
esp为栈指针，常用来指向栈顶。
假设函数A调用函数B，我们称A函数为”调用者”,B函数为“被调用者”则函数调用过程可以这么描述：
(1)先将调用者(A)的堆栈的基址(ebp)入栈，以保存之前任务的信息。
(2)然后将调用者(A)的栈顶指针(esp)的值赋给ebp，作为新的基址(即被调用者B的栈底)。
(3)然后在这个基址(被调用者B的栈底)上开辟(一般用sub指令)相应的空间用作被调用者B的栈空间。
…执行 B函数的主体机器指令段…
(4)函数B返回后，从当前栈帧的ebp即恢复为调用者A的栈顶(esp)，使栈顶恢复函数B被调用前的位置;然后调用者A再从恢复后的栈顶可弹出之前的ebp值(可以这么做是因为这个值在函数调用前一步被压入堆栈)。这样，ebp和esp就都恢复了调用函数B前的位置，也就是栈恢复函数B调用前的状态。

每一个函数调用都会分配函数栈，在栈内进行函数执行过程。调用前，先把返回地址压栈，然后把当前函数的esp指针压栈。
参数压栈顺序：从右到左

C++如何处理返回值
生成一个临时变量，把它的引用作为函数参数传入函数内。
C++中拷贝赋值函数的形参能否进行值传递
不能。如果是这种情况下，调用拷贝构造函数的时候，首先要将实参传递给形参，这个传递的时候又要调用拷贝构造函数。。如此循环，无法完成拷贝，栈也会满。

Hash函数

哈希的过程中需要使用哈希函数进行计算。
哈希函数是一种映射关系，根据数据的关键词 key ，通过一定的函数关系，计算出该元素存储位置的函数。表示为：address = H [key]
几种常见的哈希函数（散列函数）构造方法
直接定址法
取关键字或关键字的某个线性函数值为散列地址。
即 H(key) = key 或 H(key) = akey + b，其中a和b为常数
*除留余数法** 取关键字被某个不大于散列表长度 m 的数 p 求余，得到的作为散列地址。
即 H(key) = key % p, p < m。
数字分析法
当关键字的位数大于地址的位数，对关键字的各位分布进行分析，选出分布均匀的任意几位作为散列地址
仅适用于所有关键字都已知的情况下，根据实际应用确定要选取的部分，尽量避免发生冲突。
平方取中法
先计算出关键字值的平方，然后取平方值中间几位作为散列地址。
随机分布的关键字，得到的散列地址也是随机分布的。
折叠法（叠加法）
将关键字分为位数相同的几部分，然后取这几部分的叠加和（舍去进位）作为散列地址。
用于关键字位数较多，并且关键字中每一位上数字分布大致均匀。
随机数法
选择一个随机函数，把关键字的随机函数值作为它的哈希值。
通常当关键字的长度不等时用这种方法。
当关键字是整数类型时就可以用除留余数法；如果关键字是小数类型，选择随机数法会比较好。

哈希冲突的解决

加载因子：hash表中已经存储的关键字个数，与可以散列位置的比值，
表示Hsah表中元素的填满的程度.若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但:冲突的机会加大了.反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了.冲突的机会越大,则查找的成本越高.反之,查找的成本越小.因而,查找时间就越小.
选用哈希函数计算哈希值时，可能不同的 key 会得到相同的结果，一个地址怎么存放多个数据呢？这就是冲突。
1、开放地址法（前提是散列表的长度大于等于所要存放的元素）
发生哈希冲突后，按照某一次序找到下一个空闲的单元，把冲突的元素放入。
线性探查法
从发生冲突的单元开始探查，依次查看下一个单元是否为空，如果到了最后一个单元还是空，那么再从表首依次判断。如此执行直到碰到了空闲的单元或者已经探查完所有单元。
平方探查法
从发生冲突的单元加上1^2,2^2,3^2,…,n^2，直到遇到空闲的单元
双散列函数探查法
定义两个散列函数，分别为s1和s2，s1的算法和前面一致，s2取一个1～m-1之间并和m互为素数的数。s2作为步长。
更适合于造表前无法确定表长的情况；平均查找长度较短；适合结点规模较大时
2、链地址法
将哈希值相同的元素构成一个链表，head放在散列表中。一般链表长度超过了8就转为红黑树，长度少于6个就变为链表。缺点：指针需要额外的空间
3、再哈希法
同时构造多个不同的哈希函数，Hi = RHi(key) i= 1,2,3 … k;
当H1 = RH1(key) 发生冲突时，再用H2 = RH2(key) 进行计算，直到冲突不再产生，这种方法不易产生聚集，但是增加了计算时间。缺点：每次冲突都要重新散列，计算时间增加

设计模式（一）：工厂模式

工厂模式的两个最重要的功能：
定义创建对象的接口，封装了对象的创建；使得具体化类的工作延迟到了子类中。
对于工厂模式，为了使其能更好的解决多种情况的问题，将其分为三类：简单工厂模式（Simple Factory），工厂方法模式（Factory Method），抽象工厂模式（Abstract Factory）。
简单工厂模式（Simple Factory）

简单设计模式存在的目的很简单：定义一个用于创建对象的接口。
缺点：对修改不封闭，新增加产品要修改工厂。

#include 
using namespace std;
enum PRODUCTTYPE {SFJ,XSL,NAS};
class soapBase
{
  public:
  virtual ~soapBase(){};
  virtual void show() = 0;
};
 
class SFJSoap:public soapBase
{
  public:
  void show() {cout<<"SFJ Soap!"<<endl;}
};
 
class XSLSoap:public soapBase
{
  public:
  void show() {cout<<"XSL Soap!"<<endl;}
};
 
class NASSoap:public soapBase
{
  public:
  void show() {cout<<"NAS Soap!"<<endl;}
};
 
class Factory
{
  public:
  soapBase * creatSoap(PRODUCTTYPE type)
  {
    switch(type)
    {
      case SFJ: 
        return new SFJSoap();
        break;
      case XSL:
        return new XSLSoap();
        break;
      case NAS:
        return new NASSoap();
        break;
      default:break;
    }
    
  }
};
 
int main()
{
  Factory factory;
  soapBase* pSoap1 = factory.creatSoap(SFJ);
  pSoap1->show();
  soapBase* pSoap2 = factory.creatSoap(XSL);
  pSoap2->show();
  soapBase* pSoap3 = factory.creatSoap(NAS);
  pSoap3->show();
  delete pSoap1;
  delete pSoap2;
  delete pSoap3;
  return 0;
}

工厂模式（Factory Method）

工厂方法模式的应用并不是只是为了封装对象的创建，而是要把对象的创建放到子类中实现：Factory中只是提供了对象创建的接口，其实现将放在Factory的子类ConcreteFactory中进行
缺点：每增加一种产品，就需要增加一个对象的工厂。

#include 
using namespace std;
enum SOAPTYPE {SFJ,XSL,NAS};
 
class soapBase
{
  public:
  virtual ~soapBase(){};
  virtual void show() = 0;
};
 
class SFJSoap:public soapBase
{
  public:
  void show() {cout<<"SFJ Soap!"<<endl;}
};
 
class XSLSoap:public soapBase
{
  public:
  void show() {cout<<"XSL Soap!"<<endl;}
};
 
class NASSoap:public soapBase
{
  public:
  void show() {cout<<"NAS Soap!"<<endl;}
};
 
class FactoryBase
{
  public:
  virtual soapBase * creatSoap() = 0;
};
 
class SFJFactory:public FactoryBase
{
  public:
  soapBase * creatSoap()
  {
    return new SFJSoap();
  }
};
 
class XSLFactory:public FactoryBase
{
  public:
  soapBase * creatSoap()
  {
    return new XSLSoap();
  }
};
 
class NASFactory:public FactoryBase
{
  public:
  soapBase * creatSoap()
  {
    return new NASSoap();
  }
};
 
int main()
{
  SFJFactory factory1;
  soapBase* pSoap1 = factory1.creatSoap();
  pSoap1->show();
  XSLFactory factory2;
  soapBase* pSoap2 = factory2.creatSoap();
  pSoap2->show();
  NASFactory factory3;
  soapBase* pSoap3 = factory3.creatSoap();
  pSoap3->show();
  delete pSoap1;
  delete pSoap2;
  delete pSoap3;
  return 0;
}

抽象工厂模式（Abstract Factory）

抽象工厂模式：给客户端提供一个接口，可以创建多个产品族中的产品对象，而且使用抽象工厂模式还要满足一下条件：
1)系统中有多个产品族，而系统一次只可能消费其中一族产品。
2)同属于同一个产品族的产品以其使用。

Eg：搞两个厂房，一个生产低档的牙膏和肥皂，一个生产高档的牙膏和肥皂。比如，厂房一生产中华牙膏、娜爱斯肥皂，厂房二生产黑人牙膏和舒肤佳牙膏

#include 
using namespace std;
enum SOAPTYPE {SFJ,XSL,NAS};
enum TOOTHTYPE {HR,ZH};
 
class SoapBase
{
  public:
  virtual ~SoapBase(){};
  virtual void show() = 0;
};
 
class SFJSoap:public SoapBase
{
  public:
  void show() {cout<<"SFJ Soap!"<<endl;}
};
 
class NASSoap:public SoapBase
{
  public:
  void show() {cout<<"NAS Soap!"<<endl;}
};
 
class ToothBase
{
  public:
  virtual ~ToothBase(){};
  virtual void show() = 0;
};
 
class HRTooth:public ToothBase
{
  public:
  void show() {cout<<"Hei ren Toothpaste!"<<endl;}
};
 
class ChinaTooth:public ToothBase
{
  public:
  void show() {cout<<"China Toothpaste!"<<endl;}
};
 
class FactoryBase
{
  public:
  virtual SoapBase * creatSoap() = 0;
  virtual ToothBase * creatToothpaste() = 0;
};
 
class FactoryA :public FactoryBase
{
  public:
  SoapBase * creatSoap()
  {
    return new SFJSoap();
  }
  
  ToothBase * creatToothpaste()
  {
    return new HRTooth();
  }
};
 
class FactoryB :public FactoryBase
{
  public:
  SoapBase * creatSoap()
  {
    return new NASSoap();
  }
  
  ToothBase * creatToothpaste()
  {
    return new ChinaTooth();
  }
};
 
 
int main()
{
  FactoryA factory1;
  FactoryB factory2;
  SoapBase *pSoap1 = NULL;
  ToothBase *pToothpaste1 = NULL;
  pSoap1 = factory1.creatSoap();
  pToothpaste1 = factory1.creatToothpaste();
  pSoap1->show();
  pToothpaste1->show();
  
  SoapBase *pSoap2 = NULL;
  ToothBase *pToothpaste2 = NULL;
  pSoap2 = factory2.creatSoap();
  pToothpaste2 = factory2.creatToothpaste();
  pSoap2->show();
  pToothpaste2->show();
  
  delete pSoap1;
  delete pSoap2;
  delete pToothpaste1;
  delete pToothpaste2;
  
  return 0;
}

设计模式（二）：单例模式

单例模式主要解决一个全局使用的类频繁的创建和销毁的问题。单例模式下可以确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
单例模式有三个要素：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。
单例的实现主要是通过以下两个步骤：
将该类的构造方法定义为私有方法，这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例；
在该类内提供一个静态方法，当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。

懒汉：
懒汉式的特点是延迟加载，比如配置文件，在第一次用到类实例的时候才会去实例化；
懒汉加载，如果并发访问：使用锁机制，防止多次访问,可以这样，第一次判断为空不加锁，若为空，再进行加锁判断是否为空，若为空则生成对象。在访问量较小时，采用懒汉实现。这是以时间换空间。
饿汉：
饿汉式的特点是一开始就加载了，在单例类定义的时候就进行实例化。
由于要进行线程同步，所以在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。

//懒汉式 第一次用到类的实例的时候才回去实例化
class singleton
{
private:
    singleton(){} //构造函数私有
    static singleton* _instance;  
public:
    static singleton* Get_instance()
    {
        if(_instance == NULL){  //判断是否第一次调用
           Lock();
           if(_instance == NULL){
              _instance = new singleton();
           }
           UnLock();
        }
        return _instance;
    }
};

//饿汉式 单例类定义的时候就进行实例化
class singleton  
  {  
  private:  
      singleton(){}  //私有构造函数  
  public:  
      static singleton* Get_instance()  
      {  
          static singleton _instance;  
          return &_instance;  
      }  
  };

应用场景：
Windows的Task Manager（任务管理器）就是很典型的单例模式，你不能同时打开两个任务管理器。Windows的回收站也是同理。
应用程序的日志应用，一般都可以用单例模式实现，只能有一个实例去操作文件。
读取配置文件，读取的配置项是公有的，一个地方读取了所有地方都能用，没有必要所有的地方都能读取一遍配置。
数据库连接池，多线程的线程池。

刷题汇总（三）leetcode 精选50题 C++答案总结

2019-09-25T17:49:22.000Z

题目来源

腾讯精选练习（50 题）

PDF版 code （提取码：0wxr ）

1、两数相加

给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* res = new ListNode(0);
        ListNode* head = res;
        int flag = 0;
        while(l1 || l2){
            int x = l1?l1->val:0;
            int y = l2?l2->val:0;
            head->next = new ListNode((x+y+flag)%10);
            flag = x+y+flag>9?1:0;
            if(l1) l1= l1->next;
            if(l2) l2 = l2->next;
            head = head->next;                         
        }
        if(flag) head->next = new ListNode(1);
        return res->next;
    }
};

2、寻找两个有序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。
请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
你可以假设 nums1 和 nums2 不会同时为空。

示例 1:
nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0
示例 2:
nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size();
        int n = nums2.size();
        if(m > n) return findMedianSortedArrays(nums2, nums1); //保证nums1更短
        int lMax1,rMin1,lMax2,rMin2,c1,c2,low=0,high=2*m;
        while(low <= high){
            c1 = (low + high)/2;
            c2 = m + n - c1;
            lMax1 = c1==0? INT_MIN:nums1[(c1-1)/2];
            rMin1 = c1==2*m? INT_MAX:nums1[c1/2];
            lMax2 = c2==0? INT_MIN:nums2[(c2-1)/2];
            rMin2 = c2==2*n? INT_MAX:nums2[c2/2];
            if(lMax1 > rMin2) high=c1-1;
            else if(lMax2 > rMin1) low=c1+1;
            else break;
        }
        return (max(lMax1,lMax2)+min(rMin1,rMin2))/2.0;
    }
};

3、最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。

输入: “cbbd”
输出: “bb”

class Solution {
public:
    // 时间复杂度：O(n^2)，空间复杂度：O(1)
    string longestPalindrome(string s) {
        int start=0, len=0;
        for(int i=0;i
            int tmp = max(getsub(i,i,s),getsub(i,i+1,s));
            if(tmp>len){
                len = tmp;
                start = i-(len-1)/2;
            }
        }
        return s.substr(start,len);
    }

    int getsub(int i,int j,string s){
        while(i>=0 && j
            i--;
            j++;
        }
        return j-i-1;
    }
};

4、整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

输入: 123
输出: 321

输入: -123
输出: -321

输入: 120
输出: 21

注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−2^31, 2^31 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

class Solution {
public:
    int reverse(int x) {
        int res=0;
        while(x!=0){
            if(res>INT_MAX/10 || res==INT_MAX/10 && x%10>7) return 0;
            if(res10 || res==INT_MIN/10 && x%10<-8) return 0;
            res=res*10+x%10;
            x=x/10;
        }
        return res;
    }
};

5、字符串转换整数 (atoi)

请你来实现一个 atoi 函数，使其能将字符串转换成整数。
首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。
当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。
该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。
注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。
在任何情况下，若函数不能进行有效的转换时，请返回 0。
说明：
假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−2^31, 2^31 − 1]。如果数值超过这个范围，请返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。

输入: “42”
输出: 42

输入: “ -42”
输出: -42
解释: 第一个非空白字符为 ‘-‘, 它是一个负号。
我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。

输入: “4193 with words”
输出: 4193
解释: 转换截止于数字 ‘3’ ，因为它的下一个字符不为数字。

输入: “words and 987”
输出: 0
解释: 第一个非空字符是 ‘w’, 但它不是数字或正、负号。
因此无法执行有效的转换。

输入: “-91283472332”
输出: -2147483648
解释: 数字 “-91283472332” 超过 32 位有符号整数范围。
因此返回 INT_MIN (−231) 。

class Solution {
public:
    int myAtoi(string str) {
        int res = 0;
        bool flag = true;
        int i = 0;
        while(i' ') i++;
        if(str[i] == '+'){flag=true;i++;}
        else if(str[i] == '-'){flag=false;i++;}
        for(;i
            if(str[i]<='9' && str[i]>='0'){
                if(res>INT_MAX/10 || res==INT_MAX/10&&(str[i]-'0')>7) return flag?INT_MAX:INT_MIN;
                res = res*10+(str[i]-'0');
            }
            else return flag?res:-res;
        }
        return flag?res:-res;
    }
};

6、回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

输入: 121
输出: true

输入: -121
输出: false
解释: 从左向右读, 为 -121 。从右向左读, 为 121- 。因此它不是一个回文数。

输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

class Solution {
public:
    bool isPalindrome(int x) {
        if(x<0) return false;
        string s = to_string(x);
        int l=0,r=s.size()-1;
        while(l<=r){
            if(s[l] == s[r]){
                l++;
                r--;
            }
            else return false;
        }
        return true;
    }
};

7、盛最多水的容器

给定 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器，且 n 的值至少为 2。
图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

输入: [1,8,6,2,5,4,8,3,7]
输出: 49

class Solution {
public:
    int maxArea(vector<int>& height) {
        int smax = 0;
        int i = 0,j = height.size()-1;
        while(i<=j){
            int s = min(height[i],height[j])*(j-i);
            if(s > smax) smax = s;
            if(height[i]
            else j--;
        }
        return smax;
    }
};

8、最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。

输入: [“flower”,”flow”,”flight”]
输出: “fl”

输入: [“dog”,”racecar”,”car”]
输出: “”
解释: 输入不存在公共前缀。

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        int imin = 0; //最短的字符串
        for(int i=0;i
            if(strs[i].size()
        }
        string res;
        for(int i=0;i
            for(int j=0;j
                if(strs[j][i] != strs[imin][i]) return res;
            }
            res.push_back(strs[imin][i]);
        }
        return res;
    }
};

9、三数之和

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

class Solution {
public:
    vector<vector<int> > threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int> > res;
        int add;
        for(int i=0;i
            if(i>0 && nums[i] == nums[i-1]) continue; //i和前面一样，跳过
            if((add = nums[i])>0) break;
            
            int l = i+1, r = nums.size()-1; //双指针，找和为add
            while(l
                if(nums[l]+nums[r]+add>0) r--;
                else if(nums[l]+nums[r]+add<0) l++;
                else {
                    res.push_back({add,nums[l],nums[r]});
                    l++;r--;
                    while(l-1]) l++;
                    while(l1]) r--;
                }
            }  
        }
        return res;
    }
};

10、最接近的三数之和

给定一个包括 n 个整数的数组 nums 和一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        int add = 0,dis = INT_MAX;
        for(int i=0;i
            int l = 0, r = nums.size()-1;
            while(l
                if(l==i) l++;
                if(r==i) r--;
                if(l>=r) break;
                int tadd = nums[i]+nums[l]+nums[r];
                int tdis = abs(tadd-target);
                if(tdis < dis){
                    add = tadd;
                    dis = tdis;
                }
                if(tadd == target) return add;
                if(tadd < target) l++;
                else r--;
            }
        }
        return add;
    }
};

11、有效的括号

给定一个只包括 ‘(‘，’)’，’{‘，’}’，’[‘，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

输入: “()”
输出: true

输入: “()[]{}”
输出: true

输入: “(]”
输出: false

输入: “([)]”
输出: false

输入: “{[]}”
输出: true

class Solution {
public:
    bool isValid(string s) {
        stack<char> stack;
        for(int i=0;i
            if(!stack.empty() && check(stack.top(),s[i])) stack.pop();
            else stack.push(s[i]);
        }
        return stack.empty();
    }
    
    bool check(char a,char b) {
        if(a=='('&&b==')' || a=='['&&b==']' || a=='{'&&b=='}') return true;
        return false;
    }
};

12、合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4···c

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* res = new ListNode(0);
        ListNode* head = res;
        while(l1 && l2){
            if(l1->val < l2->val){
                head->next = l1;
                l1 = l1->next;
            }
            else{
                head->next = l2;
                l2 = l2->next;
            }
            head = head->next;
        }
        head->next = l1?l1:l2;
        return res->next;
    }
};

13、合并K个排序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

输入:
[
1->4->5,
1->3->4,
2->6
]输出: 1->1->2->3->4->4->5->6

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector& lists) {
        ListNode* list = NULL;
        for(int i=0;i
            list = merge2Lists(list,lists[i]);
        }
        return list; 
    }
    
    ListNode* merge2Lists(ListNode* l1, ListNode* l2) {
        ListNode* res = new ListNode(0);
        ListNode* head = res;
        while(l1 && l2){
            if(l1->val < l2->val){
                head->next = l1;
                l1 = l1->next;
            }
            else{
                head->next = l2;
                l2 = l2->next;
            }
            head = head->next;
        }
        head->next = l1?l1:l2;
        return res->next;
    }
};

14、删除排序数组中的重复项

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。

给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.empty()) return 0;
        int i = 0; //双指针
        for(int j=1;j
            if(nums[i] != nums[j]){
                i++;
                nums[i]=nums[j];
            }
        }
        return i+1;
    }
};

15、搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

class Solution {
public:
    int search(vector<int>& nums, int target) {
        return helper(nums,target,0,nums.size()-1);
    }
    
    int helper(vector<int>& nums, int target, int i, int j) {
        if(i>j) return -1;
        int mid = (i+j)/2;
        if(nums[mid] == target) return mid;
        if(nums[mid] < nums[j]){ //7 8 1 2 3 4  旋转点在左，右顺序
            if(nums[mid] < target && target <= nums[j]) return helper(nums,target,mid+1,j);
            else return helper(nums,target,i,mid-1);
        }
        else{ //3 4 7 8 1 2  旋转点在右，左顺序
            if(nums[mid] > target && target >= nums[i]) return helper(nums,target,i,mid-1);
            else return helper(nums,target,mid+1,j);
        }
    }
};

16、字符串相乘

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

输入: num1 = “2”, num2 = “3”
输出: “6”

输入: num1 = “123”, num2 = “456”
输出: “56088”
说明：

num1 和 num2 的长度小于110。
num1 和 num2 只包含数字 0-9。
num1 和 num2 均不以零开头，除非是数字 0 本身。
不能使用任何标准库的大数类型（比如 BigInteger）或直接将输入转换为整数来处理。

class Solution {
public:
    string multiply(string num1, string num2) {
        int len1 = num1.size(),len2 = num2.size();
        string res(len1+len2,'0');
        for(int i=len1-1;i>=0;i--){
            for(int j=len2-1;j>=0;j--){
                int t = (res[i+j+1]-'0')+(num1[i]-'0')*(num2[j]-'0');
                res[i+j+1] = t%10 +'0';
                res[i+j] += t/10;
            }
        }
        for(int i=0;i
            if(res[i] != '0') return res.substr(i);
        }
        return "0";
    }
};

17、全排列

给定一个没有重复数字的序列，返回其所有可能的全排列。

输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        backtrack(nums,res,0);
        return res;
    }
    void backtrack(vector<int> &nums,vector<vector<int>> &res,int n) {
        if(n == nums.size()-1) res.push_back(nums);
        else{
            for(int i=n;i
                swap(nums[i],nums[n]);
                backtrack(nums,res,n+1);
                swap(nums[i],nums[n]);
            }
        }
    }
    void swap(int &i ,int &j) {
        int t = i; i = j; j = t;
    }
};

//剑指offer 27题 字典序输出有重复字符串序列的全排列
/*
 问题转换为先固定第一个字符，求剩余字符的排列
 再把第一个字符与后面每一个字符交换，并同样递归获得首位后面的字符串组合
 a b b c:
 a+f(bbc),b+f(abc),c+f(cbba); 遍历出所有可能出现在第一个位置的字符
 f(bbc)=b+f(bc),c+f(bb);
 f(bc)=b+f(c),c+f(b);
 f(c)=c;
class Solution {
public:
    vector Permutation(string str) {
        vector res;
        helper(str,res,0);
        sort(res.begin(),res.end());
        return res;
    }
    void helper(string s, vector &res, int n) {
        if(n == s.size()-1){ //终止条件
            if(find(res.begin(),res.end(),s) == res.end()) res.push_back(s);
        }
        else{
            for(int i=n;i
                swap(s[i],s[n]);
                helper(s,n+1);
                swap(s[i],s[n]);
            }
        }
    }
    void swap(char &i ,char &j) {
        char t = i; i = j; j = t;
    }
};

*/

18、最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int max = nums[0];
        int add = 0;
        for(int i=0;i
            add += nums[i];
            if(add > max) max = add;
            if(add < 0) add = 0;
        }
        return max;
    }
};

19、螺旋矩阵

给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

输入:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]输出: [1,2,3,6,9,8,7,4,5]

输入:
[
[1, 2, 3, 4],
[5, 6, 7, 8],
[9,10,11,12]
]输出: [1,2,3,4,8,12,11,10,9,5,6,7]

class Solution {
public:
    /*
       m   n
     i 1 2 3
       4 5 6
     j 7 8 9
    */
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if(matrix.empty() || matrix[0].empty()) return {};
        vector<int> res;
        int i=0,j=matrix.size()-1,m=0,n=matrix[0].size()-1;
        while(i<=j && m<=n){
            for(int k=m;k<=n;k++) res.push_back(matrix[i][k]);
            i++;
            if(i>j) break;
            for(int k=i;k<=j;k++) res.push_back(matrix[k][n]);
            n--;
            if(m>n) break;
            for(int k=n;k>=m;k--) res.push_back(matrix[j][k]);
            j--;
            if(i>j) break;
            for(int k=j;k>=i;k--) res.push_back(matrix[k][m]);
            m++;
        }
        return res;
    }
};

20、螺旋矩阵 II

给定一个正整数 n，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

输入: 3
输出:
[
[ 1, 2, 3 ],
[ 8, 9, 4 ],
[ 7, 6, 5 ]
]

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> arr(n,vector<int>(n,0));
        int c = 1,k = 0;
        while(c<=n*n){
            for(int i=k;i
            for(int i=k+1;i-1]=c++;
            for(int i=n-k-2;i>=k;i--) arr[n-k-1][i]=c++;
            for(int i=n-k-2;i>=k+1;i--) arr[i][k]=c++;
            k++;
        }
        return arr;
    }
};

21、旋转链表

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL

输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL
解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) { //1->2->3->4->5->NULL, k = 2
        if(k==0 || !head) return head;
        int len = getlen(head);
        if((k = k%len)==0) return head;
        ListNode* pre = head; //1->2->3->NULL
        ListNode* cur = pre;
        for(int i=0;i-1;i++){
            cur = cur->next;
        }
        ListNode* last = cur->next; //4->5->NULL
        cur->next = NULL;
        cur = last;
        while(cur->next){
            cur = cur->next;
        }
        cur->next = head; //4->5->1->2->3->NULL
        return last; 
    }
    
    int getlen(ListNode* head){
        int res = 0;
        ListNode* root = head;
        while(root){
            res++;root = root->next;
        }
        return res;
    }
};

22、不同路径

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
问总共有多少条不同的路径？
例如，上图是一个7 x 3 的网格。有多少可能的路径？
说明：m 和 n 的值均不超过 100。

输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。

向右 -> 向右 -> 向下
向右 -> 向下 -> 向右
向下 -> 向右 -> 向右

输入: m = 7, n = 3
输出: 28

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m,vector<int>(n,0));//m*n零矩阵
        for(int i=0;i
            for(int j=0;j
                if(i==0 || j==0) dp[i][j]=1;
                else dp[i][j] = dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

23、爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。

输入： 2
输出： 2
解释：有两种方法可以爬到楼顶。

1 阶 + 1 阶
2 阶

输入： 3
输出： 3
解释：有三种方法可以爬到楼顶。

1 阶 + 1 阶 + 1 阶
1 阶 + 2 阶

2 阶 + 1 阶

//当n=45时，结果已经超出了返回值类型int有效范围无法通过，不知道测试怎么回事，同剑指offer 8，剑指可通过
class Solution {
public:
    int climbStairs(int n) {
        int i=1,j=1;
        while(n > 0){
            int t = i;
            i = j;
            j = t+j;
            n--;
        }
        return i;
    }
};

24、子集

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。

输入: nums = [1,2,3]
输出:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res;
        int l = 1 << nums.size();
        for(int i=0;i
            vector<int> tmp;
            for(int j=0;j
                if(i&(1<
            }
            res.push_back(tmp);
        }
        return res;
    }
};

25、合并两个有序数组

给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。
说明:
初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
输出: [1,2,2,3,5,6]

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int i=m-1,j=n-1,cur=n+m-1;
        while(i>=0 && j>=0){
            if(nums1[i]
                nums1[cur]=nums2[j];
                j--;
            }else{
                nums1[cur]=nums1[i];
                i--;
            }
            cur--;
        }
        while(i>=0){
            nums1[cur]=nums1[i];i--;cur--;
        }
        while(j>=0){
            nums1[cur]=nums2[j];j--;cur--;
        } 
    }
};

26、格雷编码

格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。
给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。格雷编码序列必须以 0 开头。

输入: 2
输出: [0,1,3,2]
解释:
00 - 0
01 - 1
11 - 3
10 - 2

对于给定的 n，其格雷编码序列并不唯一。
例如，[0,2,3,1] 也是一个有效的格雷编码序列。
00 - 0
10 - 2
11 - 3
01 - 1

输入: 0
输出: [0]
解释: 我们定义格雷编码序列必须以 0 开头。
给定编码总位数为 n 的格雷编码序列，其长度为 2n。当 n = 0 时，长度为 20 = 1。
因此，当 n = 0 时，其格雷编码序列为 [0]。

class Solution {
public:
/*n: 0   1   2   3
     0   0  00  000
         1  10  100
                010
            01  110
            11
                001
                101
                011
                111
*/
    vector<int> grayCode(int n) {
        if(n==0) return {0};
        vector<int> res{0,1};
        for(int i=1;i
            for(int j=0;j
                res[j]*=2; //末位加0
            }
            for(int j=res.size()-1;j>=0;j--){
                res.push_back(res[j]+1); //末位加1
            }
        }
        return res;
    }
};

27、二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

给定二叉树 [3,9,20,null,null,15,7]，
3
/
9 20
/
15 7
返回它的最大深度 3 。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(!root) return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

28、买卖股票的最佳时机

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
注意你不能在买入股票前卖出股票。

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int max = 0;
        for(int i=0;i
            for(int j=i+1;j
                if(prices[j]-prices[i]>max){
                    max = prices[j]-prices[i];
                }
            }   
        }
        return max;
    }
};

29、买卖股票的最佳时机 II

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.empty()) return 0;
        int max = 0;
        for(int i=0;i-1;i++){
            if(prices[i+1]>prices[i]) max += prices[i+1]-prices[i];
        }
        return max;
    }
};

30、二叉树中的最大路径和

给定一个非空二叉树，返回其最大路径和。
本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。

输入: [1,2,3]
1
/
2 3
输出: 6

输入: [-10,9,20,null,null,15,7]
-10
/
9 20
/
15 7
输出: 42

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int res = INT_MIN;
    int maxPathSum(TreeNode* root) {
        submax(root);
        return res;
    }
    int submax(TreeNode* root) { //从root向下走的最长距离
        if(!root) return 0;
        int l = max(0,submax(root->left));
        int r = max(0,submax(root->right));
        if(root->val+l+r > res) res=root->val+l+r;
        return root->val+max(l,r);
    }
};

31、只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？

输入: [2,2,1]
输出: 1

输入: [4,1,2,1,2]
输出: 4

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int res = 0;
        for(int i=0;i
            res ^= nums[i];
        }
        return res;
    }
};

32、环形链表

给定一个链表，判断链表中是否有环。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(!head) return false;
        ListNode *fast = head;
        ListNode *slow = head;
        while(fast->next && fast->next->next){
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast) return true;
        }
        return false;
    }
};

33、环形链表 II

给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(!head) return NULL;
        bool loop = false;
        ListNode* slow = head;
        ListNode* fast = head;
        while(fast->next&&fast->next->next){
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast){
                loop = true;
                break;
            }
        }
        if(loop){
            ListNode* res = head;
            while(res!=slow){
                res = res->next;
                slow = slow->next;
            }
            return res;
        }
        return NULL;
    }
};

34、LRU缓存机制

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作：获取数据 get 和写入数据 put 。
获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

进阶:
你是否可以在 O(1) 时间复杂度内完成这两种操作？

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // 返回 1
cache.put(3, 3); // 该操作会使得密钥 2 作废
cache.get(2); // 返回 -1 (未找到)
cache.put(4, 4); // 该操作会使得密钥 1 作废
cache.get(1); // 返回 -1 (未找到)
cache.get(3); // 返回 3
cache.get(4); // 返回 4

class LRUCache {
public:
    LRUCache(int capacity) {
        _cap = capacity;
    }
    
    int get(int key) {
        auto iter = _map.find(key);
        if(iter == _map.end()) return -1;
        int res = iter->second->second;
        _list.erase(iter->second);
        _list.push_front(make_pair(key,res));
        _map[key] = _list.begin();
        return res;
    }
    
    void put(int key, int value) {
        auto iter = _map.find(key);
        if(iter != _map.end()) _list.erase(iter->second);
        _list.push_front(make_pair(key,value));
        _map[key] = _list.begin();
        if(_list.size()>_cap){
            int t = _list.back().first;
            _map.erase(t);
            _list.pop_back();
        }   
    }
private:
    unordered_map<int,listint,int>>::iterator> _map;
    listint,int>> _list;
    int _cap;
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

35、排序链表

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

输入: 4->2->1->3
输出: 1->2->3->4

输入: -1->5->3->4->0
输出: -1->0->3->4->5

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(!head || !head->next) return head;
        ListNode* slow = head;
        ListNode* fast = head;
        while(fast->next && fast->next->next){
            slow = slow->next;
            fast = fast->next->next;
        }
        ListNode* bk = slow->next;
        slow->next = NULL;
        ListNode* l1 = sortList(head);
        ListNode* l2 = sortList(bk);
        //合并有序链表
        ListNode* res = new ListNode(0);
        ListNode* h = res;
        while(l1 && l2){
            if(l1->val>l2->val){
                h->next = l2;
                l2 = l2->next;
            }
            else{
                h->next = l1;
                l1 = l1->next;
            }
            h = h->next;
        }
        h->next = l1?l1:l2;
        return res->next;
    }
};

36、最小栈

设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) – 将元素 x 推入栈中。
pop() – 删除栈顶的元素。
top() – 获取栈顶元素。
getMin() – 检索栈中的最小元素。

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); –> 返回 -3.
minStack.pop();
minStack.top(); –> 返回 0.
minStack.getMin(); –> 返回 -2.

class MinStack {
public:
    /** initialize your data structure here. */
    MinStack() {
        
    }
    
    void push(int x) {
        if(smin.empty() || x <= smin.top()) smin.push(x);
        s.push(x);
    }
    
    void pop() {
        if(smin.top() == s.top()) smin.pop();
        s.pop();
    }
    
    int top() {
        return s.top();
    }
    
    int getMin() {
        return smin.top();
    }
private:
    stack<int> s;
    stack<int> smin;
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

37、相交链表

编写一个程序，找到两个单链表相交的起始节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int len1 = getlen(headA);
        int len2 = getlen(headB);
        int step = abs(len1-len2);
        while(step!=0){
            if(len1>len2) headA = headA->next;
            else headB = headB->next;
            step--;
        }
        while(headA){
            if(headA == headB) return headA;
            headA = headA->next;
            headB = headB->next;
        }
        return NULL;
    }
    int getlen(ListNode* l) {
        int res = 0;
        while(l){
            res++;
            l = l->next;
        }
        return res;
    }
};

38、求众数

给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在众数。

输入: [3,2,3]
输出: 3

输入: [2,2,1,1,1,2,2]
输出: 2

class Solution {
public:
    /*
     如果重复的次数超过一半的话，一定有相邻的数字相同这种情况的
     对数组同时去掉两个不同的数字，到最后剩下的一个数就是该数字
    */
    int majorityElement(vector<int>& nums) {
        int res = nums[0];
        int count = 1;
        for(int i=1;i
            if(nums[i] == res) count++;
            else{
                count--;
                if(count == 0){
                    res = nums[i];
                    count = 1;
                }
            }
        }
        return res;
    }
};

39、反转链表

反转一个单链表。

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* res = NULL;
        while(head){
            ListNode* tmp = new ListNode(head->val);
            tmp->next = res;
            res = tmp;
            head = head->next;
        }
        return res;
    }
};

40、数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        priority_queue <int,vector<int>,greater<int>> q;
        for(int i=0;i
            if(q.size()==k){
                if(q.top()
                    q.pop();
                    q.push(nums[i]);
                }
            }
            else{
                q.push(nums[i]);
            }
        }
        return q.top();
    }
};

41、存在重复元素

给定一个整数数组，判断是否存在重复元素。
如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。

输入: [1,2,3,1]
输出: true

输入: [1,2,3,4]
输出: false

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_map<int,int> m;
        for(int i=0;i
            if(m.find(nums[i]) != m.end()) return true;
            else m[nums[i]] = 1;
        }
        return false;
    }
};

42、二叉搜索树中第K小的元素

给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int res;
    int cur = 0;
    int kthSmallest(TreeNode* root, int k) {
        midfor(root, k);
        return res;
    }
    void midfor(TreeNode* root, int k) {
        if(!root) return;
        if(cur != k) midfor(root->left,k);
        cur++;
        if(cur == k){
            res = root->val;
        }
        if(cur != k) midfor(root->right,k);
    }
};

43、2的幂

给定一个整数，编写一个函数来判断它是否是 2 的幂次方。

class Solution {
public:
    bool isPowerOfTwo(int n) {
        if(n<=0) return false;
        while(n!=1){
            double t = n/2.0;
            if(!isint(t)) return false;
            n /= 2;
        }
        return true;
    }
    bool isint(double d){
        return abs(d-(int)d)<1e-5;
    }
};

44、二叉搜索树的最近公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉搜索树中。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* res;
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        search(root,p,q);
        return res;
    }
    void search(TreeNode* root, TreeNode* p, TreeNode* q) {
        if((root->val-p->val)*(root->val-q->val)<=0) res = root;
        else if(p->val > root->val && q->val > root->val) search(root->right,p,q);
        else search(root->left,p,q);
    }
};

45、二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root) return NULL;
        if(root == p || root == q) return root;
        TreeNode* l = lowestCommonAncestor(root->left,p,q);
        TreeNode* r = lowestCommonAncestor(root->right,p,q);
        if(l&&r) return root;
        if(l) return l;
        if(r) return r;
        return NULL;
    }
};

46、删除链表中的节点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
现有一个链表 – head = [4,5,1,9]，它可以表示为:

输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
    }
};

47、除自身以外数组的乘积

给定长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。

输入: [1,2,3,4]
输出: [24,12,8,6]
说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int l=1, r=1;
        vector<int> res(nums.size());
        for(int i=0;i
            res[i] = l;
            l *= nums[i];
        }
        for(int i=nums.size()-1;i>=0;i--){
            res[i] *= r;
            r *= nums[i];
        }
        return res;
    }
};

48、Nim 游戏

你和你的朋友，两个人一起玩 Nim 游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。拿掉最后一块石头的人就是获胜者。你作为先手。
你们是聪明人，每一步都是最优解。编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。

输入: 4
输出: false
解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛；
因为无论你拿走 1 块、2 块还是 3 块石头，最后一块石头总是会被你的朋友拿走。

class Solution {
public:
    bool canWinNim(int n) {
        return !(n%4==0);
    }
};

49、反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

输入：[“h”,”e”,”l”,”l”,”o”]
输出：[“o”,”l”,”l”,”e”,”h”]

输入：[“H”,”a”,”n”,”n”,”a”,”h”]
输出：[“h”,”a”,”n”,”n”,”a”,”H”]·

class Solution {
public:
    void reverseString(vector<char>& s) {
        int i=0,j=s.size()-1;
        while(i
            swap(s[i],s[j]);
            i++;j--;
        }
    }
};

50、反转字符串中的单词 III

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

输入: “Let’s take LeetCode contest”
输出: “s’teL ekat edoCteeL tsetnoc”
注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

class Solution {
public:
    string reverseWords(string s) {
        string res;
        stack<char> stack;
        for(int i=0;i
            if(s[i] == ' '){
                while(!stack.empty()){
                    res.push_back(stack.top());
                    stack.pop();
                }
                res.push_back(' ');
            }
            else{
                stack.push(s[i]);
            }
        }
        while(!stack.empty()){
            res.push_back(stack.top());
            stack.pop();
        }
        return res;
    }
};

常见算法的c++实现总结

2019-08-07T03:11:48.000Z

一、七大排序算法

#include 
#include 
using namespace std;

void swap(int &a, int &b) {
int tmp;
tmp = a;
a = b;
b = tmp;
}

//一、插入排序
//1.1 直接插入排序  时间复杂度O(n^2)  空间复杂度O(1)  稳定
//构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
void insert_sort(vector<int> &nums) {
for (int i = 0; i < nums.size(); i++){
for (int j = i; j > 0; j--){
if (nums[j] < nums[j - 1])
swap(nums[j], nums[j - 1]);
}
}
}

//1.2 希尔排序  时间复杂度O(n^1.3)  空间复杂度O(1)  不稳定
//按照一定步长分成子序列进行排序，然后逐步递减步长来完成最终排序。增量 d = 1时， 就是插入排序
void shell_sort(vector<int> &nums) {
for (int gap = nums.size() >> 1; gap>0; gap >>= 1){
for (int i = gap; i < nums.size(); i++)
{
int tmp = nums[i];
int j = i - gap;
for (; j >= 0 && nums[j] > tmp; j -= gap){
nums[j + gap] = nums[j];
}
nums[j + gap] = tmp;
}
}
}

//二、选择排序
//2.1 选择排序  时间复杂度O(n^2)  空间复杂度O(1)  不稳定
//先进行第一轮循环比较相邻两项，找到最小值得下标，将最小值与第一项交换，然后重复排序剩余部分。
void select_sort(vector<int> &nums) {
for (int i = 0; i < nums.size(); i++) {
int min = i;
for (int j = i + 1; j < nums.size(); j++){
if (nums[j] < nums[min])
min = j;
}
swap(nums[i], nums[min]);
}
}

//2.2 堆排序  时间复杂度O(nlgn)  空间复杂度O(1)  稳定
//构造一个最大堆（完全二叉树），父结点大于左右子结点，然后取出根结点（最大值）与最后一个结点交换，重复调整剩余的结点成最大堆，得到有序的序列。
void max_heapify(vector<int> &nums, int l, int r) {
int curr = l;
int child = curr * 2 + 1;
while (child < r) {
if (child + 1 < r &&nums[child] < nums[child + 1])
child++;
if (nums[curr] < nums[child]) {
swap(nums[curr], nums[child]);
curr = child;
child = 2 * curr + 1;
}
else
break;
}
}

void heap_sort(vector<int> &nums) {
for (int i = nums.size() / 2 - 1; i >= 0; i--)
{
max_heapify(nums, i, nums.size());
}
for (int i = nums.size() - 1; i > 0; i--)
{
swap(nums[0], nums[i]);
max_heapify(nums, 0, i);
}
}


//三、交换排序
//3.1 冒泡排序  时间复杂度O(n^2)  空间复杂度O(1)  稳定
//每次通过两两比较交换位置，选出剩余无序序列里最大（小）的数据元素放到队尾。
void bubble_sort(vector<int> &nums) {
for (int i = 0; i < nums.size() - 1; i++){
for (int j = 0; j < nums.size() - i - 1; j++){
if (nums[j] > nums[j + 1])
swap(nums[j], nums[j + 1]);
}
}
}

//3.2快速排序  时间复杂度O(nlgn)  空间复杂度O(1)  不稳定
//将无序序列分隔成两部分，左边均比右边小，分别对这两部分进行排序
void quick_sort(vector<int> &nums, int l, int r) {
if (l < r) {
int i = l, j = r;
while (i < j) {
while (nums[j] >= nums[l] && i < j)
j--;
while (nums[i] <= nums[l] && i < j)
i++;
swap(nums[i], nums[j]);
}
swap(nums[l], nums[i]);
quick_sort(nums, l, i-1);
quick_sort(nums, i + 1, r);
}
}

//四、归并排序  时间复杂度O(nlgn)  空间复杂度O(n)  稳定
//将序列递归分成单位为1的小序列，然后两两合并排序，最终得到有序的序列。
void  merge_sort(vector<int> &nums, int l, int r, vector<int> &tmp) {
if (l >= r) return;
int m = (l + r) / 2;
merge_sort(nums, l, m, tmp);
merge_sort(nums, m + 1, r, tmp);
int i = l, j = m + 1, index = l;
while (i <= m &&  j <= r) {
if (nums[i] < nums[j])
tmp[index++] = nums[i++];
else
tmp[index++] = nums[j++];
}
while (i <= m)
tmp[index++] = nums[i++];
while (j <= r)
tmp[index++] = nums[j++];
for (int i = l; i <= r; i++)
nums[i] = tmp[i];
}


int main() {

cout << "原始数列：8, 3, 1, 4, 11, 2, 2, 1, 5, 2, 7, 9, 1, 6 " << endl;
cout << "请选择排序算法：" << endl;
cout << "1 插入排序，2 希尔排序，3 选择排序，4 堆排序，5 冒泡排序，6 快速排序，7 归并排序" << endl;

int index;
while (cin >> index){
vector<int> nums{ 8, 3, 1, 4, 11, 2, 2, 1, 5, 2, 7, 9, 1, 6 };
int len = nums.size();
switch (index){
case 1:
insert_sort(nums); //插入排序
break;
case 2:
shell_sort(nums); //希尔排序
break;
case 3:
select_sort(nums); //选择排序
break;
case 4:
heap_sort(nums); //堆排序
break;
case 5:
bubble_sort(nums); //冒泡排序
break;
case 6:
quick_sort(nums, 0, len - 1); //快速排序
break;
case 7:
vector<int> tmp(len);
merge_sort(nums, 0, len - 1, tmp); //归并排序
break;
}

for (int i = 0; i
cout << nums[i] << ' ';
}
cout << endl;
}
return 0;
}

二、大整数计算

#include 
#include 
using namespace std;

//大数相加
string addstr(string s1, string s2) {
if (s1.size()>s2.size()) return addstr(s2, s1); //s1短
s1.insert(s1.begin(), s2.size() - s1.size(), '0');
string res(s2.size() + 1, '0');
for (int i = s2.size() - 1; i >= 0; i--){
int t = (s1[i] - '0') + (s2[i] - '0') + (res[i + 1] - '0');
res[i + 1] = t % 10 + '0';
res[i] = t / 10 + '0';
}
if (res[0] == '0') return res.substr(1);
return res;
}
//大数相乘
string multiply(string num1, string num2) {
int len1 = num1.size(), len2 = num2.size();
string res(len1 + len2, '0');
for (int i = len1 - 1; i >= 0; i--){
for (int j = len2 - 1; j >= 0; j--){
int t = (res[i + j + 1] - '0') + (num1[i] - '0')*(num2[j] - '0');
res[i + j + 1] = t % 10 + '0';
res[i + j] += t / 10;
}
}
for (int i = 0; i
if (res[i] != '0') return res.substr(i);
}
return "0";
}

int main(){
string s1, s2;
cin >> s1 >> s2;

cout << "相加:" << addstr(s1,s2) << endl;
cout << "相乘:" << multiply(s1, s2) << endl;

return 0;
}

三、编辑距离问题

题目地址

编辑距离，又称Levenshtein距离，是指两个子串之间，由一个转成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。请尝试写出一个算法来计算两个字符串的编辑距离。

1、当min(i,j)=0时，f(i,j)=max(i,j)，一个字符串的长度为0，编辑距离是另一个字符串的长度
2、当a[i]=b[j]时，f(i,j)=f(i−1,j−1)，比如xxcz和xyz的距离=xxc和xy的距离
3、否则，lev(i,j)为如下三项的最小值：
f(i−1,j)+1(在a中删除ai);
f(i,j−1)+1(在a中插入bj);
f(i−1,j−1)+1(在a中把ai替换bj)，

#include 
#include 
#include 
#include 
using namespace std;

//编辑距离
int EditDistance(string s1, string s2) {
int m = s1.size(), n = s2.size();
vector<vector<int>> arr(m + 1, vector<int>(n + 1));
for (int i = 0; i <= m; i++){
for (int j = 0; j <= n; j++){
if (i == 0 || j == 0){
arr[i][j] = max(i, j);
}
else if(s1[i-1] == s2[j-1]){ //注意
arr[i][j] = arr[i - 1][j - 1];
}
else{
arr[i][j] = min(arr[i - 1][j] + 1, min(arr[i][j-1] + 1, arr[i - 1][j - 1] + 1));
}
}
}
return arr[m][n];
}

int main(){
string s1, s2;
cin >> s1 >> s2;

cout << EditDistance(s1, s2) << endl;

return 0;
}

时间复杂度O（nm)，空间复杂度O（nm）

四、kmp算法

题目地址

给定两个字符串str和match，长度分别为N和M。实现一个算法，如果字符串str中含有子串match，则返回match在str中的开始位置，不含有则返回-1

#include 
#include 
#include 
using namespace std;

// 暴力匹配算法
int ViolentMatch(string s, string p) {
int i = 0, j = 0, slen = s.size(), plen = p.size();
while (i < slen && j < plen)
{
if (s[i] == p[j]){
i++;
j++;
}
else{
i = i - j + 1;
j = 0;
}
}

if (j == plen) return i - j;
else return -1;
}

// KMP算法
int KMP(string s, string p, vector<int>next) {
int i = 0, j = 0, slen = s.size(), plen = p.size();
while (i < slen && j < plen)
{
if (j == -1 || s[i] == p[j]){
i++;
j++;
}
else{
j = next[j];
}
}

if (j == plen) return i - j;
else return -1;
}

// MultiKMP算法
vector<int> MultiKMP(string s, string p, vector<int>next) {
vector<int> res;
int i = 0, j = 0, slen = s.size(), plen = p.size();
while (i < slen)
{
if (j == -1 || s[i] == p[j]){
i++;
j++;
}
else{
j = next[j];
}
if (j == plen){
res.push_back(i - j);
j = 0;
}
}
return res;
}

// MultiKMP2算法
vector<int> MultiKMP2(string s, string p, vector<int>next) {
vector<int> res;
int i = 0, j = 0, slen = s.size(), plen = p.size();
while (i < slen)
{
if (j == -1 || s[i] == p[j]){
i++;
j++;
}
else{
j = next[j];
}
if (j == plen){
res.push_back(i - j);
i = i - j + 1;
j = 0;
}
}
return res;
}

vector<int> GetNext(string p)
{
vector<int> next(p.size());
next[0] = -1;
int k = -1, j = 0;
while (j < p.size() - 1)
{
//p[k]表示前缀，p[j]表示后缀  
if (k == -1 || p[j] == p[k]){
++k;
++j;
if (p[j] != p[k]) next[j] = k;
else next[j] = next[k];
}
else{
k = next[k];
}
}
return next;
}

void printvec(vector<int> vec) {
if (!vec.empty()){
for (int i = 0; i < vec.size(); i++){
cout << vec[i] << ' ';
}
cout << endl;
}
else{
cout << -1 << endl;
}
}

int main(){
string s1, s2;
cin >> s1 >> s2;

vector<int> next = GetNext(s2);

// 暴力匹配第一次出现位置
cout << ViolentMatch(s1, s2) << endl;

// KMP匹配第一次出现位置
cout << KMP(s1, s2, next) << endl;

// KMP匹配无重复所有出现位置
vector<int> res = MultiKMP(s1, s2, next);
printvec(res);

// KMP匹配可重复所有出现位置
vector<int> res2 = MultiKMP2(s1, s2, next);
printvec(res2);

return 0;
}

算法详解时间复杂度为O(m + n)
扩展：BM算法、Sunday算法。

五、dijkstra算法

迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。它解决的是带权重的有向图上单源最短路径问题。

#include 
#include 

using namespace std;

const int maxn = 100; // 最大顶点数
int map[maxn][maxn]; // 邻接矩阵存图
int dis[maxn]; // dist[i]表示距离源点的最短距离
int vis[maxn];  // vis[i] = 1表示已加入集合S
int path[maxn]; // 记录路径
int n, m, r;

void dijk(int s) // 求顶点s到其他顶点的最短路径
{
//初始化
memset(path, -1, sizeof(path));
/*INF使用0x3f3f3f3f的好处：
* 1：满足无穷大加一个有穷的数依然是无穷大（在DijKstra算法松弛操作中避免了溢出而出现负数）
* 2：满足无穷大加无穷大依然是无穷大（两个0x3f3f3f3f相加并未溢出）
* 3：初始化时，由于每一个字节为0x3f，所以只需要memset（buf，0x3f,sizeof(buf)）即可
*/
memset(dis, 0x3f, sizeof(dis)); //初始化为无穷大
memset(vis, 0, sizeof(vis));
dis[s] = 0; //自身到自身的距离为0
while (1)
{
int k = 0;
for (int j = 1; j <= n; j++)
{
if (!vis[j] && dis[j]//找未收录顶点中dis值最小的
k = j; //这里第一次找到的是起点
}
if (!k) return; //没有未收录的点，则返回
vis[k] = 1;
//松弛操作
for (int j = 1; j <= n; j++)
{
//第一次循环只有起点的邻接点距离被更新，每次都更新新找到的点的邻接点
if (dis[j]>dis[k] + map[k][j])
{
dis[j] = dis[k] + map[k][j];
path[j] = k;//路径被改变，重新记录前驱，最短路是由最短路+某一条固定路组成，所以前驱是有效的
}
}
}
}

void printPath(int x)
{
if (x == -1) 
return;
//递归
printPath(path[x]);
if (x == r) 
cout << x;
else 
cout << " -> " << x;
}


/*问题描述：
* 输入n,m和r，代表n个节点，m条边，出发点r，然后是m行输入，每行有x,y,z，代表x到y的路距离为z。
* 问题：从r出发到各点的最短路径。
*/

int main()
{
cin >> n >> m >> r;

memset(map, 0x3f, sizeof(map));

int x, y, z;
for (int i = 1; i <= m; i++)
{
cin >> x >> y >> z;
if (map[x][y] > z){ // 防止1->1的环
map[x][y] = z;
//map[y][x] = z; // 无向图
}
}

dijk(r);

for (int i = 1; i <= n; i++){
printPath(i);
cout<< " "<< dis[i];
cout<< endl;
}

return 0;
}

算法详解算法详解时间复杂度为O( n^2)

六、0/1背包问题

0/1背包问题:满足总重量<=背包重量限制，使价值最大。

#include 
#include 
#include 

using namespace std;

int ZeroOnePack(int m, int s, vector<int> weight, vector<int> value) {
// F[i ][ v] 表示  前i件物品恰放入一个容量恰为v的背包可以获得的最大价值
vector<vector<int> > F(m + 1, vector<int>(s + 1));
for (int i = 0; i <= s; i++) {
F[0][i] = 0; //如果要求恰好装满背包，除了F[0]为0，其余F[1 .. s]均设为-INF
}
for (int i = 1; i <= m; i++){
for (int j = 0; j <= s; j++){
if (j >= weight[i - 1])
F[i][j] = max(F[i - 1][j], F[i - 1][j - weight[i - 1]] + value[i - 1]);
else
F[i][j] = F[i - 1][j];
}
}

//打印哪几样物品能够获得最大价值
vector<bool> isAdd(m,false);
int j = s;
for (int i = m; i >= 1; i--){
if (F[i][j] != F[i - 1][j]){
isAdd[i - 1] = true;
j = j - weight[i - 1];
}
}
for (int i = 0; i < m; i++){
cout << isAdd[i] << " ";
}
cout << endl;

return F[m][s];
}

int main() {
int m, s; // 物品种类m，背包总空间t，求最大价值
cin >> m >> s;

vector<int> weight;
vector<int> value;
for (int i = 0; i < m; i++){
int t1, t2;
cin >> t1 >> t2;
weight.push_back(t1);
value.push_back(t2);
}

int res = ZeroOnePack(m, s, weight, value);
cout << res << endl;

return 0;
}

算法详解

刷题汇总（二）剑指Offer 66题 C++答案总结

2019-08-01T03:32:27.000Z

题目来源

剑指Offer 66题

PDF版 code （提取码：0wxr ）

1、二维数组中的查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

/* 
 3 4 5
 4 5 6
 6 7 8
 从左下角开始查找，当target比左下角数字大时，右移；小时，上移
*/
class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int rows = array.size(), cols = array[0].size();
        int i = rows - 1, j = 0;
        while(i>=0&&j
            if(array[i][j] == target) return true;
            else if(array[i][j] > target) i--;
            else j++;
        }
        return false;
    }
};

2、替换空格

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

/*
 从前往后替换，后面的字符要多次移动，效率低下
 从后往前，先计算需要多少空间，每个字符只移动一次，效率更高
 例如：a b c
 从后往前，当前第i位为'c'（非空格），前有n个空格，则i+2*n位为c
 当前第i位为' '（空格）,前有n个空格，则i+2*n位为%，i+2*n+1位为2，i+2*n+2位为0
*/
class Solution {
public:
void replaceSpace(char *str,int length) {
        int sum = 0;
        for(int i=0;i
            if(str[i] == ' ') sum++;
        }
        for(int i=length-1;i>=0;i--){
            if(str[i] != ' ') str[i + 2*sum] = str[i];
            else{
                sum--;
                str[i + 2*sum] = '%';
                str[i + 2*sum + 1] = '2';
                str[i + 2*sum + 2] = '0';
            }
        }
    }
};
`

3、从尾到头打印链表

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> res;
        stack<int> stack;
        while(head){
            stack.push(head->val);
            head = head->next;
        }
        while(!stack.empty()){
            res.push_back(stack.top());
            stack.pop();
        }
        return res;
    }
};

4、重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

/*
 前序遍历序列{1,2,4,7,3,5,6,8} 1是根元素
 中序遍历序列{4,7,2,1,5,3,8,6} 1之前4,7,2是左子树中序，之后5,3,8,6是右子树中序
 前序中1后的3个是左子树前序，之后是右子树前序
 问题转换为根元素已知，求左子树和右子树的重建二叉树，进行递归
*/
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        return buildtree(pre,vin,0,pre.size()-1,0,vin.size()-1);
    }
    
    TreeNode* buildtree(vector<int> pre,vector<int> vin,int pl,int pr,int vl,int vr) {
        if(pl > pr || vl > vr) return NULL;
        TreeNode* root = new TreeNode(pre[pl]);
        int i;
        for(i=vl;i<=vr;i++){
            if(vin[i] == pre[pl]) break;
        }
        int num = i - vl; //左子树个数
        root->left =  buildtree(pre,vin,pl+1,pl+num,vl,vl+num-1);
        root->right =  buildtree(pre,vin,pl+num+1,pr,vl+num+1,vr);
        return root;
    }
};

5、用两个栈实现队列

用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。

/*
 用两个栈实现一个队列的功能
 入队：将元素进栈A
 出队：判断栈B是否为空，如果为空，则将栈A中所有元素pop，并push进栈B，栈B出栈；
 如果不为空，栈B直接出栈。
 
 用两个队列实现一个栈的功能
 入栈：将元素进队列A
 出栈：判断队列A中元素的个数是否为1，如果等于1，则出队列，否则将队列A中的元素依次出队列并放入队列B，直到队列A中的元素留下一个，然后队列A出队列，再把队列B中的元素出队列以此放入队列A中。
*/
class Solution
{
public:
    void push(int node) {
        stack1.push(node);
    }

    int pop() {
        while(!stack1.empty()){
            stack2.push(stack1.top());
            stack1.pop();
        }
        int res = stack2.top();
        stack2.pop();
        while(!stack2.empty()){
            stack1.push(stack2.top());
            stack2.pop();
        }
        return res;
    }
private:
    stack<int> stack1;
    stack<int> stack2;
};

6、旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.size() == 0) return 0;
        int i = 0, j = rotateArray.size()-1;
        while(i < j){
            int mid = (i + j)/2;
            if(rotateArray[mid] > rotateArray[j]){ 
                i = mid + 1; //3 4 7 8 1 2  旋转点在右，左顺序
            }
            else if(rotateArray[mid] < rotateArray[j]){ 
                j = mid; //7 8 1 2 3 4  旋转点在左，右顺序
            }
            else{ //1 0 1 1 1  或  1 1 1 0 1 顺序部分为常数
                i ++; //或 j --;
            }
        }
        return rotateArray[i];
    }
};

7、斐波那契数列

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39

class Solution {
public:
    int Fibonacci(int n) { //0 1 1 2 3 5 …,使用动态规划
        int i = 0, j = 1;
        while(n>0){
            int tmp = j;
            j = i+j;
            i = tmp;
            n--;
        }
        return i;
    }
};

8、跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

/*
 最后一步跳1，有f(n-1)种情况
 最后一步跳2，有f(n-2)种情况
 共f(n)=f(n-1)+f(n-2)，1 1 2 3 5（斐波那契数列）使用动态规划
*/
class Solution {
public:
    int jumpFloor(int number) {
        int i = 1, j = 1;
        while(number>0){
            int tmp = j;
            j = i + j;
            i = tmp;
            number--;
        }
        return i;
    }
};

9、变态跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

//f(n) = f(1) + f(2) + f(3) +...+ f(n-1) + 1
//1 2 4 8 ...
class Solution {
public:
    int jumpFloorII(int number) {
        vector<int> step;
        while(number>0){
            int sum = 0;
            for(int i=0;i
                sum += step[i];
            }
            step.push_back(sum+1); 
            number--;
        }
        return step.back();
    }
};
/*
class Solution {
public:
    int jumpFloorII(int number) {
        int res = 1;
        for(int i=1;i
            res += jumpFloorII(i);
        }
        return res;
    }
};
*/

10、矩形覆盖

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

/*
|    | | |   f(n-1)
|    | | |
 
— —    | |   f(n-2)
— —    | |
f(n) = f(n-1) + f(n-2),1 2 3 5 8…,动态规划
*/
class Solution {
public:
    int rectCover(int number) {
        if(number == 0) return 0;
        int i = 1, j = 1;
        while(number>0){
            int tmp = j;
            j = i + j;
            i = tmp;
            number--;
        }
        return i;
    }
};

11、二进制中1的个数

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

/*
 将n与n-1相与会把n的最右边的1变为0，比如
 1100&1011 = 1000
*/
class Solution {
public:
     int  NumberOf1(int n) {
         int res=0;
         while(n!=0){
             res++;
             n = n&(n-1);
         }
         return res;
     }
};

/*
 #include 
*/
class Solution {
public:
     int  NumberOf1(int n) {
         bitset<32>a(n); //32位的2进制
         return a.count(); //返回1的个数
     }
};

12、数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

/*
 10^1101 = 10^0001*10^0100*10^1000，即base*1 * base^2 * base^4 * …
 通过&1和>>1来逐位读取1101
*/
class Solution {
public:
    double Power(double base, int exponent) {
        double res = 1;
        int e = abs(exponent);
        while(e!=0){
            if(e&1 == 1){
                res *= base;
            }
            base *= base;
            e = e>>1;
        }
        return exponent>0?res:1/res;
    }
};

13、调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

/*
 要想保证原有次序，则只能顺次移动或相邻交换。
 1.i从左向右遍历，找到第一个偶数。
 2.j从i+1开始向后找，找到第一个奇数。
 3.将[i,...,j-1]的元素整体后移一位，将找到的奇数放入i位置
*/
class Solution {
public:
    void reOrderArray(vector<int> &array) {
        for(int i=0;i<array.size();i++){
            if(array[i]%2 == 0){
                for(int j=i+1;j<array.size();j++){
                    if(array[j]%2 == 1){
                        int tmp = array[j];
                        for(int k=j-1;k>=i;k--){
                            array[k+1] = array[k];
                        }
                        array[i] = tmp;
                        break;
                    }
                }
            }
        }
    }
};

14、链表中倒数第k个结点

输入一个链表，输出该链表中倒数第k个结点。

/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
/*
 两指针指向头结点，
 第一个指针走(k-1)步，到k节点
 两个指针同时往后移动，当第一个结点到达末尾的时候，第二个结点所在位置就是倒数第k个节点
*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if(!pListHead || k==0) return NULL;
        ListNode* node1 = pListHead;
        ListNode* node2 = pListHead;
        int i = 0;
        while(node1){
            if(i>=k){
                node2 = node2 -> next;
            }
            node1 = node1 -> next;
            i++;
        }
        return iNULL : node2;
    }
};

15、反转链表

输入一个链表，反转链表后，输出新链表的表头。

/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
/*
1 2 3 4 5
遍历链表，当前值为4时，相当于新建值为4的链表node，node->next = 前面链表反转，node即为所求
当前值为5时，相当于新建值为5的链表node，node->next = 上一步的值
*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode* res = NULL;
        while(pHead){
            ListNode* tmp = new ListNode(pHead->val);
            tmp -> next = res;
            res = tmp;
            pHead = pHead -> next;
        }
        return res;
    }
};

//原地修改
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode* res = NULL;
        while(pHead){
            ListNode* tmp = pHead->next;
            pHead->next = res;
            res = pHead;
            pHead = tmp;
        }
        return res;
    }
};

16、合并两个排序的链表

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        ListNode* res = new ListNode(0);//初始化，取几不重要
        ListNode* here = res; //标记位置
        while(pHead1 && pHead2){
            if(pHead1->val < pHead2->val){
                res -> next = pHead1;
                pHead1 = pHead1 -> next;
            }
            else{
                res -> next = pHead2;
                pHead2 = pHead2 -> next;
            }
            res = res -> next;
        }
        res -> next = pHead1 ? pHead1:pHead2;
        return here->next;
    }
};

17、树的子结构

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

/*
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) {
        if(pRoot1 && pRoot2){
            return issub(pRoot1,pRoot2)|| 
                HasSubtree(pRoot1->left,pRoot2)|| 
                HasSubtree(pRoot1->right,pRoot2);
        }
        return false;
    }
    
    bool issub(TreeNode* l1, TreeNode* l2) {
        if(l2){
            return l1&& l1->val==l2->val&& 
                issub(l1->left,l2->left)&& 
                issub(l1->right,l2->right);
        }
        return true;
    }
};

18、二叉树的镜像

操作给定的二叉树，将其变换为源二叉树的镜像。

/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if(!pRoot) return;
        TreeNode *tmp = pRoot->left;
        pRoot->left = pRoot->right;
        pRoot->right = tmp;
        Mirror(pRoot->left);
        Mirror(pRoot->right);
    }
};

19、顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

/*
   m   n
 i 1 2 3
   4 5 6
 j 7 8 9
*/
class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> res;
        int i = 0,j = matrix.size()-1,m = 0,n = matrix[0].size()-1;
        while(i<=j && m<=n){
            for(int k=m;k<=n;k++) res.push_back(matrix[i][k]);
            i++;//削首行
            if(i>j) break;
            for(int k=i;k<=j;k++) res.push_back(matrix[k][n]);
            n--;//削尾列
            if(m>n) break;
            for(int k=n;k>=m;k--) res.push_back(matrix[j][k]); 
            j--;//削尾行
            if(i>j) break;
            for(int k=j;k>=i;k--) res.push_back(matrix[k][m]);
            m++;//削首列
        }
        return res;
    }
};

20、包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

/*
 用stack1保存数据，用stack2做辅助栈保存依次入栈最小的数
 stack1:5, 4, 3, 8, 10, 11, 12, 1
 stack2:5, 4, 3,no, no, no, no, 1
 no代表此次不入栈
 入栈，如果stack1的压入比stack2压入大，stack2不压;小于等于，两栈同时压入
 出栈，如果两栈顶元素不等，stack1出，stack2不出;相等，都出
*/
class Solution {
public:
    stack<int> stack1,stack2;
    void push(int value) {
        stack1.push(value);
        if(stack2.empty()) stack2.push(value);
        else{
            if(value <= stack2.top()) stack2.push(value);
        }
    }
    void pop() {
        if(stack1.top() == stack2.top()) stack2.pop();
        stack1.pop();
    }
    int top() {
        return stack1.top();
    }
    int min() {
        return stack2.top();
    }
};

21、栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        stack<int> s;
        int k = 0,len = pushV.size();
        for(int i=0;i
            s.push(pushV[i]);
            while(k
                s.pop();
                k++;
            }
        }
        return s.empty();
    }
};

22、从上往下打印二叉树

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> res;
        queue q;
        if(root) q.push(root);
        while(!q.empty()){
            if(q.front()->left) q.push(q.front()->left);
            if(q.front()->right) q.push(q.front()->right);
            res.push_back(q.front()->val);
            q.pop();
        }
        return res;
    }
};

23、二叉搜索树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

/*
 二叉搜索树BST 左子树值都比root小，右子树值都比root大。
 去掉最后一个元素root，其他分成两段:
 前一段（左子树）小于x，后一段（右子树）大于x，且这两段（子树）都是BST的后序遍历
*/
class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        if(sequence.size()==0) return false;
        return isok(sequence,0,sequence.size()-1);
    }
    bool isok(vector<int> arr,int l,int r) {
        if(l >= r) return true;
        int i=l;
        while(i//找到满足BST的右子树开头
        for(int j=i;jif(arr[j] < arr[r]) return false; //判断剩下是否为右子树
        return isok(arr,l,i-1)&& isok(arr,i,r-1);
    } 
};

24、二叉树中和为某一值的路径

输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
    vector<vector<int> > res;
    vector<int> tmp;
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        if(root) helper(root,expectNumber);
        return res;
    }
    void helper(TreeNode* root,int n) {
        if(!root) return;
        tmp.push_back(root->val);
        if(root->val == n && !root->left && !root->right) res.push_back(tmp);
        helper(root->left,n-root->val);
        helper(root->right,n-root->val);
        tmp.pop_back();
    }
};

25、复杂链表的复制

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
/*
 复制节点，如：复制节点A得到A1，将A1插入节点A后面
 复制random，遍历链表，A1->random = A->random->next;
 将链表拆分成原链表和复制后的链表
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(!pHead) return NULL;
        
        RandomListNode* cur = pHead;//从头复制节点 A->B->C 变成A->A'->B->B'->C->C'
        while(cur){
            RandomListNode* copynode = new RandomListNode(cur->label);
            copynode -> next = cur -> next;
            cur->next = copynode;
            cur = cur -> next -> next;
        }
        
        cur = pHead;//从头复制random,A1->random = A->random->next;
        while(cur){
            if(cur -> random) cur -> next -> random = cur -> random -> next;
            cur = cur -> next -> next;
        }
        
        cur = pHead;//从头将链表拆分成原链表和复制后的链表
        RandomListNode* res = cur -> next; //复制后的链表,标记位置
        RandomListNode* tmp;
        while(cur -> next){
            tmp = cur -> next;
            cur -> next = tmp -> next;
            cur = tmp;
        }
        return res;
    }
};

26、二叉搜索树与双向链表

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

/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
//树的线索化，利用了二叉树结点中的空指针，让它们分别指向本结点的前驱或者后继
    TreeNode* head = NULL;
    TreeNode* res = NULL;
    TreeNode* Convert(TreeNode* pRootOfTree) {
        if(!pRootOfTree) return NULL;
        helper(pRootOfTree);
        return res;
    }
    void helper(TreeNode* root) {
        if(!root) return;
        helper(root->left);
        if(!head){ //中序遍历第一个，即树的左下角
            head = root;
            res = root;
        }
        else{
            head -> right = root;
            root -> left = head;
            head = root;
        }
        helper(root->right);
    } 
};

27、字符串的排列

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

/*
 问题转换为先固定第一个字符，求剩余字符的排列
 再把第一个字符与后面每一个字符交换，并同样递归获得首位后面的字符串组合
 a b b c:
 a+f(bbc),b+f(abc),c+f(abb); 遍历出所有可能出现在第一个位置的字符
 f(bbc)=b+f(bc),b+f(bc),c+f(bb);
 f(bc)=b+f(c),c+f(b);
 f(c)=c;
*/
class Solution {
public:
    vector<string> res;
    vector<string> Permutation(string str) {
        if(str.empty()) return res;
        help(str,0);
        sort(res.begin(),res.end());
        return res;
    }
    void help(string s,int n) {
        if(n==s.size()-1){
            if(find(res.begin(),res.end(),s)==res.end()) res.push_back(s);
        }
        else{
            for(int i=0;i
                swap(s[i],s[n]);
                help(s,n+1);
                swap(s[n],s[i]);
            }
        }
    }
};

28、数组中出现次数超过一半的数字

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

/*
 如果重复的次数超过一半的话，一定有相邻的数字相同这种情况的
 对数组同时去掉两个不同的数字，到最后剩下的一个数就是该数字
*/
class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        if(numbers.empty()) return 0;
        int res = numbers[0];
        int times = 0;
        for(int i=0;i
            if(numbers[i] == res) times++;
            else{
                times--;
                if(times == 0){
                    res = numbers[i];
                    times = 1;
                }
            }
        }
        //check
        times = 0;
        for(int i=0;i
            if(numbers[i] == res) times++;
        }
        return times>numbers.size()/2?res:0;
    }
};
/* 涉及到快排sort，其时间复杂度为O(NlogN)并非最优
class Solution {
public:
    int MoreThanHalfNum_Solution(vector numbers)
    {
        // 因为用到了sort，时间复杂度O(NlogN)，并非最优
        if(numbers.empty()) return 0;
         
        sort(numbers.begin(),numbers.end());
        int middle = numbers[numbers.size()/2];//假设存在众数may
        
        //check
        int count=0; // 出现次数
        for(int i=0;i
        {
            if(numbers[i]==middle) ++count;
        }
         
        return (count>numbers.size()/2) ? middle :  0;
    }
};
*/

29、最小的k个数

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

/*
 基于堆排序算法，构建最大堆。时间复杂度为O(nlogk)
 用最大堆保存这k个数，每次只和堆顶比，如果比堆顶小，删除堆顶，新数入堆
 如果用快速排序，时间复杂度为O(nlogn)；
*/
class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> res;
        priority_queue<int> q; 
        //priority_queue,greater> q;最小堆
        if(input.empty() || k>input.size() || k==0) return res;
        for(int i=0;i
            if(i
            else{
                if(input[i] < q.top()){
                    q.pop();
                    q.push(input[i]);
                }
            }
        }
        while(!q.empty()){
            res.push_back(q.top());
            q.pop();
        }
        return res;
    }
};

30、连续子数组的最大和

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
        int res = array[0];
        int max = 0;
        for(int i=0;i<array.size();i++){
            max += array[i];
            if(max > res) res = max;
            if(max < 0) max = 0;
        }
        return res;
    }
};

31、整数中1出现的次数

求出1~~13的整数中1出现的次数,并算出100~~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。

/*
 n=10917 1~10917
 所有数里在个位的1的数量：
 前面为0~1090，个位后无，排列组合共1*1091种情况；前面为1091时，个位后为1。总共：1*1091+1(m=1，情况3)
 所有数里在十位的1的数量：
 前面为0~108，十位后为0~9，排列组合共10*109种情况；前面为109时，十位后为0~7。总共：10*109+8(m=8，情况2)
 所有数里在百位的1的数量：
 前面为0~9，百位后为0~99，排列组合共100*10种情况；前面为10时，百位后为0~99。总共：100*10+100(m=100，情况3)
 所有数里在千位的1的数量：
 前面为0~0，千位后为0~999，排列组合共1000*1种情况；前面为1时，千位后没有满足的。总共：1000*1+0(m=0，情况1)
 所有数里在万位的1的数量：
 前面为无，万位后为0~917。总共：1000*0+918(m=918，情况2)
 
 精髓在于后面部分m值分三种情况：
 ①当前位为0时，m=0；②当前位为1时，m=后面值+1；③当前位为2~9时，m=10^(后面的位数)
*/
class Solution {
public:
    int NumberOf1Between1AndN_Solution(int n) {
        if(n == 0) return 0;
        int res = 0;
        int base = 1,t = n,m;
        while(t!=0){
            if(t%10 == 0) m = 0;
            else if(t%10 == 1) m = n-t*base+1;
            else m = base;
            t/=10; res+=base*t+m; base*=10; 
        }
        return res;
    }
};

32、把数组排成最小的数

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

class Solution {
public:
    //sort中的比较函数compare要声明为静态成员函数或全局函数，不能作为普通成员函数
    string PrintMinNumber(vector<int> numbers) {
        string res = "";
        sort(numbers.begin(),numbers.end(),cmp);
        for(int i=0;i
            res += to_string(numbers[i]); 
        }
        return res;
    }
    static bool cmp(int &i,int &j) {
        string si = to_string(i);
        string sj = to_string(j);
        return si+sj// 2 23和23 2
    }
};

33、丑数

把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

/*
 如果p是丑数，那么p=2^x * 3^y * 5^z, 且x,y,z需满足是前面的丑数
 初始x=y=z=1， 2^x、3^y、5^z最小的数2^x加进结果，x在结果中位置后移一位
*/
class Solution {
public:
    int GetUglyNumber_Solution(int index) {
        if(index < 7) return index;
        vector<int> res(index);
        res[0] = 1;
        int x=0, y=0, z=0;
        for(int i=1;i
            res[i] = min(min(res[x]*2,res[y]*3),res[z]*5);
            if(res[i] == res[x]*2) x++;
            if(res[i] == res[y]*3) y++;
            if(res[i] == res[z]*5) z++;
        }
        return res[index-1];
    }
};

34、第一个只出现一次的字符

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.

class Solution {
public:
    int FirstNotRepeatingChar(string str) {
        //字符在计算机中以ASCII码的形式存储，当字符作为数组下标时，其表示的下标值为该字符的ASCII码的十进制值
        //0-9:  48-57， A-Z:  65-90， a-z:  97-122
        map<char,int> map; //map支持int，char，string
        for(int i=0;i
            map[str[i]]++;
        }
        for(int i=0;i
            if(map[str[i]] == 1) return i;
        }
        return -1;
    }
};

35、数组中的逆序对

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。即输出P%1000000007

输入描述:
题目保证输入的数组中没有的相同的数字
数据范围：
对于%50的数据,size<=10^4
对于%75的数据,size<=10^5
对于%100的数据,size<=2*10^5

示例:
输入   1,2,3,4,5,6,7,0
输出   7

/*
 先把数组分割成子数组，先统计出子数组内部的逆序对的数目，然后再统计出两个相邻子数组之间的逆序对的数目
 在统计逆序对的过程中，还需要对数组进行排序,每一次比较的时候
 都把较大的数字从后面往前复制到一个辅助数组中，确保辅助数组copy中的数字是递增排序的
 交换copy和data:在每次的操作中，当前传入函数中第一项，比较的结果都存放到第二项中,需要交叉保证下一次是排序的
 输入[7,5,6,4], 最后的结果copy[4,5,6,7], data[5,7,4,6]
*/
class Solution {
public:
    int InversePairs(vector<int> data) {
        if(data.size()==0) return 0;
        vector<int>copy(data); //使用data初始化copy
        long long P = InversePairsCore(data,copy,0,data.size()-1);
        return P%1000000007;
    }
    long long InversePairsCore(vector<int> &data,vector<int> ©,int l,int r) {
        if(l == r){
            copy[l] = data[l]; return 0;
        }
        int mid = (l+r)/2;
        long long left = InversePairsCore(copy,data,l,mid);
        long long right = InversePairsCore(copy,data,mid+1,r);
        int i = mid,j = r;
        long long count = 0; //需要long long,int的话最后一个例子会溢出测试不通过
        int cur = r;
        while(i>=l && j>=mid+1){
            if(data[i]>data[j]){ //3 8,4 6  8>6
                count += j-mid;
                copy[cur--] = data[i]; i--;
            }
            else{
                copy[cur--] = data[j]; j--;
            }
        }
        while(i>=l){
            copy[cur--] = data[i]; i--;
        }
        while(j>=mid+1){
            copy[cur--] = data[j]; j--;
        }
        return left+right+count;
    }
};

36、两个链表的第一个公共节点

输入两个链表，找出它们的第一个公共结点。

/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        //找出2个链表的长度，然后让长的先走两个链表的长度差，然后再一起走
        int len1 = getlen(pHead1);
        int len2 = getlen(pHead2);
        int dis = len1-len2>0?len1-len2:len2-len1;
        while(dis!=0){
            if(len1>len2) pHead1 = pHead1->next;
            else pHead2 = pHead2->next;
            dis--;
        }
        while(pHead1){
            if(pHead1 == pHead2) return pHead1;
            pHead1 = pHead1->next;
            pHead2 = pHead2->next;
        }
        return NULL;
    }
    
    int getlen(ListNode* p) {
        int res = 0;
        ListNode* root = p;
        while(root){
            res++;
            root = root->next;
        }
       return res;
    }
};

37、数字在排序数组中出现的次数

统计一个数字在排序数组中出现的次数。

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        if(data.empty()) return 0;
        int l=0,r=data.size()-1;
        while(l<=r){
            int mid = (l+r)/2;
            if(data[mid]==k){ //计数
                int res=0,i=mid;
                while(i>=l){
                    if(data[i]==k){
                        i--;
                        res++;
                    }
                    else break;
                }
                i=mid+1;
                while(i<=r){
                    if(data[i]==k){
                        i++;
                        res++;
                    }
                    else break;
                }
                return res;
            }
            else if(data[mid] > k) r=mid-1;
            else l=mid+1;
        }
        return 0;
    }
};

38、二叉树的深度

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
    int TreeDepth(TreeNode* pRoot) {
        if(!pRoot) return 0;
        return max(TreeDepth(pRoot->left),TreeDepth(pRoot->right))+1;
    }
};

39、平衡二叉树

输入一棵二叉树，判断该二叉树是否是平衡二叉树。

class Solution {
public:
    //左右子树均为平衡二叉树，且左右子树层高不超过1
    bool IsBalanced_Solution(TreeNode* pRoot) {
        if(!pRoot) return true;
        return IsBalanced_Solution(pRoot->left)
            && IsBalanced_Solution(pRoot->right)
            && abs(getlen(pRoot->left)-getlen(pRoot->right))<=1;
    }
    int getlen(TreeNode* p){
        if(!p) return 0;
        return max(getlen(p->left),getlen(p->right))+1;
    }
};

40、数组中只出现一次的数字

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

/*
 异或性质：
 交换律：a ^ b ^ c  <=> a ^ c ^ b,俩两相同的移到一起
 相同的数异或为0: n ^ n => 0
 任何数于0异或为任何数 0 ^ n => n
 
 遍历异或后，只剩下两单个的异或了，结果res的二进制至少有一位为1
 取第一个1所在的位数index，原数组分成第index位为1和为0
 相同的数肯定在一个组，两个单的在不同的组
*/
class Solution {
public:
    void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {
        int add = 0;
        for(int i=0;i
            add ^= data[i];
        }
        int index = 0;
        while((add&1)==0){
            add = add >> 1;
            index++;
        }
        for(int i=0;i
            if((data[i]>>index&1)==0) num1[0]^=data[i];
            else num2[0]^=data[i];
        }
    }
};

41、和为S的连续正数序列

小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!输出描述:
输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

class Solution {
public:
    vector<vector<int> > FindContinuousSequence(int sum) {
        vector<vector<int> > res;
        vector<int> part;
        int i = 1,j = 2;
        while(i < j){
            int count = (i+j)*(j-i+1)/2; //i~j的和
            if(count == sum){ //将i~j插入res
                part.clear();
                for(int k=i;k<=j;k++){
                    part.push_back(k);
                }
                res.push_back(part);
                i++;
            }
            else if(count < sum) j++; //右窗口右移
            else i++; //左窗口右移
            
        }
        return res;
    }
};

42、和为S的两个数字

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述:
对应每个测试案例，输出两个数，小的先输出。

class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {
        vector<int> res;
        int i = 0, j = array.size()-1;
        while(i
            if(array[i]+array[j] == sum){ //1 3 4 6,1*6<3*4,越边边乘积越小
                res.push_back(array[i]);
                res.push_back(array[j]);
                break;
            }
            else if(array[i]+array[j] > sum) j--;
            else i++;
        }
        return res;
    }
};

43、左旋转字符串

汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

class Solution {
public:
    string LeftRotateString(string str, int n) {
        if(str.empty()) return "";
        n%=str.size();
        return str.substr(n)+str.substr(0,n);
    }
};

44、翻转单词顺序列

牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

class Solution {
public:
    string ReverseSentence(string str) {
        string res;
        stack<string> stack;
        string tmp;
        for(int i=0;i
            if(str[i] == ' '){
                stack.push(tmp);
                tmp.clear();
            }
            else tmp.push_back(str[i]);
        }
        stack.push(tmp);
        while(!stack.empty()){
            res += ' ' + stack.top();
            stack.pop();
        }
        return res.erase(0,1);
    }
};

45、扑克牌顺子

LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…..LL不高兴了,他想了想,决定大\小王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何，如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

/*
 max 记录 最大值,min 记录  最小值,min ,max 都不记0
 满足条件 max - min <5;除0外没有重复的数字(牌);数组长度 为5
*/
class Solution {
public:
    bool IsContinuous( vector<int> numbers ) { // 5张牌
        if(numbers.size()!=5) return false;
        int max = -1, min = 14;
        int* flag = new int[14](); //初始化数组全为 0
        for(int i=0;i
            if(numbers[i] == 0) continue;
            int tmp = numbers[i];
            if(flag[tmp] == 1) return false; //重复
            else{
                if(tmp < min) min = tmp;
                if(tmp > max) max = tmp;
                flag[tmp] = 1;
            }
        }
        delete[] flag;
        return max-min<5;
    }
};

46、孩子们的游戏（圆圈中最后剩下的数）

每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数….这样下去….直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

class Solution {
public:
    int LastRemaining_Solution(int n, int m) {
        if (m == 0 || n == 0) return -1;
        int* flag = new int[n]();//初始化数组全为 0
        int i = -1,left = n,step = 0;
        while(left>0){
            i++; //0
            if(i == n) i = 0; //模拟环
            if(flag[i] == 1) continue; //跳过被删除的对象
            step++;
            if(step == m){
                step = 0;
                flag[i] = 1;
                left--;
            }
        }
        return i;
    }
};

47、求1+2+3+…+n

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

/*
 int Sum_Solution(int n) {
     if(n == 0) return 0;
     return n+Sum_Solution(n-1);
 }
 将此段代码改写成不使用for、while、if、else、switch、case等关键字及条件判断语句
*/
class Solution {
public:
    int Sum_Solution(int n) {
        int res = n;
        res && (res+=Sum_Solution(n-1));
        //当n==0时，只执行前面的判断，为false，然后直接返回0；
        //当n>0时，执行sum+=Sum_Solution(n-1)，实现递归计算Sum_Solution(n)
        return res;
    }
};

48、不用加减乘除做加法

写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

/*
 两数相与再左移一位，表示相加进位的值 101&111=101 左移1，1010
 两数异或，表示相加不算进位的值 101^111=010
 两者相加为和，(101&111)<<1 + 101^111 = 1100,即调用函数本身，直到进位为0
*/
class Solution {
public:
    int Add(int num1, int num2) {
        while(num2!=0){
            int tmp = num1^num2; //相加不算进位的值
            num2 = (num1&num2)<<1; //相加进位的值
            num1 = tmp;
        }
        return num1;
    }
};

49、把字符串转换成整数

将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。数值为0或者字符串不是一个合法的数值则返回0。
输入描述:
输入一个字符串,包括数字字母符号,可以为空
输出描述:
如果是合法的数值表达则返回该数字，否则返回0

输入: +2147483647 , 1a33
输出: 2147483647 , 0

/*
 字符"0123456789"的值是连续的，如果c"0123456789"范围内
 int a = c - '0'就是对应整数值
 从后往前，最后判断符号位
*/
class Solution {
public:
    int StrToInt(string str) {
        if(str.empty()) return 0;
        int res = 0,base = 1;
        for(int i = str.size()-1;i>=0;i--){
            if(str[i]>='0' && str[i]<='9'){
                res += base*(int)(str[i]-'0');
                base *= 10;
            }
            else if(str[i] == '-'){
                if(i == 0) return -res; //-123
            }
            else if(str[i] == '+'){
                if(i == 0) return res; //+123
            }
            else return 0; //1a3
        }
        return res; //123
    }
};

50、数组中重复的数字

在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

/*
 数字的范围保证在0 ~ n-1 之间，所以可以利用现有数组设置标志
 当一个数字i被访问过后，可以设置对应位上的数numbers[i] += n
 再次访问i时，发现numbers[i] >=n，直接返回i
*/
class Solution {
public:
    // Parameters:
    //        numbers:     an array of integers
    //        length:      the length of array numbers
    //        duplication: (Output) the duplicated number in the array number
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    bool duplicate(int numbers[], int length, int* duplication) {
        for(int i=0;i//2,3,1,0,2,5,3
            int cur = numbers[i];
            if(cur >= length) cur = cur-length;
            if(numbers[cur] >= length){
                *duplication = cur;
                return true;
            }
            numbers[cur] += length;
        }
        return false;
    }
};

51、构建乘积数组

给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…A[i-1]A[i+1]…A[n-1]。不能使用除法。

/*
 1                             第一项左侧
 a[0]                          第二项左侧
 a[0]*a[1]
 a[0]*a[1]*a[2]
 a[0]*a[1]*a[2]...*a[n-2]      第n项左侧
 
 1                             第n项右侧
 a[n-1]
 a[n-1]*a[n-2]
 a[n-1]*a[n-2]*a[n-3]...*a[2]  第二项左侧
 a[n-1]*a[n-2]*a[n-3]...*a[1]  第一项右侧
*/
class Solution {
public:
    vector<int> multiply(const vector<int>& A) {
        vector<int> res;
        if(A.empty()) return res;
        int tmp = 1;
        for(int i=0;i//左边乘
            res.push_back(tmp);
            tmp *= A[i];
        } 
        tmp = 1;
        for(int i=A.size()-1;i>=0;i--){ //右边乘
            res[i] *= tmp;
            tmp *= A[i];
        }
        return res;
    }
};

52、正则表达式匹配

请实现一个函数用来匹配包括’.’和’‘的正则表达式。模式中的字符’.’表示任意一个字符，而’‘表示它前面的字符可以出现任意次（包含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串”aaa”与模式”a.a”和”abaca”匹配，但是与”aa.a”和”ab*a”均不匹配

/*
 当第二个字符不是“*”时：
 1、第一个字符匹配，字符串和模式后移1个字符，继续匹配 
 2、第一个字符不匹配，返回false
 当第二个字符是“*”时：
 1、第一个字符不匹配，模式后移2个字符，继续匹配
 2、第一个字符匹配，可以有3种情况：
    （1）模式后移2字符，相当于x*被忽略，x出现0次；
    （2）字符串后移1字符，模式后移2字符，相当于x出现一次；
    （3）字符串后移1字符，模式不变，相当于x出现多次次；
 注：匹配指值相同，或pattern为'.',字符串未到尾
*/
class Solution {
public:
    bool match(char* str, char* pattern)
    {
        if(*str == '\0' && *pattern == '\0') return true;
        if(*str != '\0' && *pattern == '\0') return false;
        if(*(pattern+1) != '*'){
            if(*str==*pattern || *pattern=='.'&&*str!='\0'){
                return match(str+1,pattern+1);
            }
            else return false;
        }
        else{
            if(*str==*pattern || *pattern=='.'&&*str!='\0'){
                return match(str,pattern+2)|| match(str+1,pattern+2)|| match(str+1,pattern);
            }
            else return match(str,pattern+2);
        }
    }
};

53、表示数值的字符串

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串”+100”,”5e2”,”-123”,”3.1416”和”-1E-16”都表示数值。但是”12e”,”1a3.14”,”1.2.3”,”+-5”和”12e+4.3”都不是。

/*
 1、+、-
  第一次出现+-符号，且不在首位，必须紧接在e之后
  第二次出现+-符号，必须紧接在e之后
 2、e、E
  e后不为空
  不能双e
 3、.
  .前不能有.或e
 4、其他
  return false
*/
class Solution {
public:
    bool isNumeric(char* string) {
        // 标记符号、小数点、e是否出现过
        bool hasSign = false, hasPoint = false, hasE = false; 
        for(int i=0;string[i];i++){
            if(string[i] == '+' || string[i] == '-'){
                if(!hasSign && i>0 && string[i-1]!='e' && string[i-1]!='E') return false;
                if(hasSign && string[i-1]!='e' && string[i-1]!='E') return false;
                hasSign = true;
            }
            else if(string[i] == 'e' || string[i] == 'E'){
                if(string[i+1] == '\0' || hasE) return false;
                hasE = true;
            }
            else if(string[i] == '.'){
                if(hasPoint || hasE) return false;
                hasPoint = true;
            }
            else if(string[i] < '0' || string[i] > '9') return false;
        }
        return true;
    }
};

54、字符流中第一个不重复的字符

请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符”go”时，第一个只出现一次的字符是”g”。当从该字符流中读出前六个字符“google”时，第一个只出现一次的字符是”l”。
输出描述:
如果当前字符流没有存在出现一次的字符，返回#字符。

/*
 字符在计算机中以ASCII码的形式存储，当字符作为数组下标时，其表示的下标值为该字符的ASCII码的十进制值
 0-9:  48-57  ,A-Z:  65-90  ,a-z:  97-122   ASCII码:0~127
*/
class Solution
{
public:
    string s;
    char flag[128] = {0}; 
    void Insert(char ch) {
        s += ch;
        flag[ch]++;
    }
    
    char FirstAppearingOnce() {
        for(int i=0;i
            if(flag[s[i]] == 1) return s[i];
        }
        return '#';
    }
};

55、链表中环的入口结点

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

/*
 如果有环，快慢指针总会相遇
 1——2——3——4——5——6
          |     |
          9——8——7
 假设快慢指针相遇在6，有1~6走的=6~6走的
 1~6走的 = 1~入环点+入环点~6
 6~6走的 = 6~入环点+入环点~6
 则当快指针从1重新开始，两指针速度相同，再次相遇即为入口节点
*/
/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead) {
        //快慢指针，判断是否有环
        bool hasLoop = false;
        ListNode* fast = pHead;
        ListNode* slow = pHead;
        while(fast && fast->next){
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow){
                hasLoop = true;
                break;
            }
        }
        //寻找环的入口节点
        if(hasLoop){
            fast = pHead;
            while(fast != slow){
                fast = fast->next;
                slow = slow->next;
            }
            return slow;
        }
        return NULL;
    }
};

56、删除链表中重复的结点

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead) {
        ListNode* root = new ListNode(0);//设为几无所谓
        ListNode* h = root; //标记当前位置
        h->next = pHead;
        while(h->next && h->next->next){//至少两个节点
            ListNode* tmp = h->next->next;
            if(h->next->val == tmp->val){//两节点相同
                while(tmp && h->next->val == tmp->val){
                    tmp = tmp->next;
                }
                h->next = tmp; //删除操作
            }
            else h = h->next;
        }
        return root->next;
    }
};

57、二叉树的下一个结点

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

/*
 3种情况：
       1              1              1
      / \            / \            / \
     2   3          2   4          2   5
        / \        /              / \
       4   5      3              3   4
  cur=1,next=4   cur=2,next=1   cur=4,next=1
 情况1，有右子树，返回右子树的左下角
 情况2，无右子树，且是父结点的左子树，返回父结点
 情况3，无右子树，且是父结点的右子树，返回父结点的左上角的父结点
*/
/*
struct TreeLinkNode {
    int val;
    struct TreeLinkNode *left;
    struct TreeLinkNode *right;
    struct TreeLinkNode *next;
    TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) {
        
    }
};
*/
class Solution {   
public:
    TreeLinkNode* GetNext(TreeLinkNode* pNode) {
        if(pNode->right){
            TreeLinkNode* res = pNode->right;
            while(res->left){
                res = res->left;
            }
            return res;
        }
        else{  
            while(pNode->next && pNode->next->right == pNode){
                pNode = pNode->next;
            }
            return pNode->next;
        }
        
    }
};

58、对称的二叉树

请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NUL L) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot){
        if(!pRoot) return true;
        return ismoir(pRoot->left,pRoot->right);
    }
    bool ismoir(TreeNode* l,TreeNode* r){//是镜像的
        if(!l && !r) return true;//都不存在
        if(l && r) return l->val==r->val && ismoir(l->left,r->right) && ismoir(r->left,l->right);
        return false;// 有且仅有1个存在
    }
};

59、按之字形顺序打印二叉树

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

/*
        1         ——> stack1 存奇数层，顺序
       / \
      2   3       <—— stack2 存偶数层，逆序,先left后right
     / \  / \
    4  5 6   7    ——> stack1 存奇数层，顺序,先right后left
*/
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int> > res;
        if(!pRoot) return res;
        stack stack1,stack2;
        stack1.push(pRoot);
        while(!stack1.empty() || !stack2.empty()){
            if(!stack1.empty()){
                vector<int> tmp;
                while(!stack1.empty()){
                    if(stack1.top()->left) stack2.push(stack1.top()->left);
                    if(stack1.top()->right) stack2.push(stack1.top()->right);
                    tmp.push_back(stack1.top()->val);
                    stack1.pop();
                }
                res.push_back(tmp);
            }
            if(!stack2.empty()){
                vector<int> tmp;
                while(!stack2.empty()){
                    if(stack2.top()->right) stack1.push(stack2.top()->right);
                    if(stack2.top()->left) stack1.push(stack2.top()->left);
                    tmp.push_back(stack2.top()->val);
                    stack2.pop();
                }
                res.push_back(tmp);
            }
        }
        return res;
    }
};

60、把二叉树打印成多行

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
        vector<vector<int> > Print(TreeNode* pRoot) {
            vector<vector<int> > res;
            if(!pRoot) return res;
            queue queue;
            queue.push(pRoot);
            while(!queue.empty()){
                int num = queue.size();
                vector<int> tmp;
                while(num!=0){
                    if(queue.front()->left) queue.push(queue.front()->left);
                    if(queue.front()->right) queue.push(queue.front()->right);
                    tmp.push_back(queue.front()->val);
                    queue.pop();
                    num--;
                }
                res.push_back(tmp);
            }
            return res;
        }
    
};

61、序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    char* Serialize(TreeNode *root) {
        if(!root) return NULL;
        string s;
        queue queue;
        queue.push(root);
        while(!queue.empty()){
            if(queue.front()){
                queue.push(queue.front()->left);
                queue.push(queue.front()->right);
                s += to_string(queue.front()->val)+",";
            }
            else s += "#,";
            queue.pop();
        }
        char* res = strdup(s.c_str());
        /* 另一种写法，不用strdup()
        char* res = new char[s.size() + 1];
        int i;
        for(i=0;i
        res[i] = '\0';
        */
        return res;
    }
    TreeNode* Deserialize(char *str) {
        if(!str) return NULL;
        int i = 0;
        auto head = getnode(str,i);
        queue queue;
        queue.push(head);
        while(!queue.empty()){
            queue.front()->left = getnode(str,i);
            queue.front()->right = getnode(str,i);
            if(queue.front()->left) queue.push(queue.front()->left);
            if(queue.front()->right) queue.push(queue.front()->right);
            queue.pop();
        }
        return head;
    }
    TreeNode* getnode(char *str,int &i){
        if(str[i] == ',') i++;
        if(str[i] == '#'){
            i += 2;
            return NULL;
        }
        string s;
        while(str[i] != ',' && str[i] != '\0'){
            s += str[i];
            i++;
        }
        if(!s.empty()) return new TreeNode(stoi(s));
        return NULL;
    }
};

62、二叉搜索树的第k个结点

给定一棵二叉搜索树，请找出其中的第k小的结点。例如，（5，3，7，2，4，6，8）中，按结点数值大小顺序第三小结点的值为4。

/*
 二叉搜索树：左子树上所有结点的值均小于它的根结点的值,右子树上所有结点的值均大于它的根结点的值
 二叉搜索树按照中序遍历得到递增的顺序，压入栈，第k个结点就是结果
*/
/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/

class Solution {
public:
    stack stack;
    TreeNode* KthNode(TreeNode* pRoot, int k){
        if(k <= 0) return NULL;
        sortmid(pRoot,k);
        if(stack.size() < k) return NULL; //k大于节点数
        return stack.top();
    }
    
    void sortmid(TreeNode* pRoot, int k) {
        if(!pRoot) return;
        if(stack.size()!=k) sortmid(pRoot->left,k);
        if(stack.size()!=k) stack.push(pRoot);
        if(stack.size()!=k) sortmid(pRoot->right,k);
    }
};

63、数据流中的中位数

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。

/*
 使用大小顶堆，中位数是大顶堆的根节点与小顶堆的根节点和的平均数
 大顶堆,由大到小，存较小的数 7 6 5
 小顶堆,由小到大，存较大的数 8 9 10
 步骤：
 第一个插入的元素装大顶堆
 1、每来一个插入的元素，比大顶堆堆顶元素小的装大顶堆，否则装小顶堆（保证大顶堆的数都比小顶堆的数小）
 2、判断是否大顶堆装多了，大顶堆最多比小顶堆多一个，如果是，将大顶堆堆顶元素插入小顶堆
 3、判断是否小顶堆装多了，小顶堆小于等于大顶堆，如果是，将小顶堆堆顶元素插入大顶堆
*/
class Solution {
public:
    priority_queue<int,vector<int>,less<int> > big_heap;
    priority_queue<int,vector<int>,greater<int> > small_heap;
    void Insert(int num) {
        if(big_heap.empty() || num < big_heap.top()) big_heap.push(num);
        else small_heap.push(num);
        if(big_heap.size() == small_heap.size()+2){
            small_heap.push(big_heap.top());
            big_heap.pop();
        }
        if(big_heap.size() == small_heap.size()-1){
            big_heap.push(small_heap.top());
            small_heap.pop();
        }
    }

    double GetMedian() { 
        return small_heap.size()==big_heap.size()?(small_heap.top()+big_heap.top())/2.0:big_heap.top();
    }
};

64、滑动窗口的最大值

给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}；针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

class Solution {
public:
    vector<int> maxInWindows(const vector<int>& num, unsigned int size)
    {
        vector<int> res;
        deque<int> q;//队首为当前窗口下最大值下标
        for(unsigned int i=0;i
            while(!q.empty() && num[i]>num[q.back()]){//q删掉所有比当前元素小的，保证q降序
                q.pop_back();
            }
            if(!q.empty() && q.front()+size == i){ //若队首超过窗口位置,删掉
                q.pop_front();
            }
            q.push_back(i);
            if(size && i+1>=size) res.push_back(num[q.front()]); //防止size=0
        }
        return res;
    }
};

65、矩阵中的路径

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串”bcced”的路径，但是矩阵中不包含”abcb”路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

class Solution {
public:
    bool hasPath(char* matrix, int rows, int cols, char* str)
    {
        //if(!matrix || rows<=0 || cols<=0 || !str) return false;
        for(int i=0;i
            for(int j=0;j
                if(help(matrix,i,j,str,0,rows,cols)) return true;
            }
        }
        return false;
    }
    bool help(char* matrix, int i, int j, char* str, int k, int rows, int cols) {
        int index = i*cols+j;
        if(i<0||i>=rows||j<0||j>=cols||matrix[index]=='#'||str[k]!=matrix[index]) return false;
        if(str[k+1]=='\0') return true;
        char tmp = matrix[index];
        matrix[index] = '#';
        if(help(matrix,i+1,j,str,k+1,rows,cols) 
           || help(matrix,i-1,j,str,k+1,rows,cols)
           || help(matrix,i,j+1,str,k+1,rows,cols) 
           || help(matrix,i,j-1,str,k+1,rows,cols)){
            return true;
        }
        matrix[index] = tmp;
        return false;
    }
};

66、机器人的运动范围

地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

class Solution {
public:
    int movingCount(int threshold, int rows, int cols) {
        if(rows<=0 || cols<=0 || threshold<0) return 0;
        bool* flag = new bool[rows*cols];
        memset(flag,false,rows*cols);
        return helper(threshold,rows,cols,0,0,flag);
    }
    int helper(int threshold, int rows, int cols,int i, int j, bool* flag) {
        int index = i*cols+j;
        if(i<0||i>=rows||j<0||j>=cols||flag[index]||count(i)+count(j)>threshold) return 0;
        flag[index] = true;
        return helper(threshold,rows,cols,i-1,j,flag)+
               helper(threshold,rows,cols,i+1,j,flag)+
               helper(threshold,rows,cols,i,j-1,flag)+
               helper(threshold,rows,cols,i,j+1,flag)+1;
    }
    int count(int n) {
        int res = 0;
        while(n!=0){
            res += n%10;
            n /= 10;
        }
        return res;
    }
};

基于RGBD相机的人脸实时三维重建过程解析（ElasticFusion实现）

2019-06-17T03:36:20.000Z

主要是在ElasticFusion基础上做了部分修改，进行人脸实时重建。
PPT及相关论文地址：https://pan.baidu.com/s/1Zr1uCFj7YqgEWWof2gp-Lw ，提取码：7fnw
相关算法实现链接：
BundleFusion在win10+vs2013+cuda8.0上的实现
 DynamicFusion在ubuntu16.04+显卡GT740+cuda8.0上的实现
 ElasticFusion在ubuntu16.04+cuda8.0上的实现

参考链接：
KinectFusion 解析
 KinectFusion 论文精析
 kinect fusion 3D重建基本算法
 KinectFusion中用到的TSDF Fusion
BundleFusion 解析
 ElasticFusion 解析（这个博主其他文章也非常值得参考）
ElasticFusion

Vue+iview+Echarts+electron 桌面应用

2019-04-29T12:01:15.000Z

一、Vue项目创建

1、安装node.js

#下载安装包：https://nodejs.org/en/
cmd输入node -v 和npm -v查看是否安装成功

2、Vue开发环境

#命令行下载淘宝镜像命令工具 cnpm

1	npm install cnpm -g --registry=http://registry.npm.taobao.org

#用 cnpm 命令全局安装vue-cli脚手架

1	cnpm install --global vue-cli

输入vue，出来vue的信息说明安装成功

3、搭建Vue项目

（1）项目初始化

使用命令创建项目，一步步选择之后开始等等项目创建完成

1	vue init webpack app

（2）项目预览

1 2	cd demo npm run dev

打开浏览器，复制粘贴命令行显示的地址（ http://localhost:8080），跳出页面

二、引入ivew+Echarts

1、ivew+Echarts安装

1	cnpm install ivew -save

1	cnpm install echarts -save

2、引入ivew+Echarts

项目src/main.js中引入ivew+Echarts

import iView from 'iview';
import 'iview/dist/styles/iview.css';

Vue.use(iView);

1 2	import Echarts from 'echarts' Vue.prototype.echarts = Echarts

3、Echarts组件

将src/components/HelloWorld修改为如下内容


<template>
    class="layout">
        
            
                
                    
                    
                        
                            
                            Item 1
                        
                        
                            
                            Item 2
                        
                        
                            
                            Item 3
                        
                        
                            
                            Item 4
                        
                    
                
            
            
                
                    
                        
                            
                            Option 1
                            Option 2
                            Option 3
                        
                        
                            
                            Option 1
                            Option 2
                        
                        
                            
                            Option 1
                            Option 2
                        
                    
                
                
                    
                        Home
                        Components
                        Layout

1	npm run dev

打开http://localhost:8080 ，显示页面

4、生成项目

执行生成命令

1	npm run build

出现如下效果

项目下回多出一个dist的文件夹，里面是打包好的东西，双击index.html显示网页内容则证明生成成功

（1）打包页面显示空白

修改index.js 中的生成路径，第46行改为assetsPublicPath: './',，否则后面程序运行打包页面会显示空白，找不到路径

（2）页面部分空白，router-view内容无法显示

// mode: ‘history’,//将这个模式关闭就好

（3）iview 打包之后，图标无法显示

在 build/webpack.prod.conf.js 中,将extract改为false

接下来一切操作都在dist文件夹目录下。

三、electron打包

1、安装 electron

用 cnpm 命令安装 electron

1	cnpm install electron -g

cmd输入electron -v查看是否安装成功

2、 package.json 和 main.js

在dist文件夹下，复制粘贴下面的 package.json 和 main.js文件，最终目录如图

在package.json中：

{
  "name"    : "your-app",
  "version" : "0.1.0",
  "main"    : "main.js"
}

在main.js中

const {app, BrowserWindow} = require('electron')
const path = require('path')
const url = require('url')

// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
let win

function createWindow () {
  // Create the browser window.
  win = new BrowserWindow({width: 800, height: 600})

  // and load the index.html of the app.
  win.loadURL(url.format({
    pathname: path.join(__dirname, 'index.html'),
    protocol: 'file:',
    slashes: true
  }))

  // Open the DevTools.
  // win.webContents.openDevTools()

  // Emitted when the window is closed.
  win.on('closed', () => {
    // Dereference the window object, usually you would store windows
    // in an array if your app supports multi windows, this is the time
    // when you should delete the corresponding element.
    win = null
  })
}

// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.on('ready', createWindow)

// Quit when all windows are closed.
app.on('window-all-closed', () => {
  // On macOS it is common for applications and their menu bar
  // to stay active until the user quits explicitly with Cmd + Q
  if (process.platform !== 'darwin') {
    app.quit()
  }
})

app.on('activate', () => {
  // On macOS it's common to re-create a window in the app when the
  // dock icon is clicked and there are no other windows open.
  if (win === null) {
    createWindow()
  }
})

// In this file you can include the rest of your app's specific main process
// code. You can also put them in separate files and require them here.

运行

1	electron .

3、electron-packager打包

（1）全局安装`electron-packager`

1	npm install electron-packager -g

（2）运行打包命令

1	electron-packager . demo --win --out outApp --arch=x64 --app-version 1.0.0 --electron-version 5.0.0 --overwrite --ignore=node_modules

在dist\outApp\demo-win32-x64文件夹下生成可执行文件demo.exe,双击运行程序

嫌每次输入太长，可以将在package.json中添加

"scripts": {
        "start": "electron .",
        "build": "electron-packager . myApp --win --out outApp --arch=x64 --app-version 1.0.0 --electron-version 5.0.0 --overwrite --ignore=node_modules"
      }

这样输入npm run start相当于执行了electron .,测试打包效果
输入npm run build相当于执行了打包命令，在dist\outApp\myApp-win32-x64文件夹下生成可执行文件myApp.exe

4、源码加密

在outApp\demo-win32-x64\resources\app里有写的源码。写的代码完全暴露在用户电脑上是非常不安全的，可以通过electron 自带的加密功能解决这个问题。

（1）全局安装 asar

1	npm install asar -g

（2）使用asar指令进行加密

在resources目录下使用asar指令进行加密

1	asar pack ./app app.asar

将原来的app文件夹删除，这样生成的app.asar就加密了之前的源代码
双击demo.exe重新运行程序

一步步配置腾讯云服务器Ubuntu 通过域名访问自己的网页tomcat（详细基础）

2019-04-26T08:32:46.000Z

STEP1:云服务器+域名

1、购买云服务器、域名

购买学生优惠套餐 10元/月：https://cloud.tencent.com/act/campus?fromSource=gwzcw.1088196.1088196.1088196
系统选ubuntu，购买3个月加购域名共38元（3个月以下没法添加域名解析），买了域名以后可以直接通过域名访问

收到服务器信息，最好把这些复制到一个txt里，以后会经常用。

2、添加解析

在控制台进入云解析，添加解析，填域名，点新手快速添加，网站解析，输入公网ip（无需备案）
完成后：

3、设置安全组

控制台-云服务器-安全组-新建，选择放通22，80，443，3389端口和ICMP协议，新建安全组
点击关联实例数，新增关联与自己的服务器进行关联，
点击修改规则，放通8080端口（tomcat要用）

STEP2:连接服务器，配置JDK+tomcat

1、连接服务器

下载安装PuTTY：https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html
下载安装WinSCP：https://winscp.net/eng/download.php

（1）PuTTY连接服务器

输入公网ip

输入默认账户ubuntu，输入初始密码**，登陆成功如上图。

putty的复制粘贴技巧

复制密码后，在putty直接右键就是粘贴，密码不显示注意不要多复制。（如果想复制putty中的文字，左键选取就已经复制上了）

创建root账号

1、设置root密码
sudo passwd root
输入密码
2、获取root权限
输入su
输入密码
以后再次登录，输入su再输入密码就可以了，成功后：

root@VM-0-16-ubuntu:/home/ubuntu#

（2）winSCP连接服务器

主机名为公网ip，点击登录

尝试新建文件夹test，提示permission denied

使用root登录winSCP：

打开winSCP填写登录信息，点击高级，设置SFTP如下：
sudo /usr/lib/openssh/sftp-server

重新登录后，就可以将本地文件拖到服务器中了。

2、配置JDK+tomcat（ubuntu云服务器）

下载jdk8：http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
下载Tomcat：https://tomcat.apache.org/download-90.cgi
root登录winSCP后，将下载的 jdk-8u191-linux-x64.tar.gz 和 jdk-11.0.1_linux-x64_bin.tar.gz拖到/usr/local/src/目录下

（1）安装JDK1.8

root登录putty后，输入
cd /usr/local/src/                                              // 进入存放安装包的位置
tar zxvf jdk-8u144-linux-x64.tar.gz            // 解压下载的数据包
mv jdk1.8.0_144 /usr/local/jdk1.8                // 给解压完成后的数据包更换一个其他目录并且改名
vi /etc/profile                                                    // 编辑/etc/profile 环境变量文件
在最后面添加

JAVA_HOME=/usr/local/jdk1.8
JAVA_BIN=/usr/local/jdk1.8/bin
JRE_HOME=/usr/local/jdk1.8/jre
PATH=$PATH:/usr/local/jdk1.8/bin:/usr/local/jdk1.8/jre/bin
CLASSPATH=/usr/local/jdk1.8/jre/lib:/usr/local/jdk1.8/lib:/usr/local/jdk1.8/jre/lib/charsets.jar

vi使用技巧

输入 i ，退出命令模式，进入INSERT模式
开始修改内容……
按 esc 键，退出INSERT模式，进入命令模式
再输入 :wq，保存文件，退出vi编辑器

键        功能
:wq      保存文件，退出vi编辑器
:w        保存文件，但不退出vi编辑器
:q         退出vi编辑器
:q!        不保存文件，退出vi编辑器
ZZ       保存文件，退出vi编辑器
或者在winSCP中直接打开/etc/profile文件，修改后保存。

putty中输入
source /etc/profile // source重启环境变量配置文件
java -version // 检测jdk环境是否配置好

注：每次登录，碰到java -version不显示版本号就，先source /etc/profile，再java -version，就好了。

（2）安装Tomcat9

root登录putty后，输入
cd /usr/local/src/                                                  // 进入存放安装包的位置
tar zxvf apache-tomcat-9.0.14.tar.gz              // 解压下载的数据包
mv apache-tomcat-9.0.14 /usr/local/tomcat    // 给解压完成后的数据包更换一个其他目录并且改名
/usr/local/tomcat/bin/startup.sh                      // 启动Tomcat

Tomcat启用成功了显示：

Using CATALINA_BASE: /usr/local/tomcat
Using CATALINA_HOME: /usr/local/tomcat
Using CATALINA_TMPDIR: /usr/local/tomcat/temp
Using JRE_HOME: /usr/local/jdk1.8
Using CLASSPATH: /usr/local/tomcat/bin/bootstrap.jar:/usr/local/tomcat/bin/tomcat-juli.jar
Tomcat started.

如果要关闭Tomcat
/usr/local/tomcat/bin/shutdown.sh
启动Tomcat后，确定服务器8080端口放通，则在浏览器输入服务器公网ip:8080，一只熟悉的猫出现了~注：如果添加了域名解析，可以用域名代替ip

STEP3:本地网页布置到tomcat

希望ip:8080访问自己的网页
首先有自己的网页，如自己写的跳一跳网页，下载地址：https://github.com/zj19941113/You_Jump_I_Jump
将项目文件夹zjgame放到tomcat/webapps/文件夹中，从ROOT中将WEB-INF文件夹复制到zjgame，访问ip:8080/zjgame/zjtest.html，就能看到项目了
如果添加了域名解析，可以访问域名:8080/zjgame/zjtest.html

（1）去掉项目名

a. 将zjgame中的网页和资源文件复制到ROOT中，zjtest.html重命名为index.html
浏览器输入 ip:8080 就能访问了
或者

b. 修改 /usr/local/tomcat/conf/server.xml 文件

在里加上

（2）去掉:8080

修改 /usr/local/tomcat/conf/server.xml 文件，将默认端口port=”8080”改为”80”

Connector port=”80” protocol=”HTTP/1.1” connectionTimeout=”20000” redirectPort=”8443” />

关闭Tomcat
/usr/local/tomcat/bin/shutdown.sh
过一会再重启
/usr/local/tomcat/bin/startup.sh
因为之前已经进行过域名解析，所以直接访问 http://zhoujie1994.cn 就能看到自己的网页了

备案后不会再提示不安全：https://zhoujie1994.cn/three/

Kinect v1实时dlib(GPU版)人脸识别与活体检测

2019-04-22T11:39:33.000Z

一、配置

1、opencv

#安装依赖

1 2	sudo apt-get install libvtk5-dev sudo apt-get install libgtk2.0-dev

#安装OpenCV 2.4.13

git clone https://github.com/opencv/opencv
cd opencv/
git checkout 2.4.13.3
mkdir -p build && cd build
cmake -DWITH_VTK=ON -DWITH_GTK=ON -DBUILD_opencv_calib3d=ON -DBUILD_opencv_imgproc=ON -DWITH_CUDA=OFF ..
make -j4
sudo make install

注：opencv的下载过程非常慢

2、dlib（GPU版）

需要提前安装驱动、cuda 与 cudnn
进入官网：http://dlib.net/ ，点击左下角Download dlib ver.19.17 ，下载后解压。
进入dlib根目录下

mkdir build && cd build
cmake .. 
cmake --build . --config Release
sudo make install

注：会自动检查满足安装gpu版条件，注意命令行提示信息

二、Kinect v1接入

1、安装OpenNI2

1
2
3

git clone https://github.com/occipital/OpenNI2.git
cd OpenNI2
make -j4

2、安装libFreenect

1 2	git clone https://github.com/OpenKinect/libfreenect cd libfreenect

打开libfreenect/CMakeLists.txt，在33行cmake_minimum_required(VERSION 2.8.12)下一行添加

1	add_definitions(-std=c++11)

保存后关闭，命令行继续执行

mkdir build && cd build  
cmake .. -DBUILD_OPENNI2_DRIVER=ON  
make -j4
cp -L lib/OpenNI2-FreenectDriver/libFreenectDriver.so ${OPENNI2_DIR}/Bin/x64-Release/OpenNI2/Drivers   #OPENNI2_DIR需要修改

注：${OPENNI2_DIR}是OpenNI2的解压文件夹，比如我的在ElasticFusion文件夹，则

打开libfreenect文件夹，运行

1	sudo cp platform/linux/udev/51-kinect.rules /etc/udev/rules.d

重启后，插上kinect后，命令行运行clsusb，查看是否包含：Xbox camera，Xbox motor，Xbox audio

二、代码运行

1、CMakeList.txt修改

#CMakeList.txt

cmake_minimum_required(VERSION 2.8.4) 

project(face_dlib) 


SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -DDLIB_JPEG_SUPPORT")

IF(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Weverything")
ELSEIF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
ENDIF()

# opencv
find_package(OpenCV REQUIRED)
include_directories(${OpenCV_INCLUDE_DIRS})

# OpenNI2
set(OPENNI2_PATH "/home/zhoujie/fusion/ElasticFusion/OpenNI2") 

set(OPENNI2_INCLUDE_DIR ${OPENNI2_PATH}/Include)
set(OPENNI2_LIBRARY ${OPENNI2_PATH}/Bin/x64-Release)
include_directories (${OPENNI2_INCLUDE_DIR})
link_directories (${OPENNI2_LIBRARY})

# dlib
include(/home/zhoujie/dlib-19.17/dlib/cmake)

add_executable(this_is_who_kinect_one src/this_is_who_kinect_one.cpp)
target_link_libraries(this_is_who_kinect_one dlib ${OpenCV_LIBS} libOpenNI2.so)

macro(add_face_dlib name)
   add_executable(${name} src/${name}.cpp)
   target_link_libraries(${name} dlib )
endmacro()

add_face_dlib(train_candidate)
add_face_dlib(this_is_who)

将OPENNI2_PATH与dlib路径修改为自己的。

2、数据+模型下载

下载 shape_predictor_68_face_landmarks.dat 和 dlib_face_recognition_resnet_model_v1.dat 放置到model文件夹中

链接：https://pan.baidu.com/s/1jIoW6BSa5nkGWNipL7sxVQ
其中包括：

candidate-face.zip（人脸库：包含29个正面人脸红外图）
allface.zip（测试人脸集：包括29个人，每人13种脸部姿态下的红外图与深度图）
shape_predictor_68_face_landmarks.dat（人脸68关键点检测器）
dlib_face_recognition_resnet_model_v1.dat（人脸识别模型）

3、代码运行

将train_candidate.cpp 、this_is_who 和 this_is_who_kinect_one.cpp置于src文件夹中。

#build

1
2
3

mkdir build && cd build
cmake ..
make -j4

cmake时检查是否适用dlib(GPU)版

最终在build文件夹中生成多个可执行文件

将人脸图片重命名为人的名字，放在data文件夹中。

1、运行train_candidate 获得人脸库特征信息，存储在candidates_descriptors.dat 与 candidates.dat 中，同时生成candidates.txt，便于查看候选人信息。每次修改人脸库，只需运行train_candidate，完成人脸信息的更新。

2、运行this_is_who_kinect_one,实时获取Kinect深度图与彩色图，并进行人脸识别与活体检测。

3、不使用kinect v1实时接入，在离线数据上测试，运行this_is_who,使用data/allface中的深度图与红外图，并进行人脸识别与活体检测。

代码部分：

#train_candidate

#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 
#include 

using namespace dlib;
using namespace std;

/* 函数声明 */
/* 人脸库训练 */
int candidates_train(const char *facesFile,std::vectorfloat,0,1>>&candidates_descriptors,std::vector<string>&candidates);

template <template <int,template<typename>class,int,typename> class block, int N, templateclass BN, typename SUBNET>
using residual = add_prev1>>;
template <template <int,template<typename>class,int,typename> class block, int N, templateclass BN, typename SUBNET>
using residual_down = add_prev2>>>>>;
template <int N, template <typename> class BN, int stride, typename SUBNET> 
using block  = BN>>>>;
template <int N, typename SUBNET> using ares      = relu>;
template <int N, typename SUBNET> using ares_down = relu>;
template <typename SUBNET> using alevel0 = ares_down<256,SUBNET>;
template <typename SUBNET> using alevel1 = ares<256,ares<256,ares_down<256,SUBNET>>>;
template <typename SUBNET> using alevel2 = ares<128,ares<128,ares_down<128,SUBNET>>>;
template <typename SUBNET> using alevel3 = ares<64,ares<64,ares<64,ares_down<64,SUBNET>>>>;
template <typename SUBNET> using alevel4 = ares<32,ares<32,ares<32,SUBNET>>>;
using anet_type = loss_metric128,avg_pool_everything<
    alevel0<
    alevel1<
    alevel2<
    alevel3<
    alevel4<
    max_pool<3,3,2,2,relu32,7,7,2,2,
    input_rgb_image_sized<150>
    >>>>>>>>>>>>;

int main(int argc, char** argv)
{
    if (argc == 1)
        {
            cout << "\nCall this program like this:" << endl;
            cout << "./train_candidate ../data/candidate-face/" << endl;
            return 0;
        }
    
    const char *facesFile = argv[1];

    std::vectorfloat,0,1>> candidates_descriptors;
    std::vector<string> candidates;
    
    /* 人脸库训练 */
    candidates_train(facesFile,candidates_descriptors,candidates);

}

/* 人脸库训练 */
int candidates_train(const char *facesFile,std::vectorfloat,0,1>>&candidates_descriptors,std::vector<string>&candidates)
{
    DIR *dir;
    struct dirent *ptr; 
    char base[30]; 
    const char *pick=".jpg"; //需要的子串;
    char IRfile[100];
    char *name;
    int face_num = 0;
    std::vector> faces;

    frontal_face_detector detector = get_frontal_face_detector(); // 人脸正脸检测器
    shape_predictor sp; //人脸关键点检测器
    anet_type net;  // 人脸识别模型

    deserialize("../model/shape_predictor_68_face_landmarks.dat") >> sp;
    deserialize("../model/dlib_face_recognition_resnet_model_v1.dat") >> net;

    clock_t start,finish;
    double totaltime;
    start=clock();

    ofstream mycout("../candidates.txt");

    cout << "TRAINING START！" << endl;

    if ((dir=opendir(facesFile)) == NULL)
    {
        perror("Open dir error...");
        exit(1);
    }
    while ((ptr=readdir(dir)) != NULL)
    {
        strcpy(base, ptr->d_name);
        if(strstr(base,pick)) 
        {
            cout << "training image:" << base << endl;
            strcpy(IRfile, facesFile);
            strcat(IRfile, base);
            name = strtok(base, "_");
            string candidate = name;
            cout << "candidate: " << candidate << endl;

            mycout  << candidate << endl;

            candidates.push_back(candidate);
            matrix img;
            load_image(img, IRfile);
            std::vector dets = detector(img);
            full_object_detection shape = sp(img, dets[0]);
            matrix face_chip;
            extract_image_chip(img, get_face_chip_details(shape,150,0.25), face_chip);
            faces.push_back(move(face_chip));
            face_num += 1;
        }  
    }
    candidates_descriptors = net(faces);

    mycout.close();
    cout << "TRAINING END！" << endl;
    cout << "\nTRAIN RESULT：" << endl;
    cout << "Training " << face_num <<  " face(s)！" << endl;

    finish=clock();
    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
    cout<<"TRAINING TIME： " << totaltime << " S！"<<endl;

    cout << "\nFace database updating……" << endl;
    serialize("../candidates_descriptors.dat") << candidates_descriptors;
    serialize("../candidates.dat") << candidates;
    cout << "Face has been updated！" << endl;
    
    closedir(dir);
    return 0;
}

#this_is_who_kinect_one.cpp

#include 
#include 
#include 
#include 
#include 

#include 

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 
#include  

using namespace std;
using namespace openni;
using namespace dlib;
using namespace cv;

template <template <int,template<typename>class,int,typename> class block, int N, templateclass BN, typename SUBNET>
using residual = add_prev1>>;
template <template <int,template<typename>class,int,typename> class block, int N, templateclass BN, typename SUBNET>
using residual_down = add_prev2>>>>>;
template <int N, template <typename> class BN, int stride, typename SUBNET> 
using block  = BN>>>>;
template <int N, typename SUBNET> using ares      = relu>;
template <int N, typename SUBNET> using ares_down = relu>;
template <typename SUBNET> using alevel0 = ares_down<256,SUBNET>;
template <typename SUBNET> using alevel1 = ares<256,ares<256,ares_down<256,SUBNET>>>;
template <typename SUBNET> using alevel2 = ares<128,ares<128,ares_down<128,SUBNET>>>;
template <typename SUBNET> using alevel3 = ares<64,ares<64,ares<64,ares_down<64,SUBNET>>>>;
template <typename SUBNET> using alevel4 = ares<32,ares<32,ares<32,SUBNET>>>;
using anet_type = loss_metric128,avg_pool_everything<
    alevel0<
    alevel1<
    alevel2<
    alevel3<
    alevel4<
    max_pool<3,3,2,2,relu32,7,7,2,2,
    input_rgb_image_sized<150>
    >>>>>>>>>>>>;

const int ITER = 5000; // 随机取点次数
const float PLANE_OR_NOT = 0.2; // 判断是否为平面的分界线
const int SIGMA = 1;

int main()
{
  frontal_face_detector detector = get_frontal_face_detector(); // 人脸正脸检测器
  shape_predictor sp; //人脸关键点检测器
  anet_type net;  // 人脸识别模型

  deserialize("../model/shape_predictor_68_face_landmarks.dat") >> sp;
  deserialize("../model/dlib_face_recognition_resnet_model_v1.dat") >> net;

  std::vectorfloat,0,1>> candidates_descriptors;
  deserialize("../candidates_descriptors.dat") >> candidates_descriptors;

  std::vector<string> candidates;
  deserialize("../candidates.dat") >> candidates;
  
  // 1. Initial OpenNI
  if( OpenNI::initialize() != STATUS_OK )
  {
    cerr << "OpenNI Initial Error: " 
         << OpenNI::getExtendedError() << endl;
    return -1;
  }

  // 2. Open Device
  Device mDevice;
  if( mDevice.open( ANY_DEVICE ) != STATUS_OK )
  {
    cerr << "Can't Open Device: " 
         << OpenNI::getExtendedError() << endl;
    return -1;
  }

  // 3. Create depth stream
  VideoStream mDepthStream;
  if( mDevice.hasSensor( SENSOR_DEPTH ) )
  {
    if( mDepthStream.create( mDevice, SENSOR_DEPTH ) == STATUS_OK )
    {
      // 3a. set video mode
      VideoMode mMode;
      mMode.setResolution( 640, 480 );
      mMode.setFps( 30 );
      mMode.setPixelFormat( PIXEL_FORMAT_DEPTH_1_MM );

      if( mDepthStream.setVideoMode( mMode) != STATUS_OK )
      {
        cout << "Can't apply VideoMode: "
             << OpenNI::getExtendedError() << endl;
      }
    }
    else
    {
      cerr << "Can't create depth stream on device: "
           << OpenNI::getExtendedError() << endl;
      return -1;
    }
  }
  else
  {
    cerr << "ERROR: This device does not have depth sensor" << endl;
    return -1;
  }

  // 4. Create color stream
  VideoStream mColorStream;
  if( mDevice.hasSensor( SENSOR_COLOR ) )
  {
    if( mColorStream.create( mDevice, SENSOR_COLOR ) == STATUS_OK )
    {
      // 4a. set video mode
      VideoMode mMode;
      mMode.setResolution( 640, 480 );
      mMode.setFps( 30 );
      mMode.setPixelFormat( PIXEL_FORMAT_RGB888 );

      if( mColorStream.setVideoMode( mMode) != STATUS_OK )
      {
        cout << "Can't apply VideoMode: " 
             << OpenNI::getExtendedError() << endl;
      }

      // 4b. image registration
      if( mDevice.isImageRegistrationModeSupported(
              IMAGE_REGISTRATION_DEPTH_TO_COLOR ) )
      {
        mDevice.setImageRegistrationMode( IMAGE_REGISTRATION_DEPTH_TO_COLOR );
      }
    }
    else
    {
      cerr << "Can't create color stream on device: "
           << OpenNI::getExtendedError() << endl;
      return -1;
    }
  }

  // 5. create OpenCV Window
  cv::namedWindow( "Depth Image", CV_WINDOW_AUTOSIZE);
  cv::namedWindow( "Color Image", CV_WINDOW_AUTOSIZE);

  // 6. start
  VideoFrameRef  mColorFrame;
  VideoFrameRef  mDepthFrame;

  mDepthStream.start();
  mColorStream.start();

  cv::Mat cImageBGR;
  cv::Mat DepthMat;

  int iMaxDepth = mDepthStream.getMaxPixelValue();
  while( true )
  {
    // 8a. get depth frame
    if( mDepthStream.readFrame( &mDepthFrame ) == STATUS_OK )
    {
      // 8b. convert data to OpenCV format
      const cv::Mat mImageDepth(
                mDepthFrame.getHeight(), mDepthFrame.getWidth(),
                CV_16UC1, (void*)mDepthFrame.getData() );

      DepthMat = mImageDepth.clone();

      // 8c. re-map depth data [0,Max] to [0,255]
      cv::Mat mScaledDepth;
      mImageDepth.convertTo( mScaledDepth, CV_8U, 255.0 / iMaxDepth );

      // 8d. show image
      cv::imshow( "Depth Image", mScaledDepth );
    }
    
    // 7a. get color frame
    if( mColorStream.readFrame( &mColorFrame ) == STATUS_OK )
    {
      // 7b. convert data to OpenCV format
      const cv::Mat mImageRGB(
              mColorFrame.getHeight(), mColorFrame.getWidth(),
              CV_8UC3, (void*)mColorFrame.getData() );
      // 7c. convert form RGB to BGR
      
      
      cv::cvtColor( mImageRGB, cImageBGR, CV_RGB2BGR );
      // 7d. show image

      //dlib
      cv_image cimg(cImageBGR);

      // Detect faces 
      std::vector dets = detector(cimg);

      if(dets.size() != 0){
        int livedetector;
        string who,isface;
        float who_probability;
        float pretotal_ary;

        if(dets.size() != 1){
          livedetector = -1;
          for (unsigned long j = 0; j < dets.size(); ++j){
            Rect rect(dets[j].left(),dets[j].top(),dets[j].right() -dets[j].left(), dets[j].bottom() -dets[j].top());//左上坐标（x,y）和矩形的长(x)宽(y)
            cv::rectangle(cImageBGR, rect, Scalar(0, 255, 0),1,8,0);
          }

        }
        else{
          Rect rect(dets[0].left(),dets[0].top(),dets[0].right() -dets[0].left(), dets[0].bottom() -dets[0].top());//左上坐标（x,y）和矩形的长(x)宽(y)
          cv::rectangle(cImageBGR, rect, Scalar(0, 255, 0),1,8,0);

          full_object_detection shape = sp(cimg, dets[0]);
          std::vector> faces;
          matrix face_chip;
          extract_image_chip(cimg, get_face_chip_details(shape,150,0.25), face_chip);
          faces.push_back(move(face_chip));
          std::vectorfloat,0,1>> face_descriptors = net(faces);

          float distance;
          float best_distance = length(face_descriptors[0]-candidates_descriptors[0]);
          size_t candidates_num = candidates_descriptors.size();
          int candidates_num_int = static_cast<int>(candidates_num);
          int best_k = 0;
          for (int k = 1; k < candidates_num_int; k++)
          {
              distance = length(face_descriptors[0]-candidates_descriptors[k]);
              if (distance < best_distance) 
              {
                  best_distance = distance;
                  best_k = k;
              }
          }
          if (best_distance < 0.6) {
              who = candidates[best_k];
              who_probability =  (1.05-0.66*best_distance)*100 < 100?(1.05-0.66*best_distance)*100:99;
          }
          else{
              who = "Unknow";
          }

          // liveness_detection(DepthMat,locates,livedetector);
          int COL ,ROW ,FACE_WIDTH ,FACE_HEIGHT; 
          int faceno0_num;
          int FaceDATA[3][100000];
          int k;
          int pretotal;
          int x[3],y[3],z[3];  // 随机取三个点 
          float a,b,c;  // 拟合平面方程 z=ax+by+c
          int rand_num[3];
          float check,distance2;
          int total;

          COL = rect.x;
          ROW = rect.y;
          FACE_WIDTH = rect.width;
          FACE_HEIGHT = rect.height; 
          faceno0_num = FACE_HEIGHT*FACE_WIDTH -1; 
          k = 0;
          for(int m = 1;m< FACE_HEIGHT+1;m++)
          {
              for(int n= 1;n< FACE_WIDTH+1;n++) 
              { 
                  ushort tmp = DepthMat.at(COL+n-1,ROW+m-1);
                  if (tmp == 0)
                  {
                      faceno0_num -= 1; // 非零深度点个数为 faceno0_num+1
                      continue;
                  }
                  FaceDATA[0][k] = n; 
                  FaceDATA[1][k] = m;
                  FaceDATA[2][k] = tmp;
                  k += 1;
              } 
          } 

          if(faceno0_num > 2000){
            pretotal = 0;  // 符合拟合模型的数据的个数 
            srand((unsigned)time(NULL));
            total = 0;
            for(k = 0; k < ITER; k++)
            {
              do{
                  rand_num[0] = std::rand()%faceno0_num; 
                  rand_num[1] = std::rand()%faceno0_num; 
                  rand_num[2] = std::rand()%faceno0_num; 
              }while(rand_num[0] == rand_num[1] || rand_num[0] == rand_num[2] || rand_num[1] == rand_num[2]);
              for(int n = 0; n < 3; n++ )
              {
                  x[n] = FaceDATA[0][rand_num[n]];
                  y[n] = FaceDATA[1][rand_num[n]];
                  z[n] = FaceDATA[2][rand_num[n]];
              }
              check = (x[0]-x[1])*(y[0]-y[2]) - (x[0]-x[2])*(y[0]-y[1]);
              if ( check == 0)  // 防止提示浮点数例外 (核心已转储)
              {
                  k -= 1;
                  continue;
              }
              a = ( (z[0]-z[1])*(y[0]-y[2]) - (z[0]-z[2])*(y[0]-y[1]) )*1.0/( (x[0]-x[1])*(y[0]-y[2]) - (x[0]-x[2])*(y[0]-y[1]) );
              if (y[0] == y[2])  // 防止提示浮点数例外 (核心已转储)
              {
                  k -= 1;
                  continue;
              }
              b = ((z[0] - z[2]) - a * (x[0] - x[2]))*1.0/(y[0]-y[2]);
              c = z[0]- a * x[0] - b * y[0];
              total = 0;
              for(int n = 0; n < faceno0_num +1 ; n++ )
              {
                  distance2 = fabs(a*FaceDATA[0][n] + b*FaceDATA[1][n] - 1*FaceDATA[2][n] + c*1);
                  if (distance2 < SIGMA)
                  {
                      total +=1;
                  }
              }
              if (total > pretotal)  // 找到符合拟合平面数据最多的拟合平面
              {
                  pretotal=total;
              }   
            }

            pretotal_ary = pretotal *1.0/ faceno0_num;
            if (pretotal_ary < PLANE_OR_NOT){
              livedetector = 1;
            }
            else{
              livedetector = 0;
            }
          
          }
          else{
            livedetector = -2;
          }
        }

        if(livedetector == -1){
          who = "More than one face";
          isface = "Please detect one face";
        }
        if(livedetector == 1){
          isface = "Is FACE";
        }
        if(livedetector == 0){
          isface = "Is not FACE";
        }
        if(livedetector == -2){
          isface = "Lack of depth information";
          pretotal_ary = 0;
        }

        stringstream strStream1; 
        strStream1 << who << " , " << who_probability << "%"; 
        string str1 = strStream1.str();  

        stringstream strStream2; 
        strStream2 << isface << " , " << "pretotal_ary:" << pretotal_ary; 
        string str2 = strStream2.str();  

        cv::putText(cImageBGR, "RECOGNITION RESULT: ", cv::Point(20,20), cv::FONT_HERSHEY_COMPLEX,0.4,Scalar(255, 255, 255),1,8,0);
        cv::putText(cImageBGR, str1, cv::Point(20,40), cv::FONT_HERSHEY_COMPLEX,0.5,Scalar(0, 255, 0),1,8,0);
        cv::putText(cImageBGR, "LIVENESS DETECTION RESULT: ", cv::Point(20,60), cv::FONT_HERSHEY_COMPLEX,0.4,Scalar(255, 255, 255),1,8,0);
        cv::putText(cImageBGR, str2, cv::Point(20,80), cv::FONT_HERSHEY_COMPLEX,0.5,Scalar(0, 255, 0),1,8,0);
      }

      cv::imshow( "Color Image", cImageBGR);
    }

    // 6a. check keyboard
    if( cv::waitKey( 1 ) == 'q' ){
      break;
    }
  }

  // 9. stop
  mDepthStream.destroy();
  mColorStream.destroy();
  mDevice.close();
  OpenNI::shutdown();

  return 0;
}

#this_is_who.cpp

#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 
#include 

using namespace dlib;
using namespace std;

/* 函数声明 */
/* 输出人脸位置 返回识别结果 */
string face_location(const char *imgFile,std::vector<int>&locates, std::vectorfloat,0,1>>&candidates_descriptors,std::vector<string>&candidates);
/* 判断是否为活体 */
bool liveness_detection(const char *DeepFile,std::vector<int>&locates);  

const int IMG_HEIGHT =  720;
const int IMG_WIDTH =  1280;

template <template <int,template<typename>class,int,typename> class block, int N, templateclass BN, typename SUBNET>
using residual = add_prev1>>;
template <template <int,template<typename>class,int,typename> class block, int N, templateclass BN, typename SUBNET>
using residual_down = add_prev2>>>>>;
template <int N, template <typename> class BN, int stride, typename SUBNET> 
using block  = BN>>>>;
template <int N, typename SUBNET> using ares      = relu>;
template <int N, typename SUBNET> using ares_down = relu>;
template <typename SUBNET> using alevel0 = ares_down<256,SUBNET>;
template <typename SUBNET> using alevel1 = ares<256,ares<256,ares_down<256,SUBNET>>>;
template <typename SUBNET> using alevel2 = ares<128,ares<128,ares_down<128,SUBNET>>>;
template <typename SUBNET> using alevel3 = ares<64,ares<64,ares<64,ares_down<64,SUBNET>>>>;
template <typename SUBNET> using alevel4 = ares<32,ares<32,ares<32,SUBNET>>>;
using anet_type = loss_metric128,avg_pool_everything<
    alevel0<
    alevel1<
    alevel2<
    alevel3<
    alevel4<
    max_pool<3,3,2,2,relu32,7,7,2,2,
    input_rgb_image_sized<150>
    >>>>>>>>>>>>;

int main(int argc, char** argv)
{
    if (argc == 1)
        {
            cout << "\nCall this program like this:" << endl;
            cout << "./this_is_who ../data/allface/0004_IR_allleft.jpg ../data/allface/0004_raw_allleft.raw" << endl;
            return 0;
        }
    
    const char *imgFile = argv[1];
    const char *DeepFile = argv[2];

    
    std::vectorfloat,0,1>> candidates_descriptors;
    deserialize("../candidates_descriptors.dat") >> candidates_descriptors;

    std::vector<string> candidates;
    deserialize("../candidates.dat") >> candidates;
   
    std::vector<int> locates;

    /* 输出人脸位置 返回识别结果 */
    string who = face_location(imgFile, locates, candidates_descriptors,candidates); 
    cout << "\nRECOGNITION RESULT：" << endl;
    cout << "This is " << who << endl;

    //深度图与红外图是水平翻转的
    locates[0] = IMG_WIDTH - locates[0] -locates[2];  

    /* 判断是否为活体 */
    liveness_detection( DeepFile, locates);

}

/* 函数 输出人脸位置 返回识别结果 */
string face_location(const char* imgFile,std::vector<int>&locates, std::vectorfloat,0,1>>&candidates_descriptors,std::vector<string>&candidates)
{   
    frontal_face_detector detector = get_frontal_face_detector(); // 人脸正脸检测器
    shape_predictor sp; //人脸关键点检测器
    anet_type net;  // 人脸识别模型

    deserialize("../model/shape_predictor_68_face_landmarks.dat") >> sp;
    deserialize("../model/dlib_face_recognition_resnet_model_v1.dat") >> net;
    
    cout << "\nprocessing image " << imgFile << endl;
    matrix img;
    load_image(img, imgFile);
    std::vector dets = detector(img);
    // cout << "Number of faces detected: " << dets.size() << endl;
    locates.push_back(dets[0].left());
    locates.push_back(dets[0].top());
    locates.push_back(dets[0].right() - dets[0].left());
    locates.push_back(dets[0].bottom() - dets[0].top());
    full_object_detection shape = sp(img, dets[0]);
    std::vector> faces;
    matrix face_chip;
    extract_image_chip(img, get_face_chip_details(shape,150,0.25), face_chip);
    faces.push_back(move(face_chip));
    std::vectorfloat,0,1>> face_descriptors = net(faces);
    float distance;
    float best_distance = length(face_descriptors[0]-candidates_descriptors[0]);
    size_t candidates_num = candidates_descriptors.size();
    int candidates_num_int = static_cast<int>(candidates_num);
    int best_k = 0;
    for (int k = 1; k < candidates_num_int; k++)
    {
        distance = length(face_descriptors[0]-candidates_descriptors[k]);
        if (distance < best_distance) 
        {
            best_distance = distance;
            best_k = k;
        }
    }
    string who;
    if (best_distance < 0.6) {
        who = candidates[best_k];
    }
    else{
        who = "Unknow";
    }
    return who;
}
/* 函数判断是否为活体 */
bool liveness_detection(const char *DeepFile,std::vector<int>&locates)
{
    const int ITER = 5000; // 随机取点次数
    const float PLANE_OR_NOT = 0.2; // 判断是否为平面的分界线
    const int SIGMA = 1;
    typedef unsigned short UNIT16;
    // 从.raw读取二进制16位数据到MatDATA
    UNIT16 MatDATA[IMG_HEIGHT*IMG_WIDTH];
    FILE *fp = NULL;
    fp = fopen( DeepFile, "rb" );
    size_t sizeRead = fread(MatDATA,sizeof(UNIT16),IMG_HEIGHT*IMG_WIDTH,fp);
    if (sizeRead != IMG_HEIGHT*IMG_WIDTH) {
        cout << "DeepFile open error!" << endl;
        return 0;
    }    
    fclose(fp);
    int n = 0;
    int i,j;
    int COL = locates[0],ROW = locates[1],FACE_WIDTH = locates[2],FACE_HEIGHT = locates[3]; //位置信息
    // txt :157 66 172 198 , 取行66：66+198,列取157：157+172
    int faceno0_num = FACE_HEIGHT*FACE_WIDTH -1; 
    int FaceDATA[3][100000];
    n = 0;
    for(i = 1;i< FACE_HEIGHT+1;i++)
        {
            for(j= 1;j< FACE_WIDTH+1;j++) 
            { 
                if (MatDATA[IMG_WIDTH*(ROW+i-2)+COL+j-2] == 0)
                {
                    faceno0_num -= 1; // 非零深度点个数为 faceno0_num+1
                    continue;
                }
                FaceDATA[1][n] = i;
                FaceDATA[0][n] = j; 
                FaceDATA[2][n] = MatDATA[IMG_WIDTH*(ROW+i-2)+COL+j-2];
                n += 1;
            } 
        } 

    int pretotal = 0;  // 符合拟合模型的数据的个数
    int x[3],y[3],z[3];  // 随机取三个点 
    srand((unsigned)time(NULL));
    float a,b,c;  // 拟合平面方程 z=ax+by+c
    // float besta,bestb,bestc;  // 最佳参数
    int rand_num[3];
    float check,distance;
    int total = 0;
    for(i = 0; i < ITER; i++)
    {
        do{
            rand_num[0] = std::rand()%faceno0_num; 
            rand_num[1] = std::rand()%faceno0_num; 
            rand_num[2] = std::rand()%faceno0_num; 
        }while(rand_num[0] == rand_num[1] || rand_num[0] == rand_num[2] || rand_num[1] == rand_num[2]);
        for(n = 0; n < 3; n++ )
        {
            x[n] = FaceDATA[0][rand_num[n]];
            y[n] = FaceDATA[1][rand_num[n]];
            z[n] = FaceDATA[2][rand_num[n]];
        }
        check = (x[0]-x[1])*(y[0]-y[2]) - (x[0]-x[2])*(y[0]-y[1]);
        if ( check == 0)  // 防止提示浮点数例外 (核心已转储)
        {
            i -= 1;
            continue;
        }
        a = ( (z[0]-z[1])*(y[0]-y[2]) - (z[0]-z[2])*(y[0]-y[1]) )*1.0/( (x[0]-x[1])*(y[0]-y[2]) - (x[0]-x[2])*(y[0]-y[1]) );
        if (y[0] == y[2])  // 防止提示浮点数例外 (核心已转储)
        {
            i -= 1;
            continue;
        }
        b = ((z[0] - z[2]) - a * (x[0] - x[2]))*1.0/(y[0]-y[2]);
        c = z[0]- a * x[0] - b * y[0];
        total = 0;
        for(n = 0; n < faceno0_num +1 ; n++ )
        {
            distance = fabs(a*FaceDATA[0][n] + b*FaceDATA[1][n] - 1*FaceDATA[2][n] + c*1);
            if (distance < SIGMA)
            {
                total +=1;
            }
        }
        if (total > pretotal)  // 找到符合拟合平面数据最多的拟合平面
        {
            pretotal=total;
            // besta = a;
            // bestb = b;
            // bestc = c;
        }
    }
    float pretotal_ary = pretotal *1.0/ faceno0_num ;
    cout << "\nLIVENESS DETECTION RESULT："  << endl;
    bool IS_FACE;
    if (pretotal_ary < PLANE_OR_NOT)
    {
        IS_FACE =  true;
        cout << "pretotal_ary = " << pretotal_ary  << " , Is FACE!" << endl;
    }
    else
    {
        IS_FACE = false;
        cout << "pretotal_ary = " << pretotal_ary  << " , Is not FACE!" << endl;
    }
    return  IS_FACE;
}

代码比较粗糙，应该以后也不会再改了……

ElasticFusion在ubuntu16.04+cuda8.0上的实现

2019-04-12T13:06:41.000Z

一、驱动与cuda安装

#安装驱动与cuda8.0
参考这篇：https://blog.csdn.net/ffcjjhv/article/details/89151382

二、配置

1、依赖包

1
2
3

sudo apt-get install cmake cmake-qt-gui git build-essential libusb-1.0-0-dev libudev-dev 
sudo apt-get install freeglut3-dev libglew-dev libsuitesparse-dev libeigen3-dev 
sudo apt-get install zlib1g-dev libjpeg-dev doxygen graphviz

2、openjdk-7-jdk

1
2
3

sudo add-apt-repository ppa:openjdk-r/ppa
sudo apt-get update
sudo apt-get install openjdk-7-jdk

3、OpenGL

1
2
3

sudo apt-get install build-essential libgl1-mesa-dev
sudo apt-get install freeglut3-dev
sudo apt-get install libglew-dev libsdl2-dev libsdl2-image-dev libglm-dev libfreetype6-dev

三、代码编译

#download ElasticFusion
GitHub地址：https://github.com/mp3guy/ElasticFusion ，解压到ElasticFusion/ElasticFusion-master

1	cd ElasticFusion

1、安装 Pangolin

git clone https://github.com/stevenlovegrove/Pangolin.git
cd Pangolin
mkdir build && cd build
cmake ../ -DAVFORMAT_INCLUDE_DIR="" -DCPP11_NO_BOOST=ON
make -j4
cd ../..

2、安装 OpenNI2

git clone https://github.com/occipital/OpenNI2.git
cd OpenNI2
make -j4
cd ..

3、配置 ElasticFusion

（1）build Core

cd ElasticFusion-master/Core
mkdir build && cd build
cmake ../src
make -j4
cd ../../

（2）build GPUTest

cd GPUTest
mkdir build && cd build
cmake ../src
make -j4
cd ../../

（3）build GUI

cd GUI
mkdir build && cd build
cmake ../src
make -j4
cd ../../

四、运行

1、数据集离线运行

下载数据集： http://www.doc.ic.ac.uk/~sleutene/datasets/elasticfusion/dyson_lab.klg ，放到ElasticFusion/ElasticFusion-master/GUI/build，并运行

1	./ElasticFusion -l dyson_lab.klg

#运行结果

2、在Kinect v1上实时运行

（1）build libFreenect

1
2
3

cd ElasticFusion
git clone https://github.com/OpenKinect/libfreenect
cd libfreenect

打开libfreenect/CMakeLists.txt，在33行cmake_minimum_required(VERSION 2.8.12)下一行添加

1	add_definitions(-std=c++11)

保存后关闭，命令行继续执行

mkdir build && cd build  
cmake .. -DBUILD_OPENNI2_DRIVER=ON  
make -j4
cp -L lib/OpenNI2-FreenectDriver/libFreenectDriver.so ${OPENNI2_DIR}/Bin/x64-Release/OpenNI2/Drivers   #OPENNI2_DIR需要修改

注：${OPENNI2_DIR}是OpenNI2的解压文件夹，比如我的在ElasticFusion文件夹，则

（2）Kinect v1接入

打开libfreenect文件夹，运行

1	sudo cp platform/linux/udev/51-kinect.rules /etc/udev/rules.d

重启后，插上kinect后，命令行运行lsusb，查看是否包含：Xbox camera，Xbox motor，Xbox audio

（3）修改GPUConfig.h

如果代码运行很慢且出现如下提示，需要修改修改GPUConfig.h

在ElasticFusion/ElasticFusion-master/GPUtest/build文件夹运行

1	./GPUTest ../

将最后4行添加到/ElasticFusion/ElasticFusion-master/Core/src/Utils/GPUConfig.h

（4）运行

打开ElasticFusion/ElasticFusion-master/GUI/build，运行

1	./ElasticFusion

#运行结果

BundleFusion在win10+vs2013+cuda8.0上的实现

2019-04-12T03:06:00.000Z

介绍

在深度相机室内实时稠密三维重建领域，BundleFusion是目前效果最好的开源算法框架。论文地址：https://arxiv.org/pdf/1604.01093.pdf
演示视频截取片断：

视频地址：https://www.youtube.com/watch?v=keIirXrRb1k
在演示视频中，structure sensor是卡在iPad上，将采集到的数据通过无线网络传给台式机（带GPU），匹配、优化和重建工作都是在台式机上运行，重建的结果再通过无线网络传到iPad上显示。
重建效果图：

一、配置

1、cuda8.0安装

#建议安装：cuda8.0，vs2013

#卸载cuda10.0
在控制面板/卸载程序，卸载掉所有带有NVIDIA的程序，卸载顺序不影响

#下载cuda8.0：https://developer.nvidia.com/cuda-80-ga2-download-archive ，并运行安装。

#验证安装成功，输入nvcc --version

2、DirectX SDK安装

下载地址：http://download.microsoft.com/download/A/E/7/AE743F1F-632B-4809-87A9-AA1BB3458E31/DXSDK_Jun10.exe ，运行安装。

#若运行安装出现错误 ErrorCode:s1023
解决办法1：

控制面板卸载以上两项，再重新安装DXSDK_Jun10.exe即可。

大部分通过这个方法可以解决，如果以上两项不存在或者卸载后仍不能解决问题（比如我），可能Microsoft Visual C++ 运行库安装有问题，得删除并重新安装 Microsoft Visual C++ 运行库，步骤如下：

1、控制面板卸载名称包含“Microsoft Visual C++”和“Redistributable”的所有程序
2、下载并安装以下所有软件：

注意：

每个下载的文件名均相同，因此在安装它之前，请确保不覆盖之前的文件。下载一个安装一个，然后再下载下一个并安装，依此类推。
- 64 位系统上需要 x86 和 x64 版本。32 位系统只需要 x86 版本。

3、重启后，控制面板卸载2010两项，再重新安装DXSDK_Jun10.exe，即可解决。

二、vs2013代码生成

BundleFusion GitHub地址：https://github.com/niessner/BundleFusion
配置过程主要参考这里

从GitHub上下载该BundleFusion，并解压，得到工程 BundleFusioin-master

1、mLib与 mLib external配置

mLib

下载地址：https://github.com/niessner/mLib ，解压后，替换掉目录 BundleFusion-master\external\mLib

mLib external

下载地址：https://www.dropbox.com/s/fve3uen5mzonidx/mLibExternal.zip?dl=0 ，解压后，放到 BundleFusioin-master 同级目录,网址访问不了的话可以用我传到网盘的mLibExternal.zip：链接：https://pan.baidu.com/s/1CJysQCHl4t7RPfvqliwfew 提取码：0x4t

最终目录结构：

bundlefusion
BundleFusion-master/
  external/
    mLib/ # this is the submodule you replaced
      data/
      src/
      [...]
  FriedLiver/
    [...]
    FriedLiver.sln
    [...]
mLibExternal/ # you downloaded this from Dropbox
  include
  libsWindows
  [...]

2、cuda设置

修改cuda版本

用VS2013打开 BundleFusion-master\FriedLiver\FriedLiver.sln 工程，如果cuda版本不是原代码设置的cuda7.0，就会出现如下错误：

修改 BundleFusion-master\FriedLiver\FriedLiver.vcxproj 文件，用vs code打开该文件，并修改如下两行：

再次打开就不会报错了。

显卡计算能力设置

选择适合你显卡的compute能力，显卡计算能力在这里查询
我的笔记本显卡NVIDIA GeForce MX150，计算能力与GeForce 940M等同，为5.0，在工程的配置选项中设置如下：

3、相机类型设置（以apt0.sens离线数据为例）

输入类型

输入数据可以为Kinect v1，Kinect v2，PrimeSenseSensor，IntelSensor，RealSense，StructureSensor以及SensorDataReader（离线数据）
具体可以查看FriedLiver.cpp中7-103行的内容

没有深度相机的，以离线数据office3.sens为例，下载地址：http://graphics.stanford.edu/projects/bundlefusion/

修改GlobalAppState.h

因为使用的是离线数据，将GlobalAppState.h中深度相机全部注释掉。

注：如果用深度相机（如：Kinect v1）实时运行，用哪个将哪个取消注释，并安装对应SDK。

4、生成FriedLiver.exe

修改为 Release 版本，然后选择 生成->生成解决方法
编译通过后，如下图：

在BundleFusion-master\FriedLiver\x64\Release中生成可执行文件FriedLiver.exe

三、运行与结果

1、配置文件修改

将BundleFusion-master\FriedLiver 目录下的 zParametersBundlingDefault.txt 和 zParametersDefault.txt 拷贝到 BundleFusion-master\FriedLiver\x64\Release

修改zParametersDefault.txt

用vs code打开 zParametersDefault.txt 配置文件，选择输入类型，这里使用离线数据，修改第2行，设置s_sensorIdx = 8 。如果用深度相机（如：Kinect v1）实时运行，修改为对应的序列号。

修改第49行，设置s_hashNumSDFBlocks = 100000

修改第58行，设置输入路径s_binaryDumpSensorFile = "../data/office3.sens"

将下载的office3.sens放置到BundleFusion-master\FriedLiver\x64\data

修改zParametersBundlingDefault.txt

双击运行后，若出现窗口崩溃或者没有响应直接跳出，如下图：

用vs code打开 zParametersBundlingDefault.txt 配置文件，修改第30行，设置s_maxNumImages = 400

2、运行结果

配置修改后，双击运行FriedLiver.exe

按下tab键，如下图所示，按照提示与软件进行交互，按下ctrl+2显示带颜色深度，按下ctrl+3显示彩色视频流，按下ctrl+9导出当前模型到FriedLiver\x64\Release\scans\scan.ply ，具体实现代码查看FriedLiver\Source\DepthSensing\DepthSensing.cpp

3、模型生成

运行结束后，BundleFusion-master\FriedLiver\x64\data\office3.sens同目录下生成office3.ply，用meshlab打开

4、在Kinect v1上的实时运行

安装 Kinect SDK v1.8

Kinect for Windows SDK v1.8
Kinect for Windows Developer Toolkit v1.8
下载后默认安装

设置Kinect v1输入

重新打开 BundleFusion-master\FriedLiver\FriedLiver.sln 工程，将GlobalAppState.h中第三行取消注释

选择 生成->生成解决方法，即可编译通过。

zParametersDefault.txt 配置文件，选择输入类型，这里使用Kinect v1，修改第2行，设置s_sensorIdx = 0

实时运行

插上Kinect v1，双击运行FriedLiver.exe

DynamicFusion在ubuntu16.04+显卡GT740+cuda8.0上的实现

2019-04-09T10:10:06.000Z

介绍

DynamicFusion构建了一个可以实时重建非刚性变形动态场景的系统，随着新的数据融合进模型当中，模型得到降噪、细节更加精细。

论文地址：http://grail.cs.washington.edu/projects/dynamicfusion/papers/DynamicFusion.pdf
GitHub地址：https://github.com/mihaibujanca/dynamicfusion
注意：这个项目是对论文的复现，但是目前尚未准确复现论文内容，运行速度仍然有待优化，10s/frame不满足实时运行，建议转换成离线数据，再进行运行。

这里记录DynamicFusion在ubuntu16.04+显卡GT740+cuda8.0上的实现。（虽然可以实现，但是GT740真的是太慢慢慢慢了…电脑是刚重装完系统的机子）

1、驱动与cuda安装

（1）驱动安装

a.驱动下载

#查看显卡型号

1	lspci \| grep -i nvidia

nvidia官网 https://www.geforce.cn/drivers 搜索显卡型号对应的驱动，下载（别用最新的）后放到home文件夹

b.禁用nouveau驱动

1	sudo gedit /etc/modprobe.d/blacklist.conf

在文本最后添加：

1 2	blacklist nouveau options nouveau modeset=0

然后执行：

1	sudo update-initramfs -u

重启后，屏幕分辨率可能不对不用管，命令行执行：lsmod | grep nouveau ，如果没有屏幕输出，说明禁用nouveau成功。

c.禁用X-Window服务

#注意：这会关闭图形界面，提前用手机或者笔记本看下面的步骤

1	sudo service lightdm stop

按Ctrl-Alt+F1进入命令行界面，输入用户名和密码登录。

d.命令行安装驱动

#给驱动run文件赋予执行权限：

1	sudo chmod +x NVIDIA-Linux-x86_64-384.59.run

#后面的参数不可省略：

1	sudo ./NVIDIA-Linux-x86_64-384.59.run –no-opengl-files

按照提示安装，回车确定，成功安装后在命令行输入：sudo service lightdm start，恢复到图形界面，此时屏幕分辨率恢复正常，重启。

e.驱动测试

1	sudo nvidia-smi

若列出GPU的信息列表，表示驱动安装成功。

（2）cuda7.5安装

cuda7.5可以使用命令行安装，到了cuda8.0以及往上就不行了

1 2	sudo apt-get update sudo apt-get install nvidia-cuda-dev nvidia-cuda-toolkit nvidia-nsight nvidia-prime

等待安装完成后，输入nvcc -V，检查是否安装成功。

2、环境配置

下载DynamicFusion代码：https://github.com/mihaibujanca/dynamicfusion
整个配置过程参考dynamicfusion-master/build.sh 文件（不要直接运行build.sh会有各种报错）

（1）apt-get install 依赖安装

1
2
3

sudo apt-get install cmake libvtk5-dev libsuitesparse-dev liblapack-dev --fix-missing
sudo apt-get install libblas-dev libgtk2.0-dev pkg-config libopenni-dev --fix-missing
sudo apt-get install libusb-1.0-0-dev wget zip clang --fix-missing

（2）安装gflags、glog、Eigen、Ceres

进入dynamicfusion-master文件夹的上一目录

安装gflags、glog、Eigen

#安装 gflags

git clone https://github.com/gflags/gflags.git
cd gflags
mkdir -p build/ && cd build
cmake .. && make 
cd ../../

#安装 glog

git clone https://github.com/google/glog.git
cd glog
mkdir -p build/ && cd build/
cmake .. && make
cd ../../

#安装 Eigen 3.3.4

wget http://bitbucket.org/eigen/eigen/get/3.3.4.tar.gz
tar -xf 3.3.4.tar.gz
cd eigen-eigen-5a0156e40feb
mkdir -p build && cd build
cmake ..
sudo make install
cd ../../

配置ceres-solver

#下载ceres-solver：https://github.com/ceres-solver/ceres-solver 并解压到dynamicfusion-master文件夹的上一目录 ，将ceres-solver-master重命名为ceres-solver

#配置 Ceres

cd ceres-solver
mkdir -p build/ && cd build/
cmake ..
make -j4
sudo make install
cd ../../

（3）安装OpenCV 2.4.13

注：opencv的下载过程非常非常慢，建议前天晚上下载，第二天再接着配置

git clone https://github.com/opencv/opencv
cd opencv/
git checkout 2.4.13.3
mkdir -p build && cd build
cmake -DWITH_VTK=ON -DBUILD_opencv_calib3d=ON -DBUILD_opencv_imgproc=ON -DWITH_CUDA=OFF ..
make -j4
sudo make install
cd ../../

（4）安装Boost

wget https://dl.bintray.com/boostorg/release/1.64.0/source/boost_1_64_0.tar.gz
tar -xf boost_1_64_0.tar.gz
cd boost_1_64_0
sudo ./bootstrap.sh
./b2
sudo ./b2 install
cd ..

删除掉无用的压缩包，最终目录如图

3、代码修改与dataset获取

（1）配置deps/terra

cd dynamicfusion-master/deps
wget https://github.com/zdevito/terra/releases/download/release-2016-03-25/terra-Linux-x86_64-332a506.zip
unzip terra-Linux-x86_64-332a506.zip
rm terra-Linux-x86_64-332a506.zip
mv terra-Linux-x86_64-332a506 terra

（2）配置deps/Opt

#下载Opt：https://github.com/niessner/Opt/tree/c6012e7e4c67fa3bea96161ba24fe88a2b79deed ，并解压到deps，重命名为Opt

1 2	cd Opt/API/ make -j4

（3）修改kfusion/src/warp_field.cpp

为了解决之后运行代码会出现的报错

1 2	.../dynamicfusion/kfusion/src/warp_field.cpp:158:10: error: ‘struct ceres::Solver::Options’ has no member named ‘num_threads_used’ options.num_threads_used = 8;

将第157行options.num_linear_solver_threads = 8;注释掉

（4）dataset下载

下载地址 https://www.dropbox.com/sh/qgy2n9bmioofqnj/AABUnT7pi2ECpxSi80EmXOXna?dl=0 （给的数据挺多的，如果网站上不去可以下载我传到百度云的数据，只传了作为demo的umbrella_data.zip）

umbrella_data.zip下载链接：https://pan.baidu.com/s/1PRf7-xl5vgj2SUQVNiuk-g ，提取码：25s1
下载后放置到dynamicfusion-master文件夹中，运行

mkdir -p data/umbrella/depth
mkdir -p data/umbrella/color

mv umbrella_data.zip data/umbrella
cd data/umbrella
unzip umbrella_data.zip
rm *.txt
mv *color*.png color/
mv *depth*.png depth/
rm umbrella_data.zip

4、运行

（1）编译

进入dynamicfusion-master文件夹，运行

1
2
3

mkdir -p build && cd build
cmake -DOpenCV_DIR=~/opencv/build -DBOOST_ROOT=~/boost_1_64_0/ -DOPENNI_INCLUDE_DIR=/usr/include/ni -DOpenCV_FOUND=TRUE ..
make -j4

（2）运行与报错

进入dynamicfusion-master文件夹，运行

1	./build/bin/dynamicfusion data/umbrella

运行后报错 llvm: No such file or directory ,查看这里：https://github.com/mihaibujanca/dynamicfusion/issues/54
升级cuda7.5到8.0能够解决

（3）升级cuda7.5到8.0

卸载cuda7.5

1	sudo apt-get autoremove nvidia-cuda-toolkit

安装cuda8.0

#下载cuda8.0：https://developer.nvidia.com/cuda-80-ga2-download-archive

#安装依赖

1	sudo apt-get install freeglut3-dev build-essential libx11-dev libxmu-dev libxi-dev libgl1-mesa-glx libglu1-mesa libglu1-mesa-dev

#安装cuda8.0

1 2	sudo chmod 777 cuda_8.0.61_375.26_linux.run sudo ./cuda_8.0.61_375.26_linux.run

执行后会先出现一个声明，需要阅读到100%才会开始安装，直接ctr+c跳过
按照提示输入回答就行，位置全部选择默认，注：第二个选择是否安装nvidia驱动时，一定要选择否
安装完依赖后，如果仍然提示

1 2	Installing the CUDA Toolkit in /usr/local/cuda-8.0 … Missing recommended library: libXmu.so

不用管

#添加环境变量

1	sudo gedit ~/.bashrc

将以下内容写入到~/.bashrc尾部：

1 2	export PATH=/usr/local/cuda-8.0/bin${PATH:+:${PATH}} export LD_LIBRARY_PATH=/usr/local/cuda-8.0/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

重启后，输入nvcc --version 测试是否安装成功

（4）运行与结果

1	sudo apt-get install nvidia-cuda-dev nvidia-cuda-toolkit nvidia-nsight nvidia-prime

#编译
进入dynamicfusion-master文件夹，运行

1
2
3

mkdir -p build && cd build
cmake -DOpenCV_DIR=~/opencv/build -DBOOST_ROOT=~/boost_1_64_0/ -DOPENNI_INCLUDE_DIR=/usr/include/ni -DOpenCV_FOUND=TRUE ..
make -j4

#运行
进入dynamicfusion-master文件夹，运行

1	./build/bin/dynamicfusion data/umbrella

#结果

DynamicFusion效果（项目视频）：

视频地址：https://www.youtube.com/watch?v=i1eZekcc_lM

刷题汇总（一）leetcode 精选50题 JavaScript答案总结

2019-03-11T12:58:24.000Z

题目来源

腾讯精选练习（50 题）

GitHub地址：https://github.com/zj19941113/LeetCode-50-JavaScript-Answers

2两数相加-33.0%-中等

https://leetcode-cn.com/problems/add-two-numbers/

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function(l1, l2) {
    var re = new ListNode(0); //0随便取，不会用到，只为了初始化
    var r=re;  //浅拷贝
    var carry=0;
    while(l1!=null || l2!=null){
        var x = l1==null? 0:l1.val;
        var y = l2==null? 0:l2.val;
        r.next=new ListNode((carry+x+y)%10);
        r=r.next;
        if(carry+x+y>9){
            carry=1;
        }else{
            carry=0;
        }
        if(l1!=null){
            l1=l1.next;
        }
        if(l2!=null){
            l2=l2.next;
        }
    }
    if(carry>0){
        r.next=new ListNode(1); //最高位进1
    } 
    return re.next;
};

4寻找两个有序数组的中位数-33.8%-困难

https://leetcode-cn.com/problems/median-of-two-sorted-arrays/

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number}
 */
var findMedianSortedArrays = function(a, b) {
    // 谁小谁移，移动k次，k中间
    var n = a.length;
    var m = b.length;
    var nm = n + m;
    var ni = 0,mi = 0,x,y; 

    while(ni + mi < nm ){  
        if(ni < n ){
            while(mi == m || a[ni] <= b[mi]){
                ni=ni+1;
                if(ni+mi == (nm+1)/2){ //总长奇
                    return a[ni-1];
                }
                if(ni+mi == nm/2){//总长偶
                    x = a[ni-1];
                    break;
                }
                if(ni+mi == (nm/2 + 1)){ 
                    y = a[ni-1];
                    return (x+y)/2
                }
            }
        }
        if(mi < m){
            while(ni == n || b[mi] <= a[ni]){
                mi = mi + 1;
                if(ni+mi == (nm+1)/2){
                    return b[mi-1];
                }
                if(ni+mi == nm/2){
                    x = b[mi-1];
                }
                if(ni+mi == (nm/2 + 1)){ 
                    y = b[mi-1];
                    return (x+y)/2
                }
            }
        }
    }
    return -1;
};

5最长回文子串-24.7%-中等

https://leetcode-cn.com/problems/longest-palindromic-substring/submissions/

/**
 * @param {string} s
 * @return {string}
 */
var longestPalindrome = function(s) {
    if (s==null&&s.length<1){
        return "";
    }
    var fir = 0;
    var las = 0;
    for(var i=0;i
        var lenl = getsub(s,i,i);
        var lenr = getsub(s,i,i+1);
        var len = Math.max(lenl,lenr);
        if(len>las-fir){
            fir = i - Math.floor((len-1)/2);
            las = i + Math.floor(len/2);
        }     
    }
    return s.slice(fir,las+1);
};

function getsub(s,l,r){
    while(l>=0&&r<=s.length-1&&s.charAt(l)==s.charAt(r)){
        l--;
        r++;
    }
    return r-l-1;
}

7整数反转-31.8%-简单

https://leetcode-cn.com/problems/reverse-integer/

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    var result = 0;
    var strx;
    var mayAns;
    if(x>0){
        strx = String(x);
        mayAns = Number(strx.split("").reverse().join(""));
        return mayAns<=Math.pow(2,31)-1?mayAns:0;
    }
    else{
        strx = String(-x);
        mayAns = -Number(strx.split("").reverse().join(""));
        return mayAns>=-Math.pow(2,31) ?mayAns:0;
    }
    return result;
};

8字符串转换整数 (atoi)-16.6%-中等

https://leetcode-cn.com/problems/median-of-two-sorted-arrays

/**
 * @param {string} str
 * @return {number}
 */
var myAtoi = function(str) {
    str = str.trim();
    var word = str.split(" ")[0];
    if(parseInt(word)){
        if(parseInt(word)>Math.pow(2,31)-1){
            return Math.pow(2,31)-1;
        };
        if(parseInt(word)<-Math.pow(2,31)){
            return -Math.pow(2,31);
        };
        return parseInt(word);
    }
    return 0;
};

9回文数-56.0%-简单

https://leetcode-cn.com/problems/palindrome-number/

/**
 * @param {number} x
 * @return {boolean}
 */
var isPalindrome = function(x) {
    if(x >= 0){
       var strx = String(x); 
       return strx == strx.split("").reverse().join("");
    }
    return false;
};

11盛最多水的容器-53.5%-中等

https://leetcode-cn.com/problems/container-with-most-water/

/**
 * @param {number[]} height
 * @return {number}
 */
var maxArea = function(height) {
    var maxs = 0;
    for (var i=0;i
        for (var j=i+1;j
            var tmp = Math.min(height[i],height[j])*(j-i);
            if(tmp>maxs){
                maxs = tmp;
            }
        }
    }
    return maxs;
};

14最长公共前缀-32.2%-简单

https://leetcode-cn.com/problems/longest-common-prefix/

/**
 * @param {string[]} strs
 * @return {string}
 */
var longestCommonPrefix = function(strs) {
    if(strs.length == 0){
        return "";
    }
    var mini = 0;
    for(var i=1;i
        if (strs[i].length
            mini = i;
        }
    }
    var result = "";
    for(let j=0;j
        for( i=0;i
            if(strs[mini].slice(0,j+1) != strs[i].slice(0,j+1)){
                return result;
            }
        }
        result =  strs[mini].slice(0,j+1); 
    }
    return result;
};

15三数之和-21.2%-中等

https://leetcode-cn.com/problems/3sum

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums) {
    nums.sort(function(a,b){return a-b});
    var ls = [];
    for (var i=0;i-2;i++) {
        if(nums[i]==nums[i-1]){ //i和前面一样，跳过
            continue;
        }
        for (var j=i+1;j-1;j++) {
            if(nums[j]==nums[j-1]&&j!=i+1){ //j和前面一样，且前面不是i，跳过
                continue;
            }
            for (var k=j+1;k
                if(nums[k]+nums[j]+nums[i] == 0){
                    ls.push([nums[i],nums[j],nums[k]]); //找到k跳出，不再往后
                    break;
                }
            }
        }
    }
    return ls;
};

16最接近的三数之和-39.0%-中等

https://leetcode-cn.com/problems/3sum-closest/

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var threeSumClosest = function(nums, target) {
    var len = nums.length;
    var minl = nums[0]+nums[1]+nums[2];
    for(var i=0;i-2;i++){
        for(var j=i+1;j-1;j++){
            for(var k=j+1;k
                var tmp = nums[i]+nums[j]+nums[k];
                if(Math.abs(tmp-target)<Math.abs(minl-target)){
                    minl = tmp;
                }
            }
        }
    }
    return minl;
};

20有效的括号-36.7%-简单

https://leetcode-cn.com/problems/valid-parentheses/

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
    if(s == null||s.length <1){
        return true;
    }
    var stack = [];
    for(var i=0;i
        if(s[i] == ""){
            continue;
        }
        if(stack.leng<1){
            stack.push(s[i]);
        }else if(stack[stack.length-1]=="("&&s[i]==")" ||stack[stack.length-1]=="{"&&s[i]=="}" ||stack[stack.length-1]=="["&&s[i]=="]"){
            stack.pop();
        }else{
            stack.push(s[i]);
        }
    }
    return stack.length<1;
};

21合并两个有序链表-52.9%-简单

https://leetcode-cn.com/problems/merge-two-sorted-lists/

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var mergeTwoLists = function(l1, l2) {
    var l3 = new ListNode(0);
    var l4 = l3;
    while(l1!=null && l2!=null){
        if(l1.val
            l4.next = l1;
            l1 = l1.next;
        }else{
            l4.next = l2;
            l2 = l2.next;
        }
        l4 = l4.next;
    }
    l4.next = l1==null?l2:l1;
    return l3.next;
};

23合并K个排序链表-43.8%-困难

https://leetcode-cn.com/problems/merge-k-sorted-lists/

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode[]} lists
 * @return {ListNode}
 */
var mergeKLists = function(lists) {
    var rl = null;
    for(var i=0;i
        rl = mergeTwoLists(lists[i],rl);
    }
    return rl;
};

var mergeTwoLists = function(l1, l2) {
    var l3 = new ListNode(0);
    var l4 = l3;
    while(l1!=null && l2!=null){
        if(l1.val
            l4.next = l1;
            l1 = l1.next;
        }else{
            l4.next = l2;
            l2 = l2.next;
        }
        l4 = l4.next;
    }
    l4.next = l1==null?l2:l1;
    return l3.next;
};

26删除排序数组中的重复项-42.9%-简单

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/

/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function(nums) {
    for(var i=0;i
        var j=1;
        while(nums[i] == nums[i+j]){
            ++j;
        }
        if(j!=1){
            nums.splice(i,j-1);
        }
    }
    return nums.length;
};

33搜索旋转排序数组-35.8%-中等

https://leetcode-cn.com/problems/search-in-rotated-sorted-array/

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
    return searchs(nums, 0, nums.length-1, target);
};

function searchs(nums,l,h,target){
    //搜不到返回-1，搜到了返回target
    if (l > h){
        return -1;
    } 
    var mid = Math.floor((l + h)/2);//[0,1,2,4,5,6,7]
    if(nums[mid] == target){
        return mid;
    }
    if(nums[mid] < nums[h]){ //旋转在左 [6,7,0,1,2,4,5]
        if(nums[mid]
            return searchs(nums,mid+1,h,target);//在右，右顺序
        }else{
            return searchs(nums,l,mid-1,target);//不在右
        }
    }else{ //旋转在右 [2,4,5,6,7,0,1]
        if(nums[l]<=target&&target
            return searchs(nums,l,mid-1,target);//在左，左顺序
        }else{
            return searchs(nums,mid+1,h,target);//不在右
        }
    }
}

43字符串相乘-37.9%-中等

https://leetcode-cn.com/problems/multiply-strings/

/**
 * @param {string} num1
 * @param {string} num2
 * @return {string}
 */
var multiply = function(num1, num2) {
    var res = "";
    var len1 = num1.length;
    var len2 = num2.length;
    for(var i=0;i
        for(var j=0;j
            var base = Array(i+j+1).join(0);//i+j个0  eg:"00"  //逐位相乘
            var tmp = String(Number(num1[len1-1-i])*Number(num2[len2-1-j])) + base;
            res = addstr(res,tmp);
        }
    }
    while(res[0] == 0 && res.length > 1){//"002" -> "2"
        res = res.slice(1);
    }
    return res;
};

function addstr(s1, s2) { //字符串相加
    var re = "";
    if(s1.length>=s2.length){
        s2 =  Array(s1.length-s2.length+1).join(0) + s2;
    }else{
        s1 = Array(s2.length-s1.length+1).join(0) + s1;
    }
    var flag = 0;
    for(let i=0;i
        var t = Number(s1[s1.length - 1 - i]) + Number(s2[s1.length - 1 - i]) + flag;
        if(t < 10){
            re = String(t).concat(re);
            flag = 0;
        }else{
            re = String(t-10).concat(re);
            flag = 1;
        }
    }
    return flag == 0? re:"1"+re;
};

46全排列-66.7%-中等

https://leetcode-cn.com/problems/permutations/

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var permute = function(nums) {
    if(nums.length == 0){
        return [[]];
    }
    if(nums.length == 1){
        var re = [];
        re.push(nums);
        return re;
    }
    var nums1 = permute(nums.slice(1));
    var num0 = nums[0];
    var result = [];
    for(var i=0;i
        for(var j=0;j1;j++){
            var tmp = nums1[i].concat();
            tmp.splice(j,0,num0);
            result.push(tmp);
        }
    }
    return result;
};

53最大子序和-42.9%-简单

https://leetcode-cn.com/problems/maximum-subarray/

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSubArray = function(nums) {
    var sum = 0;
    var maxsum = nums[0];
    for(var i=0;i
        sum +=nums[i];
        if(sum > maxsum){
            maxsum = sum;
        } 
        if(sum < 0){
            sum = 0;
        }
    }
    return maxsum;
};

54螺旋矩阵-34.0%-中等

https://leetcode-cn.com/problems/spiral-matrix/

/**
 * @param {number[][]} matrix
 * @return {number[]}
 */
var spiralOrder = function(matrix) {
    var arr = [];
    while(!(matrix.length == 0||matrix[0].length == 0)){
        var tmp = matrix.shift(); //剪第一行
        arr = arr.concat(tmp);
        if(matrix.length == 0||matrix[0].length == 0){ //[]   [[],[]]
            return arr;
        }
        for(var i=0;i//剪最后一列
            var tmp = matrix[i].pop();
            arr.push(tmp);
        }
        if(matrix.length == 0||matrix[0].length == 0){
            return arr;
        }
        var tmp = matrix.pop().reverse();//剪最后一行
        arr = arr.concat(tmp);
        if(matrix.length == 0||matrix[0].length == 0){
            return arr;
        }
        for(var i=0;i//剪第一列
            var tmp = matrix[matrix.length-1-i].shift();
            arr.push(tmp);
        }
    }
    return arr;
};

59螺旋矩阵II-71.1%-中等

https://leetcode-cn.com/problems/spiral-matrix-ii/

/**
 * @param {number} n
 * @return {number[][]}
 */
var generateMatrix = function(n) {
    var arr = [];
    for(var i = 0; i < n; i++) {
        arr.push(new Array(n).fill(0));//创建n*n零矩阵
    }
    var c = 1;
    var i = 0;
    while(c <= n*n){
        for(var j=i;j//第一行
            arr[i][j] = c++;
        }
        for(var j=i+1;j//最后一列
            arr[j][n-i-1] = c++;
        }
        for(var j=i+1;j//最后一行
            arr[n-i-1][n-j-1] = c++;
        }
        for(var j=i+1;j-1;j++){//第一列
            arr[n-j-1][i] = c++;
        }
        i++;
    }
    return arr;
};

61旋转链表-37.5%-中等

https://leetcode-cn.com/problems/rotate-list/

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
var rotateRight = function(head, k) {
    if(head == null||k==0){
        return head;
    }
    var h = head;
    var len = 1;//总长
    while(h.next !=null ){
        ++len;
        h = h.next;
    }
    if(k % len == 0){//不用旋转 head本身
        return head;
    }
    if(k > len){//需旋转
        k = k % len;
    }
    len = len - k;
    var ln = new ListNode(0);//0->1->2->3->NULL
    var n = ln; 
    while(len != 0){
        n.next = head;
        n = n.next;
        head = head.next;
        --len;
    }
    n.next = null;
    var r = head;
    var lr = r;
    while(head.next != null){
        lr = head;
        head = head.next;
        lr = lr.next;
    }
    lr.next = ln.next
    return r;
};

62不同路径-52.6%-中等

https://leetcode-cn.com/problems/unique-paths/

/**
 * @param {number} m
 * @param {number} n
 * @return {number}
 */
var uniquePaths = function(m, n) {
    var dp = [];
    for(var i=0;i//创建m*n零矩阵
        dp.push(new Array(n).fill(0));
    }
    for(var i=0;i
        for(var j=0;j
            if(i==0||j==0){
                dp[i][j] = 1;
            }
            else{
                dp[i][j] = dp[i-1][j]+dp[i][j-1]
            }
        }
    }
    return dp[m-1][n-1];
};

70爬楼梯-44.5%-简单

https://leetcode-cn.com/problems/climbing-stairs/

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n) {
    if(n==1){
        return 1;
    }
    if(n==2){
        return 2;
    }
    var i = 1;
    var j = 2;
    for(var k=0;k-2;k++){
        var tmp = i + j;
        i = j;
        j = tmp;
    }
    return j;
};

78子集-71.6%-中等

https://leetcode-cn.com/problems/subsets/

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var subsets = function(nums) {
    var arr = [];
    arr.push([]);
    for(var i=0;i
        var tmp = []; //tmp深拷贝arr
        for(var k=0;k
            tmp[k] = arr[k].slice(0);
        }
        for(var j=0;j
            tmp[j].push(nums[i]);
            arr.push(tmp[j]);
        }
    }
    return arr;
};

88合并两个有序数组-43.0%-简单

https://leetcode-cn.com/problems/merge-two-sorted-lists/

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var mergeTwoLists = function(l1, l2) {
    var l3 = new ListNode(0);
    var l4 = l3;
    while(l1!=null && l2!=null){
        if(l1.val
            l4.next = l1;
            l1 = l1.next;
        }else{
            l4.next = l2;
            l2 = l2.next;
        }
        l4 = l4.next;
    }
    l4.next = l1==null?l2:l1;
    return l3.next;
};

89格雷编码-62.7%-中等

https://leetcode-cn.com/problems/gray-code/

/**
 * @param {number} n
 * @return {number[]}
 */
// 000 001 011 010  ——
//                    |
// 100 101 111 110 <——
var grayCode = function(n) {
    if(n == 0){
        return [0];
    }
    var tmp = grayCode(n-1).concat();//深拷贝
    for(var i=0;i
        tmp[i] += Math.pow(2,n-1);
    }
    tmp.reverse();
    return grayCode(n-1).concat(tmp);
};

104二叉树的最大深度-67.4%-简单

https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */

var maxDepth = function(root) {
    if(root == null){
        return 0;
    }
    var l_height = maxDepth(root.left);
    var r_height = maxDepth(root.right);
    return Math.max(l_height,r_height) + 1;
};

121买卖股票的最佳时机-48.5%-简单

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    var maxtmp = 0;
    for(var i=0;i
        for(var j=i+1;j
            if(prices[j]-prices[i]>maxtmp){
                maxtmp = prices[j]-prices[i];
            }
        }   
    }
    return maxtmp;
};

122买卖股票的最佳时机II-51.6%-简单

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    var maxtmp = 0;
    for(var i=0;i-1;i++){  
        if (prices[i]1]){
            maxtmp += prices[i+1]-prices[i];
        }
    }
    return maxtmp;
};

124二叉树中的最大路径和-33.8%-困难

https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxPathSum = function(root) {
    var len = -Number.MAX_VALUE;
    submax(root);
    function submax(t){
        if(t == null){
            return 0;
        }
        var l = Math.max(submax(t.left),0);
        var r = Math.max(submax(t.right),0);
        if(t.val + l + r > len){
            len = t.val + l + r;
        }
        return Math.max(l,r) + t.val;
    }
    return len;
};

136只出现一次的数字-59.1%-简单

https://leetcode-cn.com/problems/single-number/

/**
 * @param {number[]} nums
 * @return {number}
 */
var singleNumber = function(nums) {
    // 交换律：a ^ b ^ c  <=> a ^ c ^ b,俩两相同的移到一起
    // 相同的数异或为0: n ^ n => 0,只剩下单个的了
    // 任何数于0异或为任何数 0 ^ n => n
    var s = 0;
    for(var i=0;i
        s = s^nums[i];
    }
    return s;
};

141环形链表-35.5%-简单

https://leetcode-cn.com/problems/linked-list-cycle

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
 
/**
 * @param {ListNode} head
 * @return {boolean}
 */
var hasCycle = function(head) {
    var slow = head, fast = head;
    while(fast && fast.next){
        slow = slow.next;
        fast = fast.next.next;
        if(slow == fast){
            return true;
        }
    }
    return false;
};

142环形链表II-34.8%-中等

https://leetcode-cn.com/problems/linked-list-cycle-ii/

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var detectCycle = function(head) {
    var slow = head,fast = head;
    var isloop = false;
    while(fast && fast.next){
        slow  = slow.next;
        fast = fast.next.next;
        if(slow == fast){//相遇
            isloop = true;
            break;
        }
    }
    if(isloop){
        var l  = head;
        while(l != slow){
            l = l.next;
            slow = slow.next;
        }
        return slow;
    }
    return null;
};

146LRU缓存机制-39.0%-困难

https://leetcode-cn.com/problems/lru-cache/

/**
 * @param {number} capacity
 */

/**
1.新加入的数据
            ————> ___ 头 <—————
                  ___          |
                  ___          |2.被访问的数据
                  ___     —————
                  ___
                  ___
            <———— ___ 尾
3.淘汰的数据
*/

var LRUCache = function(capacity) {
    this.size = capacity;
    this.map = {};
    this.list = []; 
};

/** 
 * @param {number} key
 * @return {number}
 */
LRUCache.prototype.get = function(key) {
    if(this.map[key] != null){
        this.list.splice(this.list.indexOf(key),1);//更新list
        this.list.unshift(key);
        return this.map[key];
    }
    return -1;
};

/** 
 * @param {number} key 
 * @param {number} value
 * @return {void}
 */
LRUCache.prototype.put = function(key, value) {
    var tmp = this.list.indexOf(key);
    if(tmp != -1){ //key已存在，更新list
        this.list.splice(tmp,1);
    }
    else{ //key不存在
        if(this.list.length == this.size){ //栈满
            var d = this.list.pop();
            this.map[d] = null;
        }   
    }
    this.list.unshift(key);
    this.map[key] = value;
};

/** 
 * Your LRUCache object will be instantiated and called as such:
 * var obj = Object.create(LRUCache).createNew(capacity)
 * var param_1 = obj.get(key)
 * obj.put(key,value)
 */

148排序链表-58.6%-中等

https://leetcode-cn.com/problems/sort-list/

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var sortList = function(head) {
    if (!head || !head.next){
        return head;
    } 
    var slow = head,bk = head,fast = head;
    while(fast && fast.next ){
        bk = slow;
        slow = slow.next;
        fast = fast.next.next;
    }
    bk.next = null;
    var l1 = sortList(head);//中分，归并
    var l2 = sortList(slow);
    return merge(l1,l2);
};

function merge(l1,l2){//合并有序链表
    var l = new ListNode(0);
    var rl = l;
    while(l1 && l2){
        if(l1.val < l2.val){
            rl.next = l1;
            l1 = l1.next;
        }else{
            rl.next = l2;
            l2 = l2.next;
        }
        rl = rl.next;
    }
    rl.next = l1==null?l2:l1;
    return l.next;
}

155最小栈-47.7%-简单

https://leetcode-cn.com/problems/min-stack/

/**
 * initialize your data structure here.
 */
var MinStack = function() {
    this.arr = [];
};

/** 
 * @param {number} x
 * @return {void}
 */
MinStack.prototype.push = function(x) {
    this.arr.push(x);
};

/**
 * @return {void}
 */
MinStack.prototype.pop = function() {
    this.arr.pop();
};

/**
 * @return {number}
 */
MinStack.prototype.top = function() {
    return this.arr[this.arr.length-1];
};

/**
 * @return {number}
 */
MinStack.prototype.getMin = function() {
    return Math.min.apply( {}, this.arr );
};

/** 
 * Your MinStack object will be instantiated and called as such:
 * var obj = Object.create(MinStack).createNew()
 * obj.push(x)
 * obj.pop()
 * var param_3 = obj.top()
 * var param_4 = obj.getMin()
 */

160相交链表-37.2%-简单

https://leetcode-cn.com/problems/intersection-of-two-linked-lists/

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} headA
 * @param {ListNode} headB
 * @return {ListNode}
 */
var getIntersectionNode = function(headA, headB) {
    if(headA == null || headB == null){
        return null;
    }
    var pA = headA;
    var pB = headB;
    while(pA != pB) {
        pA = pA == null ? headB : pA.next;
        pB = pB == null ? headA : pB.next;
    }
    return pA;
};

169求众数-58.0%-简单

https://leetcode-cn.com/problems/majority-element/

/**
 * @param {number[]} nums
 * @return {number}
 */
var majorityElement = function(nums) {
    nums.sort();
    return nums[Math.floor(nums.length/2)];
};

206反转链表-58.6%-简单

https://leetcode-cn.com/problems/reverse-linked-list/

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var reverseList = function(head) {
    var l  = null;
    while(head != null){
        var newl = new ListNode(head.val);
        var tmp = l;
        l = newl;
        l.next = tmp;
        head = head.next;
    }
    return l;   
};

215数组中的第K个最大元素-56.6%-中等

https://leetcode-cn.com/problems/kth-largest-element-in-an-array/

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var findKthLargest = function(nums, k) {
    return fastkmax(nums,0,nums.length-1,k);
};

function fastkmax(n,l,r,k){
    var mid = partiton(n,l,r);//排序 左边都是比mid小的，右边都是比mid大的
    var rk = r - mid + 1;
    if(rk == k){
        return n[mid];
    }
    if(rk > k){
        return fastkmax(n,mid + 1,r,k);
    }
    return fastkmax(n,l,mid - 1,k -rk );
}

function partiton(n,l,r){//一次快排
    var base = n[l];
    var i = l,j = r,tmp;
    while(i < j){
        while(n[j] >= base && i < j){
            j--;
        }
        while(n[i] <= base && i < j){
            i++;
        }
            tmp = n[i];
            n[i] = n[j];
            n[j] = tmp;
    }
    n[l] = n[i];
    n[i] = base;
    return i;
 }

217存在重复元素-47.0%-简单

https://leetcode-cn.com/problems/contains-duplicate/

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {
    nums.sort();
    for(var i=0;i-1;i++){
        if(nums[i]==nums[i+1]){
            return true;
        }
    }
    return false;
};

230二叉搜索树中第K小的元素-62.0%-中等

https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst/

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} k
 * @return {number}
 */
var kthSmallest = function(root, k) {
    var list = [];
    order(root,list);
    return list[k-1];
};
function order(root,list){//中序遍历
    if(!root){
        return;
    }
    order(root.left,list);
    list.push(root.val);
    order(root.right,list);
}

231 2的幂-44.3%-简单

https://leetcode-cn.com/problems/power-of-two/

/**
 * @param {number} n
 * @return {boolean}
 */
var isPowerOfTwo = function(n) {
    if(n == 0){
        return false;
    }
    if(n == 1){
        return true;
    }
    return n%2==0?isPowerOfTwo(n/2):false;
};

235二叉搜索树的最近公共祖先-56.9%-简单

https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
    // 二叉搜索树(二叉排序树):若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值;
    var res = null;
    lca(root, p , q);
    function lca(root, p, q){
        if((root.val - p.val)*(root.val - q.val) <= 0){ //root为p、q根节点
            res = root;
        }else if(root.val < p.val && root.val < q.val){ //都在右子树
            lca(root.right, p , q);
        }else{
            lca(root.left, p , q);
        }
    }
    return res;
};

236二叉树的最近公共祖先-50.4%-中等

https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
    if(!root){
        return null;
    }
    if(root == p || root == q){
        return root;
    }
    var l = lowestCommonAncestor(root.left,p,q)//左支存在一个的位置
    var r = lowestCommonAncestor(root.right,p,q)
    if(l && r){//左支有一个，右支有一个
        return root;
    }
    if(l){//右没有，都在左，先找到的即为根节点
        return l;
    }
    if(r){
        return r;
    }
    return null;
};

237删除链表中的节点-69.4%-简单

https://leetcode-cn.com/problems/delete-node-in-a-linked-list/

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} node
 * @return {void} Do not return anything, modify node in-place instead.
 */
var deleteNode = function(node) {
    node.val = node.next.val;
    node.next = node.next.next;
};

238除自身以外数组的乘积-58.8%-中等

https://leetcode-cn.com/problems/product-of-array-except-self/

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var productExceptSelf = function(nums) {
    var arr = [];
    var l = 1, r = 1;
    for(var i=0;i//arr[i] i左边数乘积
        arr[i] = l;
        l *= nums[i];
    }
    for(var j=nums.length-1;j>=0;j--){
        arr[j] *= r;
        r *= nums[j];
    }
    return arr;
};

292Nim游戏-66.4%-简单

https://leetcode-cn.com/problems/nim-game/

/**
 * @param {number} n
 * @return {boolean}
 */
var canWinNim = function(n) {
    return n%4 == 0?false:true;
};

344反转字符串-65.1%-简单

https://leetcode-cn.com/problems/reverse-string/

/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify s in-place instead.
 */
var reverseString = function(s) {
    for(var i=1;i
        var tmp = s.splice(i,1)[0];
        s.unshift(tmp);
    }
};

557反转字符串中的单词III-63.5%-简单

https://leetcode-cn.com/problems/reverse-words-in-a-string-iii/

/**
 * @param {string} s
 * @return {string}
 */
var reverseWords = function(s) {
    var arr = s.split(" ");
    for(var i=0;i
        arr[i] = arr[i].split("").reverse().join("");
    }
    return arr.join(" ");
};

setTimeout、Promise、Async/Await 异步机制事件循环

2019-02-22T12:48:32.000Z

javascript是一门单线程语言

将任务分为两类：

同步任务
异步任务

打开网站时，网页的渲染过程就是一大堆同步任务，比如页面骨架和页面元素的渲染。而像加载图片音乐之类占用资源大耗时久的任务，就是异步任务。

同步的进入主线程，异步的进入Event Table并注册函数。当指定的事情完成时，Event Table会将这个函数移入Event Queue。主线程内的任务执行完毕为空，会去Event Queue读取对应的函数，进入主线程执行。上述过程会不断重复，也就是常说的Event Loop(事件循环)。

js引擎存在monitoring process进程，会持续不断的检查主线程执行栈是否为空，一旦为空，就会去Event Queue那里检查是否有等待被调用的函数。

举些例子：

1、setTimeout

console.log('script start')//1. 打印 script start
setTimeout(function(){
    console.log('settimeout')// 3. 打印 settimeout
})
console.log('script end')//2. 打印 script start

输出顺序：script start->script end->settimeout

2、Promise

Promise本身是同步的立即执行函数，当在executor中执行resolve或者reject的时候, 此时是异步操作，会先执行then/catch等，当主栈完成后，才会去调用resolve/reject中存放的方法执行，打印p的时候，是打印的返回结果，一个Promise实例。

console.log('script start')  //1. 打印 script start
let promise1 = new Promise(function (resolve) {
    console.log('promise1')  //2. 打印 promise1
    resolve()
    console.log('promise1 end')  //3. 打印 promise1 end
}).then(function () {
    console.log('promise2')  //5. 打印 promise2
})
console.log('script end')  //4. 打印 script end

// 输出顺序: script start->promise1->promise1 end->script end->promise2->settimeout

3、async await

async function async1(){
   console.log('async1 start');  //2. 打印 async1 start
   await async2();
   console.log('async1 end')  //5. 打印 async1 end
}
async function async2(){
   console.log('async2')  //3. 打印 async2
}
console.log('script start');  //1. 打印 script start
async1();
console.log('script end')  //4. 打印 script end

// 输出顺序：script start->async1 start->async2->script end->async1 end

同时有setTimeout、Promise、Async/Await ，执行顺序又是什么？引入

macro-task(宏任务)：包括整体代码script，setTimeout，setInterval
micro-task(微任务)：Promise，process.nextTick

进入整体代码(宏任务)后，开始第一次循环。接着执行所有的微任务。然后再次从宏任务开始，找到其中一个任务队列执行完毕，再执行所有的微任务。

setTimeout(function() {
    console.log('setTimeout');  //4. 打印 setTimeout
})
new Promise(function(resolve) {
    console.log('promise');  //1. 打印 promise
}).then(function() {
    console.log('then');  //3. 打印 then
})
console.log('console');  //2. 打印 console

// 输出顺序：promise->console->then->setTimeout

先遇到setTimeout，那么将其回调函数注册后分发到宏任务Event Queue。
接下来遇到了Promise，new Promise立即执行，then函数分发到微任务Event Queue。
遇到console.log()，立即执行。
整体代码script作为第一个宏任务执行结束，发现了then在微任务Event Queue里面，执行。
第一轮事件循环结束了，从宏任务Event Queue开始第二轮循环。发现了宏任务EventQueue中setTimeout对应的回调函数，立即执行。
结束。

再来分析两个案例：

console.log('1');  //1. 打印 1
 
setTimeout(function() {
    console.log('2');  //5. 打印 2
    process.nextTick(function() {
        console.log('3');  //7. 打印 3
    })
    new Promise(function(resolve) {
        console.log('4');  //6. 打印 4
        resolve();
    }).then(function() {
        console.log('5')  //8. 打印 5
    })
})

process.nextTick(function() {
    console.log('6');  //3. 打印 6
})

new Promise(function(resolve) {
    console.log('7');  //2. 打印 7
    resolve();
}).then(function() {
    console.log('8')  //4. 打印 8
})
 
setTimeout(function() {
    console.log('9');  //9. 打印 9
    process.nextTick(function() {
        console.log('10');  //11. 打印 10
    })
    
    new Promise(function(resolve) {
        console.log('11');  //10. 打印 11
        resolve(); 
    }).then(function() {
        console.log('12')  //12. 打印 12
    })
})

// 输出顺序：1，7，6，8，2，4，3，5，9，11，10，12

async function async1() {
    console.log('async1 start')  //2. 打印 async1 start
    await async2()
    console.log('async1 end')  //7. 打印 async1 end
}
async function async2() {
    console.log('async2')  //3. 打印 async2
}

console.log('script start')  //1. 打印 script start
setTimeout(function () {
    console.log('settimeout')  //8. 打印 settimeout
})
async1()
new Promise(function (resolve) {
    console.log('promise1')  //4. 打印 promise1
    resolve()
}).then(function () {
    console.log('promise2')  //6. 打印 promise2
})
console.log('script end')  //5. 打印 script end

// 输出顺序：script start->async1 start->async2->promise1->script end->promise2->async1 end->settimeout