简介

Image from geeksforgeeks

在数组中，将无序部分依次插入有序部分，得到一个有序数组。

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <iostream>
#include <vector>

using namespace std;

void InsertSort(vector<int>& nums){
int len=nums.size();
if(len==0 || len==1) return;
int key=0;
int j=0;
for(int i=1;i<len;i++){
key=nums[i];
j=i;
while((j>=1) && (nums[j-1]>key)){
nums[j]=nums[j-1];
j--;
}
nums[j]=key;
}
}

int main(){
int tmp;
vector<int> arr;
cout<<"Please type the array you wat to sort:"<<endl;
while(cin>>tmp){
arr.push_back(tmp);
}
InsertSort(arr);
for(auto& x:arr){
cout<<x<<" ";
}
return 0;
}

为了更好地了解排序的过程，在实现过程中可以添加一些排序过程，输出排序中数组的值。

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

void InsertSort(vector<int>& nums){
int len=nums.size();
if(len==0||len==1) return;
int tmp=0;
for(int i=1;i<len;i++){
tmp=nums[i];
int j=i;
cout<<endl;
cout<<"The "<<i<<"th round:"<<endl;
while( (j>=1) && (tmp<nums[j-1]) ){
nums[j]=nums[j-1];
j--;
for(auto& x:nums){
cout<<x<<" ";
}
cout<<endl;
}
nums[j]=tmp;
for(auto& x:nums){
cout<<x<<" ";
}
cout<<endl;
cout<<endl;
}
}

比如我们输入1 5 2 4 3， 结果如下：

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

Please type the array you wat to sort:
1 5 2 4 3 ^X

The 1 round:
1 5 2 4 3


The 2 round:
1 5 5 4 3
1 2 5 4 3


The 3 round:
1 2 5 5 3
1 2 4 5 3


The 4 round:
1 2 4 5 5
1 2 4 4 5
1 2 3 4 5

Final anwers:
1 2 3 4 5

归并排序 Merge Sort

简介

Image from geeksforgeeks

“每次遇见了不会的排序时，一定不是自己脑子太笨了，肯定是规模太大了”——Prof.zly

归并排序采用分治思想，每次近乎二分，规模太大递归继续分，当只剩一个数时，就很容易比较，后递归合并结果。整个过程可以看作是递归搜索树的后序遍历过程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;


void merge(vector<int>& nums, int l, int m, int r){
int len1=m-l+1, len2=r-m;
vector<int> arr1(len1);
vector<int> arr2(len2);
int i=0,j=0;
for(i=0;i<len1;i++){
arr1[i]=nums[l+i];
}
for(j=0;j<len2;j++){
arr2[j]=nums[m+1+j];
}
i=0;
j=0;
int len=r-l+1;
int k=l;

while(i<len1 && j<len2){
if(arr1[i]<arr2[j]){
nums[k]=arr1[i];
i++;
}
else{
nums[k]=arr2[j];
j++;
}
k++;
}

while(i<len1){
nums[k]=arr1[i];
i++;
k++;
}
while(j<len2){
nums[k]=arr2[j];
j++;
k++;
}
}

void mergesort(vector<int>& nums,int l,int r){//l->left, r-> right
if(l>=r){
return;
}
int m=floor((l+r)/2);//m-> middle
mergesort(nums,l,m);
mergesort(nums,m+1,r);
merge(nums,l,m,r);
}

int main(){
vector<int> arr;
int tmp=0;
cout<<"Please input the array you want to sort:"<<endl;
while(cin>>tmp){
arr.push_back(tmp);
}
mergesort(arr,0,arr.size()-1);
for(auto& x:arr){
cout<<x<<" ";
}
return 0;
}

从Fibonacci数列讲起

​ Fibonacci数列在各种科目的教材中出现的次数很多，多为引出递归这一思想的样例，大家都比较熟悉，而此处，我用这一例子来阐述动态规划的基本思想、方法。

我们已知Fibonacci数列性质如下：

一般的递归解法如下：

1
2
3
4
5
6
7

int F(int n)
{
    if(n<0)return -1;//假设非法输入返回-1
if(n==0)return 0;
    if(n==1)return 1;
    return F(n-1)+F(n-2);
}

​ 但是递归的方法显然会出现重复计算（比如计算$F(3)=F(2)+F(1)=(F(1)+F(0))+F(1)$ ,当n更大时，重复计算更多)，时间复杂度为$O((\frac{1+\sqrt{5}}{2})^n)$（时间复杂度的详细计算可以自行搜索），明显不是一个好的算法。

动态规划——递归+重复值的记录

​ 很明显，改进递归算法的方向之一是减少重复计算，如何解决？我们用数组的形式记录之前已经计算过的值。

​ 通过简单的改进，具有简单递归思想的算法如下：

1
2
3
4
5
6
7
8
9
10

int F(int n)
{
    if(n<0) return -1;//假设非法输入返回-1
    vector<int> fib(n+1,0);
    fib[1]=1;
    for(int i=2;i<=n;i++){
        fib[i]=fib[i-1]+fib[i-2];
    }
    return fib[n];
}

​ 用fib数组来储存之前计算过的斐波那契数，不用再递归求解。由于循环中$i$由小到大，所以我们能够保证在求解$fib[i]$时，$fib[i-1], fib[i-2]$已经被求解出来。

动态规划思想简括

​ 所以动态规划的思想可以简单地概括为：

• recursion: 问题本质可以数学化为递归数列的求解，能找到相应的递推公式

• memorization: 通过数组或其他变量来存储已经计算过的项，减少重复计算

所以在

1.对问题最有解法可用于子问题（recursion）。

2.子问题与原问题有相交（overlap），且递归的解包含子问题的解且重复多次（可用memorization）。

两者同时成立时，可以考虑用DP解决该问题。

如果理解的话，尝试一下自己能否独立写出$leetcode$上这道$Fibonacci$数列的题呢？

509-斐波那契数

Learning Shell

What is Shell?

When we enter the terminal, we see something like :

1

levick@ubuntu:~$

which represent username@hostname:currentPath$. In this (my) case, my username is $levick$, my hostname(name of the machine) is $ubuntu$, the current path is $ \sim$(home path of current user), $\$$ -> normal user, # -> super user.

BTW, $/$ represent the root directory of the computer. ( It’s kind of like This PC in Windows)

And, to log in super user, type sudo -s.

some really basic commands:

date: get today’s date.

cal: display the date like a calendar.

df: the current amount of free space on your disk drives.

free: display the amount of free memory.

to close the terminal, typeexit.

Change directory in the File System

To navigate the file system, we may use following commands.

• pwd: display your password display the current directory. (short for Print Working Directory)
• file: used as file filename, to check the file format of chosen file.
• ls: list the contents of the current directory.
• cd: change directory, used as cd PathName.

pwd and file are simple, while ls and cd can be more complex.

The command cd

cd is what we use all the time, because we have to change the directory constantly. The are 2 different methods to represent Path——–>absolute pathname or relative pathname.

absolute pathname: starts from the root directory and leads to its destination

relative pathname: starts from the working directory, uses . to represent the working directory and .. to represent the parent directory of the working directory.

Even more , we can change the working directory easily with following shortcut.

Cases I Came across

Vim

Replace string that contains \(or /)

​ We know that in command mode we use :%s/string1/string2/g to replace string1 with string2 globally.(Note that / here is a delimiter) But when we need to replace string that contains \ or /, it’s a bit tricky. In general, there are two ways to do it.

​ For example, we want replace all the \ with / (when you want to convert path from Windows to Linux)

• escape the /, use :%s/\\/\//g. From the first slash to the last slash, they are: delimiter, escape character, character, delimiter, escape character, character, delimiter.
  In this case we use / as a delimiter, so if we don’t want to mix up delimiter / and the character /, we use \/ to escape / the delimiter to / the character.
• use another delimiter, like # or @, use :%s#\\#/#g. From the first slash to the last slash, they are: escape character, character, character. But note that you can’t use |, \," as a separator.

Note that in both cases we escape \ (the default escape character) as \\ when we want to use it as a character.

​ Always be ware of the structure of the command, distinguish delimiter , escape character and normal character.