sort学习小记

STL-sort学习

学习sort发现不错的文章，摘录一下。
并且做一个自己的理解，默认的sort下排序，即升序。

前景知识 三种排序

快速排序：视频入口 B站的视频，简单的讲了一下快排，并且手把手的带你简单的实现了一遍。
优化：优化参考1 优化参考2
1.三数取中法，在头元素，尾元素，中间元素上，取得中位数。
2.随机选取基准，用随机数代替基准点。
3.插排的引入，当递归到一定程度后，last和first中间元素个数不多，并且已经基本有序，改用插排。

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
int n = 1000,a[1000];
void swap(int i,int j)
{
    int t = a[i];
    a[i] = a[j];
    a[j] = t;
}
void quick_sort(int l,int r)
{
    if(l>r) return ;
    int i = l,
        j = r,
        index = l;
    while(i!=j)
    {
        while(i<j&&a[j]>=a[index]) j--;
        while(i<j&&a[i]<=a[index]) i++;
        if(i<j) swap(i,j);
    }
    swap(index,i);
    quick_sort(l,i-1);
    quick_sort(i+1,r);
}
int main()
{
    srand(time(NULL));
    for(int i=0;i<n;i++)
        a[i] = rand();
    quick_sort(0,n-1);

    for(int i=0;i!=n;i++)
        cout<<a[i]<<endl;

    return 0;
}

插入排序：很简单的东西，要多说一点的是，
它在数据大致有序的情况表现非常好，可以达到O(N)。
参考入口地址 虽然笔者是Java的，不过丝毫不影响对思路的理解

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
int a[1000];
int len = 1000;

void insert_sort()
{
    for(int i=1;i<len;i++)
    {
        int key = a[i]; //选取基准值
        int j = i-1;
        while (j>=0 && a[j] > key)  
        {
            a[j+1] = a[j];    //往后移动
            j--;
        }
        a[j+1] = key;   //选取基准值的位置并且插入
    }
}

int main()
{
    srand(time(NULL));
    for(int i=0;i<len;i++)
        a[i] = rand();    //输入

    insert_sort(); 				//插排

    for(int i=0;i<len;i++)
        cout<<a[i]<<endl;  //输出
    return 0;
}

堆排序：B站视频入口 讲得很好，也是一样，讲完原理之后敲代码了。

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
int n=1000,tree[1000] = {1,7,4,5,8,9,6,3,2,0};
void heapify(int n,int pa) //有n个节点，对第i个节点做heapify
{													//在第i个节点进行调整，在i的左右儿子中选出最大，进行交换
    if(pa>=n) return ;		//如果左儿子大，交换。然后在左儿子中的孩子中选出最大，重复下去
    int lson = 2*pa+1;		//自己画图理解
    int rson = 2*pa+2;
    int maxn = pa;
    if(lson<n&&tree[lson]>tree[maxn]) maxn = lson;
    if(rson<n&&tree[rson]>tree[maxn]) maxn = rson;
    if(pa!=maxn) {
        swap(tree[maxn],tree[pa]);
        heapify(n,maxn);
    }
}
void heap_build(int n)//有n个节点   heap_build的操作是制造根堆，0元素是最值
{																	//根堆建好之后，堆根节点的每一次heapify都能将次大值选到第二层
    int lastnode = n-1;//最后一个节点
    int startpa = (lastnode-1)/2; //最后一个父节点
    for(int i=startpa; i>=0; i--) //逆序对每一个父节点做heapify
        heapify(n,i);
}
void heap_sort(int n) //有n个节点
{
    heap_build(n);
    for(int i=n-1;i>=0;i--)
    {
        swap(tree[0],tree[i]);
        heapify(i,0);
    }
}
int main()
{

//    heapify(n,0);
// 7 8 4 5 1 9 6 3 2 0
//    heap_build(n);
// 9 8 6 5 7 4 1 3 2 0    这些数据是初写的时候用的，数量少，便于理解
    srand(time(NULL));
    for(int i=0;i<n;i++)
        tree[i] = rand();

    heap_sort(n);

    for(int i:tree)
        cout<<i<<endl;
    return 0;
}

sort

参考网址入口 这篇是我见过写的最好的了。没有找到侯捷老师的视频。
以下很多引用自原文：
（1）在数据量很大时采用正常的快速排序，此时效率为O(logN)。//最好情况
（2）一旦分段后的数据量小于某个阈值，就改用插入排序，因为此时这个分段是基本有序的，这时效率可达O(N)。//最好情况
（3）在递归过程中，如果递归层次过深，分割行为有恶化倾向时，它能够自动侦测出来，使用堆排序来处理，在此情况下，使其效率维持在堆排序的O(N logN)，但这又比一开始使用堆排序好。

1
2
3
4
5
6
7
8
9
// 1  sort()
template <class RandomAccessIterator>
inline void sort(RandomAccessIterator first, RandomAccessIterator last) {
    if (first != last) {
        __introsort_loop(first, last, value_type(first), __lg(last - first) * 2);     //__lg(last - first) * 2 这是计算深度阈值 以2为底的对数*2
        __final_insertion_sort(first, last); //满足(2)
    }
}//首先调用__introsort_loop，在里面有 快排，堆排 的调用
//其次是__final_insertion_sort插排的调用
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
// 2     __introsort_loop()
template <class RandomAccessIterator, class T, class Size>
void __introsort_loop(RandomAccessIterator first,
                      RandomAccessIterator last, T*,
                      Size depth_limit)
{    //__introsort_loop()  begin--------------------------------------
    while (last - first > __stl_threshold) { //(2)的条件 
//__stl_threshold的定义：const int __stl_threshold = 16; 
        if (depth_limit == 0) {   //满足(3) 调用堆排
            partial_sort(first, last, last);
            return;
        }
        --depth_limit; 
        RandomAccessIterator cut = __unguarded_partition 
          (first, last, T(__median(*first, *(first + (last - first)/2),
                                   *(last - 1)))); //__median三值取中法进行快排
          //cut = __unguarded_partition(first,last,中值); 
        __introsort_loop(cut, last, value_type(first), depth_limit);//递归调用自己
        last = cut;
    }
}//__introsort_loop()  end---------------------------------------------
/*while循环的条件：当快排到一定程度的时候，小区间的个数会变的很少，元素差不多是有序的，这个时候递归回去，为的是结束退出该函数调用插排。当元素个数很小的时候，继续递归快排付出的代价是要比插排大得多的。这个临界值(__stl_threshold) 16的确定感觉恰到好处。
depth_limit的确定：假设是八个元素(实际上调用插排，我只是举例子)，递归可以认为是这样的
   8 
 4   4
2 2 2 2 ，六次，基本上是log以2为底元素的个数的2倍，这就是调用此函数的时候是
__lg(last - first) * 2的原因。
之前说，当递归层数太深，会调用堆排就是在这里了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 3 __unguarded_partition()  快排
template <class RandomAccessIterator, class T>
RandomAccessIterator __unguarded_partition(RandomAccessIterator first, 
                                           RandomAccessIterator last, 
                                           T pivot) {
    while (true) {
        while (*first < pivot) ++first;  
        --last;
        while (pivot < *last) --last;
        if (!(first < last)) return first;
        iter_swap(first, last);
        ++first;
    }
}//这里的--last;和++first; 相当于上述我的快排代码中的quick_sort(l,i-1);中的i-1和i+1
/*关于为什么没有边界判断，文章中说的很清楚
我觉得是有两个原因，最主要还是第二个，举两个例子。
(1) 如果存的是 1 2 3 4 5 6 7 8 9 10 ，你可能会说，first会一直向后移动直到超出范围。不会，因为pivot取的是中值，上述例子中first会在5这个位置停下，三值取中法。
(2) 源代码和我写的不一样，用的是<(>),不像我的代码中用的<=(>=)，这个时候会在pivot的时候停下来，结束循环。如果是0 2 5 16 11 7 9 1 4 19， pivot是11的话，first会指向16，last会指向4，交换之后变成0 2 5 4 11 7 9 1 16 19，之后first会在pivot的时候停下来，而last指向1，交换后变成0 2 5 4 1 7 9 11 16 19，first又会在11这个地方停下来，而左边肯定会有比pivot小的数，last也会停下来，这时候已经交叉return了。
可能讲的不是很清楚，在本子上多举几个例子运行一边便会觉得十分精妙。last肯定会在左边停下来，因为左边基本是比pivot小的值了，first肯定会在右边停下来，同理。一个小小的小于大于号，竟然如此巧妙。
*/
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
// 4 partial_sort()和__partial_sort()  堆排
//sort中的__introsort_loop调用partial_sort，而partial_sort调用__partial_sort 

//后调用：__partial_sort()
template <class RandomAccessIterator, class T, class Compare>
void __partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
                    RandomAccessIterator last, T*, Compare comp) 
{
    make_heap(first, middle, comp);//对原始容器内区间为[first, middle)的元素运行make_heap()操作构造一个最大堆 那么头元素为最大值 即下面的*first 此时为堆序
    for (RandomAccessIterator i = middle; i < last; ++i)
        if (comp(*i, *first))  //将middle到last的元素与对顶元素进行比较
            __pop_heap(first, middle, i, T(*i), comp, distance_type(first));
  //如果小于该值，就互换位置并重新保持 max-heap 状态
    sort_heap(first, middle, comp); //此时为增序
}
//先调用：partial_sort()
template <class RandomAccessIterator, class Compare>
inline void partial_sort(RandomAccessIterator first,
                         RandomAccessIterator middle,
                         RandomAccessIterator last, Compare comp) {
    __partial_sort(first, middle, last, value_type(first), comp);//主体
}
// __pop_heap()
template <class RandomAccessIterator, class T, class Distance>
inline void __pop_heap(RandomAccessIterator first, RandomAccessIterator last,
                       RandomAccessIterator result, T value, Distance*) {
  *result = *first; // 弹出元素放vector尾端
  __adjust_heap(first, Distance(0), Distance(last - first), value);//保持最大堆
}
/*
__partial_sort():当需要对某个区间进行排序的时候，将调用时的参数改成(first，last，last)就可以了。从最初的调用到make_heap(),其实原型都是(first，last，last)。
虽然上述的参数直接实现了堆排，但是我另外说一下。在__partial_sort()中可以看到make_heap(参数1，参数2),是从[参数1,参数2]的区间做一次build_heap()（我的代码中的函数），函数完成之后就是一个最大堆，元素顺序为堆序。之后拿[middle,last]区间的元素对首元素进行比较,若小，进行一次__pop_heap()。__pop_heap()中就是将首元素取出来放在[middle,last]区间的最后，再将[middle,last]区间的首元素覆盖最大堆的首元素，此时最大堆已经不是最大堆，要进行heapify(我的代码中的函数)，即__adjust_heap()。
之后的sort_heap是将最大堆的堆序调成为升序。即我的代码中sort_heap()中的循环。

起先我感觉：这个for循环有一点多余(当然，这个函数并不只是只用在sort里面被调用)，它是对整个[first,last]区间进行造堆，那么顶元素肯定是最大值啊，middle后的区间完全没必要比。
后来：for循环的条件直接跳过了。middle就是last

下有参考链接。
*/

__partial_sort参考网址入口
参考2 

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
// 5  __final_insertion_sort()------------------>__unguarded_linear_insert()
//    |_-> __insertion_sort()->__linear_insert->__unguarded_linear_insert()

//__final_insertion_sort() sort调用：  插排阅读顺序(1) 
template <class RandomAccessIterator>
void __final_insertion_sort(RandomAccessIterator first, 
                            RandomAccessIterator last)
{
    if (last - first > __stl_threshold) {
        __insertion_sort(first, first + __stl_threshold);
        __unguarded_insertion_sort(first + __stl_threshold, last);
    }
    else
        __insertion_sort(first, last);
}
//__unguarded_linear_insert() 插排阅读顺序(4)
template <class RandomAccessIterator, class T>
void __unguarded_linear_insert(RandomAccessIterator last, T value) {
    RandomAccessIterator next = last;
    --next;
    while (value < *next) {
        *last = *next;
        last = next;
        --next;
    }
    *last = value;
}
//__linear_insert() 插排阅读顺序(3)
template <class RandomAccessIterator, class T>
inline void __linear_insert(RandomAccessIterator first, 
                            RandomAccessIterator last, T*) {
    T value = *last;
    if (value < *first) {
        copy_backward(first, last, last + 1);
        *first = value;
    }
    else
        __unguarded_linear_insert(last, value);//调__unguarded_linear_insert（）
}
//__insertion_sort()  插排阅读顺序(2)
template <class RandomAccessIterator>
void __insertion_sort(RandomAccessIterator first, RandomAccessIterator last) {
    if (first == last) return; 
    for (RandomAccessIterator i = first + 1; i != last; ++i)
        __linear_insert(first, i, value_type(first)); //调用__linear_insert()
}
/*文章将的很清楚，没有什么特别的理解了

*/

万事具备

学了，那就自己敲一下吧，用数组简单实现

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
//先是写了快排   第一版本
#include <iostream>
#include <time.h>
#include <cstdio>
#include <stdlib.h>

#include "help.h"

using namespace std;

int a[1000];
int len = 1000;

//快排
int quick_sort(int first ,int last, int pivot)
{
    while(true)
    {
        while(a[first]<pivot) ++first;
        --last;
        while(a[last]>pivot)  --last;
        if(!(first<last)) return first;
        swap(a[first],a[last]);
        ++first;
    }
}

void myintrosort_loop(int first ,int last)
{
    while( last-first>1 )  //没有加上插排的时候，这么写。如果写成first<last会 死递归
    {                                                      
        int mid_value = get_mid_value( a[first], a[last-1], a[(first+last)/2] );//三值取中法 调用函数 我写在了help.h文件里 我就没有粘出来了
        int cut = quick_sort(first , last , mid_value);
        myintrosort_loop(cut,last);
        last = cut;
    }
}

void mysort(int first ,int last)
{
    myintrosort_loop(first,last); 
}

int main()
{

    srand(time(NULL));
    for(int i=0;i<len;i++)
        a[i] = rand();

    mysort(0,len);  //开始sort

    for(int i:a)
        cout<<i<<endl;

    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
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
//堆排测试  __begin()
int a[100],len=100;
void heapify(int first,int last,int pa)
{
    if(pa>=last) return ;
    int lson = first + 2*(pa-first)+1;
    int rson = first + 2*(pa-first)+2;
    int maxn = pa;
    if(lson<last&&a[lson]>a[maxn]) maxn = lson;
    if(rson<last&&a[rson]>a[maxn]) maxn = rson;
    if(pa!=maxn) {
        swap(a[maxn],a[pa]);
        heapify(first, last ,maxn);
    }
}
void heap_build(int first,int last)
{
    int lastnode = last-1;//最后一个节点
    int startpa = first+(lastnode-first-1)/2; //最后一个父节点
    for(int i=startpa; i>=first; i--) //逆序对每一个父节点做heapify
        heapify(first,last,i);
}
void heap_sort(int first ,int last)
{
    heap_build(first,last);
    for(int i=last-1;i>=first;i--)
    {
        swap(a[first],a[i]);
        heapify(first,i,first);
    }
}
int main()
{
  	srand(time(NULL));
  	for(int i=0;i<len;i++)
    		a[i] = rand();
  
  	heap_sort(90,101);//在区间[90,100]进行堆排 左闭右开区间，所有last要+1
  	
  	for(int i:a)
      	cout<<i<<endl;
  
		return 0;
}
//  __end
  						 /*将两个函数整合到里面去*/
int a[10000];
int len = 10000;
//////////////////////////堆排__start() 实现一个区间堆排
void heapify(int first,int last,int pa)
{
    if(pa>=last) return ;
    int lson = first + 2*(pa-first)+1;
    int rson = first + 2*(pa-first)+2;
    int maxn = pa;
    if(lson<last&&a[lson]>a[maxn]) maxn = lson;
    if(rson<last&&a[rson]>a[maxn]) maxn = rson;
    if(pa!=maxn) {
        swap(a[maxn],a[pa]);
        heapify(first, last ,maxn);
    }
}
void heap_build(int first,int last)
{
    int lastnode = last-1;//最后一个节点
    int startpa = first+(lastnode-first-1)/2; //最后一个父节点
    for(int i=startpa; i>=first; i--) //逆序对每一个父节点做heapify
        heapify(first,last,i);
}
void heap_sort(int first ,int last)
{
    heap_build(first,last);
    for(int i=last-1;i>=first;i--)
    {
        swap(a[first],a[i]);
        heapify(first,i,first);
    }
}
//////////////////////////堆排__end()

////////////////////////////快排 __begin
int quick_sort(int first ,int last, int pivot)
{
    while(true)
    {
        while(a[first]<pivot) ++first;
        --last;
        while(a[last]>pivot)  --last;
        if(!(first<last)) return first;
        swap(a[first],a[last]);
        ++first;
    }
}
////////////////////////////快排 __end

void myintrosort_loop(int first ,int last,int depth_limit)
{
    while( last-first>1 )
    {
        if(depth_limit==0)
        {
            heap_sort(first,last);
            //make_heap(&a[first],&a[last]);  //I'm here. 堆排的调用
          	/*想整合自己的函数进去，发现竟然也不是易事，这个函数可以实现区间造堆，
          	又有研究的东西了*/
            return ;
        }
        depth_limit--;
        int mid_value = get_mid_value( a[first], a[last-1], a[(first+last)/2] );//三值取中法 调用函数
        int cut = quick_sort(first , last , mid_value);
        myintrosort_loop(cut,last,depth_limit);
        last = cut;
    }
}

void mysort(int first ,int last)
{
    int depth_limit = get_depth_limit(last,first); //获取深度阈值 调用函数
    myintrosort_loop(first,last,depth_limit);
}

int main()
{

    srand(time(NULL));
    for(int i=0;i<len;i++)
        a[i] = rand();

    mysort(0,len);

    for(int i:a)
        cout<<i<<endl;

    return 0;
}
1
//插排的整合之后再更新

看完之后，这里我有两个问题，
1.就是(2)一旦分段后的数据量小于某个阈值，就改用插入排序，因为此时这个分段是基本有序的，这时效率可达O(N)。
这个到底是什么意思，是a[15]的时候直接调用插排，还是说a[10000]在快排递归，区段小于16的时候调用插排。如果是第二种，插排是在sort()函数里面的，也就是说在introsort_loop()执行完之后才开始调用。如果他是在intro_loop()函数里调用了，那我认为要在while(){}后面加上插排的调用代码。
2.还有，插排的里是分段的，>16是一段，小于是一段，分段处理。从introsort_loop()出来之后肯定是<=16的，为什么要分这个段呢，没必要啊。我的想法是这个插排的函数不只是由sort()调用，其他也会调用这个函数，所以才这么写
希望解答…….

本文是自己的学习记录，读者可参考，仅供参考
不完善的地方请指正

欢迎来小站一逛 戳一下

展开全文 >>

c++新特性学习笔记

c++新特性学习笔记

这里有一些是新特性，有一些是为了描述新特性另外说明的一些东西。

Variadic Templates …

参考网址：https://blog.csdn.net/zwvista/article/details/5450759?locationNum=11&fps=1
这个好像和Java的类似，需要注意的是新名词的出现，//模板参数包，函数参数包，解包运算符；
实现方式是递归。

forward

请先看下面的右值引用
https://www.cnblogs.com/xiaoshiwang/p/9589008.html
写法:forward(t),其中t是T类型的对象。
在这之前请先了解左值引用和右值引用。
举例：func(100);//实参为右值引用。
还有一个move函数，就是转化为右值的。move()

右值引用

于心不忍，还是给参考连接。
https://blog.csdn.net/qq527703883/article/details/60141034?locationNum=7&fps=1
我感觉就是看这个 总的语句是否分配了空间 ，没有分配就是右值引用
B站侯捷老师的视频 ，这个视频对于的右值引用做了十分详细的讲述，后面还有move和forward的讲解，很深入。强力推荐。

nullptr nullptr auto

这三个东西挺简单的，前两个之间看源码
auto是一个很好用的东西，让编译器推导变量类型。
示例：for(vector::iterator it=v.begin();it!=v.end();it++)可以写成
：for(auto it=v.begin();it!=v.end();it++)

C++11下的初始化

为了统一化管理，引入{}花括号初始化。
initializer_list：这个东西可以支持我们初始化的花括号使用
在使用vector vec1{ 1,2,3,4,5 };时，会自动生成initializer_list，initializer_list内含一个array的头指针和长度
参考网址：https://mp.weixin.qq.com/s?src=11&timestamp=1593334114&ver=2427&signature=Dly5GAhXZ8v*vMicn54oEe8jlhPoK-5GTLlA-*VpY1On1J9l7VsvuqLU3jQvsigf3QKraAujVskn6yZqi3kVLccyK6PdBbpOK44zhhCQGa-UGxUSKkNnHNEEMkbGycql&new=1
注意：虽然很长，但是感觉讲的很好。但是我认为有一个错误，源码是没有内含数组的，只是拿了一个指针和长度进来。可能版本不同把，我就没有深究了。对于它的使用标准库真是大量用了。

1
2
3
4
5
6
int a;cin>>a;
int b=2;
int c=3;
int d=max( {a,b,c}  );//香  发现新大陆啊
cout<<d<<endl;
return 0;

explicit

多用于构造函数中，explicit构造函数是用来防止隐式转换的。很小的一个东西，看之前如果知道类对象的隐式转换和显示转换就很容易懂了。

新for循环

for( decl : coll ){ statement}
搭配auto香的一批，该有全局的begin()和end(),参数放容器。
https://www.jb51.net/article/87283.htm这里有它的底层源码，底层还是用了常用的for，穿入头指针和尾指针，头指针++，当头指针等于尾指针时退出循环。右值引用，for结束则析构。

=default ，=delete

https://www.cnblogs.com/Li-F/p/11517192.html
https://blog.csdn.net/u010640235/article/details/51286445
在写代码的时候，’=’是不能省略的，和两个关键字是一个整体，或者说，这就是一个关键字。
生成类的时候，会自动调动四种函数，=delete会禁用删除当前函数，=dafault用于显式要求编译器提供合成版本的四大函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
class Text
{
private:
    int x,y;
};
int main()
{
    Text t1;
    Text t2(t1);
    Text t3;
    t3 = t1;
    return 0;
}   //当创建一个类的时候，编译器会自动创建四种函数，构造，析构，拷贝，复制。

Alias template

用using定义别名，这个和typedef类似，一个最大的不同是using可以别名化模板。

1
2
3
4
template<typename T>
using Vec = std::vector<T, MyAlloc<T>>;//给一个化名
Vec<int> coll;
//代码摘自侯捷老师的课程

Template Template Parameter

模板模板参数，这个感觉用的很少，想深究的自己去看。

Type Alias

使用using定义别名，和typedef功能一样
示例：using func = void(*)(int,int);
扩充，在string头文件中，都有basic_string string;
basic_string的源码在它的.h文件里面，三千多行，我就不看了。

noexcept

https://blog.csdn.net/xiaoguyin_/article/details/79798544
当函数不会有异常的时候，是应只当noexcept，并且是在关键字实在函数的声明或者是定义之后的。
对于异常，侯捷老师有专门的一讲课，实际开发中异常处理经常出现，值得深究。

override

https://blog.csdn.net/fanyun_01/article/details/79122136
当父类的虚函数在子类中实现的时候使用，可以避免派生类中忘记重写虚函数的错误
当参数不一致时，编译器会报错给予提示

final

表明当前类是不可继承的。
说白了就是当前类是断子绝孙的，只有爸爸，没有儿子。

另外，函数后面加上const，https://wenwen.sogou.com/z/q825346133.htm
说明当前函数为只读操作

decltype

http://c.biancheng.net/view/3722.html 这篇讲的比较深入
编译器自行推导类型。
这篇的使用比较直观

lambda

csdn参考地址
B站侯捷老师视频
知道语法即可，深入请自行了解。

tuple

csdn参考连接
可以看作是一个结构体或者是泛化的pair，只不过配备了很多的函数进行操作。

用于给各位学习者参考，仅供参考。

展开全文 >>

大数和高精度运算

大数运算

POJ 1001
hdu 1024
hdu 1753
hdu 1002

在学习了Java的一些基本语法之后，接下来就是巩固一下知识了。记得之前做过一些大数的运算，用C写起来真是麻烦，今天就用Java来写一写，来爽一把。

POJ 1001

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.math.BigDecimal;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String s = new String();  
		int p;
		while(scanner.hasNext()) {
			s = scanner.next();
			p = scanner.nextInt(); 
			BigDecimal a = new BigDecimal(s);
			a = a.pow(p);
			s = a.stripTrailingZeros().toPlainString(); //注解1
			if(s.charAt(0)=='0')
				s=s.substring(1);
			System.out.println(s);
		}
		
		scanner.close();
	}
}

自己去看了一下Bigdecimal的一些函数，用Java这感觉就是不一样。
题目是算a的b次方。
首先是用String类int接收数值，然后String转BigDecimal，BigDecimal的定义必须赋初值。
注解1：toPlainString()是将Bigdecimal转化为String类，直接转的常用十进制方式，不然是科学记数法。stripTrailingZeros()是去掉后导0。

1
2
3
4
s = a.toPlainString();
//没有stripTrailingZeros(),这是结果
1.0100 12
1.126825030131969720661201000000000000000000000000

对于第2个样例，因为有前导0，需要进行判断。

http://acm.hdu.edu.cn/showproblem.php?pid=1042 hdu 1024

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		while(scanner.hasNext()) {
			long n;
			n = scanner.nextLong();
			BigInteger ans = new BigInteger("1");
			for(long i=1;i<=n;i++) {
				ans = ans.multiply(BigInteger.valueOf(i)); //强制转换的方法
			}
			System.out.println(ans);
			
			
		}
		scanner.close();
	}
}

http://acm.hdu.edu.cn/showproblem.php?pid=1753 hdu 1753

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.math.BigDecimal;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		while(scanner.hasNext()) {
			String sa = new String();
			String sb = new String();
			sa = scanner.next();
			sb = scanner.next();
			BigDecimal a = new BigDecimal(sa);
			BigDecimal b = new BigDecimal(sb);
			BigDecimal ans =a.add(b);
			String sans = ans.stripTrailingZeros().toPlainString();
			System.out.println(sans);
		}
		scanner.close();
	}
}

http://acm.hdu.edu.cn/showproblem.php?pid=1002 hdu 1002

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int T;
		T = scanner.nextInt();
		for(int t=1;t<=T;t++) {
			BigInteger a = scanner.nextBigInteger();
			BigInteger b = scanner.nextBigInteger();
			System.out.println("Case "+t+":");
			System.out.println( a+" + "+b +" = "+ (a.add(b)) );
			//if(t!= T)System.out.println();
		}
		scanner.close();
	}
}

展开全文 >>

云想衣裳花想容

我是自由的云。

晓看天色暮看云，行也思君，坐也思君
昼赏微云夜观星，醒也思卿，寐也思卿。
春看百花冬看雪，醒也思君，梦也思君。
夜阑卧听风吹雨, 铁马是你, 冰河也是你

我喜欢你，像三相点，精确而不变。
我喜欢你，像互相纠缠的粒子，有些改变不了的联系。
我喜欢你，像普通的玻色子，却可以包容在一起。
我喜欢你，像滕氏蓝与普鲁士蓝，结果还是一起。
我喜欢你，像四氯化碳，无可取代。
我喜欢你，像尖晶石，复杂而又致密。
我喜欢你，像焓增熵减，总是爱你。 我还是很喜欢你，像多巴胺的分泌，永不停歇。
我喜欢你，像亲核亲电，注定要在一起。
我还是很喜欢你，像Re的蒸气压，不忍离去。
我还是很喜欢你，像滴定分析，精确而不偏离。
我还是很喜欢你，像焰色反应的绚丽，多彩甜蜜。
我还是很喜欢你，像立方金刚石的坚固，从不变心。

纵然万劫不复，
纵然相思入骨，
我也待你眉眼如初，
岁月如故。
纵然笑靥已故，
纵然繁华落幕，
我亦许你金风玉露，
此生不负。
纵然荒冢枯骨，
纵然黄泉陌路，
我亦等你奈何桥上，
生死同路。
纵然魂消身死，
纵然万世不枯，
我亦跳下忘川河，
百世情苦。
纵然轮回千古，
纵然形同陌路，
我亦寻你千百度，
初心不负。
纵然望穿秋水，
纵然思绪满腹，
我亦爱你不能诉，
心似红豆。
纵然沧桑陵谷，
纵然河清难俟，
我亦思君如流水，
连绵不诉。
纵然蜂飞蝶舞，
纵然百花娇艳，
我亦待你不相离，
长相厮守。
纵然红颜不复，
纵然相思成姝，
我亦带你眉眼如初，
明眸入伫。
纵然衣白衫故，
纵然弹指韵华烟云过，
我亦抚琴红莲赋，
又见谁一舞？
花花世界处处繁华似锦，能遇到你何其幸运！

展开全文 >>

C++中static的学习

要还是用法的方面写的多，注意事项写了一个重要的，毕竟这个编译错误卡了我几天，下面开始简单介绍，文中有很多类比的地方，如果不当，还请谅解。

static

一个类中的成员，可以是一个实例成员，也可以是一个类范围成员(static).

静态数据成员：

目的：为了解决数据共享的问题。多个类对象实现数据的互通。

即使对象不存在，静态数据成员也是存在的。
如有有很多对象，也只有一份。

可以看成一个全局变量，为何要封装在类中呢，为了限制该变量的作用范围，还有一个作用，就是增加可读性和可维护性。

1
2
3
4
5
6
7
8
9
///在.h声明文件当中声明静态数据成员
class A
{
	static int x;
	static int y;
};
///在.cpp类函数实现中进行初始化
int A::x = 5;
int A::y = 10;

静态数据成员的访问：
1：无需创建对象便可访问，如：A::x=5;
2: 在类的成员函数中可以访问，如：x=5或者A::x = 5;

静态成员函数：

说明：
1：静态成员函数没有宿主对象，所以不能用this
2：静态成员函数不能直接访问非静态数据成员
3：普通成员函数可以调用静态成员函数
非静态的数据成员肯定实在对象确定以后才有的，对象存在非静态数据才存在(对应第2条)。

注意

下面讲我觉得非常重要的一点，就是静态数据成员在类中，你可以认为是一个声明，就和函数一样，然后在定义文件.cpp文件中进行定义(并初始化)。

为了方便理解，给出全部代码。例子：通讯录条目，有姓名和电话两个数据成员。创建三个文件，主文件，声明文件，定义文件，下面是代码:

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
///main.cpp
#include <iostream>
#include <string>
#include "declaration.h"
using namespace std;

int displayMenu()
{
    cout << "==================="<<endl;
    cout << "1.输入通讯录条目"   <<endl;
    cout << "2.输出通讯录条目"   <<endl;
    cout << "3.修改姓名"         <<endl;
    cout << "4.修改电话"         <<endl;
    cout << "0.退出"             <<endl;
    cout << "==================="<<endl;
    cout << "请输入操作数："     <<endl;
    int iChoice;
    cin>>iChoice;
    return iChoice;
}
int main()
{
    CommEntry c1;
    int iChoice =1;
    while (iChoice!=0){
    iChoice = displayMenu();
    switch (iChoice)
    {
        case 1:{
            c1.input();
            break;
        }
        case 2:{
            c1.output();
            break;
        }
        case 3:{
            string nm;
            cout<<"请输入修改之后的名字:";
            cin>>nm;
            c1.setName(nm);
            break;
        }
        case 4:{
            string t;
            cout<<"请输入修改之后的电话：";
            cin>>t;
            c1.setTel(t);
            break;
          }
        case 0:
            break;
       }
    }
    return 0;
}
///definition.cpp
#include <string>
#include "declaration.h"
#include <iostream>
using namespace std;

string CommEntry::tel;   ///定义并且初始化
void CommEntry::input()
{
    cout<<"Name:";cin>>name;
    cout<<"Tel:"; cin>>tel;
}
void CommEntry::output()
{
    cout<<"Name:" <<name<<endl;
    cout<<"Tel:"  <<tel<<endl;
}
string CommEntry::getName()
{
   return name;
}
void CommEntry::setName(string nm)
{
    name = nm;
}
string CommEntry::getTel()
{
    return tel;
}
void CommEntry::setTel(string t)
{
    tel = t;
}
///declaration.h
#include <string>
using namespace std;
class CommEntry
{
    public:
        string name;
        static string tel; ///前向声明

        void input();
        void output();

        string getName();
        void setName(string nm);

        static string getTel();
        static void setTel(string ow);
};

如有错误，还请指出~

展开全文 >>

运算符重载C++

运算符重载

对于运算符的重载，主要有两种方式:友元和成员函数
@表示某一种操作符。
以下有+ - * / >> << 的用法，其他没有。

对于 + - * / 的重载

在这四个例子中，我串入两种重载方法的使用。
以复数作为例子，定义实部和虚部两个数据成员。没有学复数的读者可以认为就是两个float变量，后面只是一些计算。

友元方法的声明： + * 举例

1
2
friend Complex operator+(Complex &,Complex &);/// +
friend Complex operator*(Complex &,Complex &);/// *

定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Complex operator+(Complex &a,Complex &b) /// +
{
    Complex c;
    c.r = a.r+b.r;
    c.i = a.i+b.i;  ///定义类c，进行运算
    return c;
}
Complex operator*(Complex &a,Complex &b) /// *
{
    Complex c;
    c.r = a.r*b.r-a.i*b.i;
    c.i = a.r*b.i+a.i*b.r;
    return c;
}

使用：

1
2
3
4
Complex a,b;
// ***省略赋值语句
a = a + b;
a = a * b;///相加之后赋给a，直接覆盖掉

对于friend Complex operator+(Complex &,Complex &);，我们忽略掉friend和&简化得到
Complex operator+(Complex,Complex;。可以看成是有两个参数的一个函数，返回类Complex。
第一个Complex你可以看成是int，void这样的返回类型，不过这是类，不是基础数据类型。
用友元的方法，看上去比较整洁，是几目运算符，形参就有几个。
定义的时候，在声明的基础上去掉friend。

成员函数方法的声明： - / 举例

1
2
Complex operator-(const Complex &b);/// -
Complex operator/(const Complex &b);/// /

定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Complex Complex::operator-(const Complex &b)
{
    Complex c;
    c.r = this->r-b.r;
    c.i = this->i-b.i;
    return c;
}
Complex Complex::operator/(const Complex &b)
{
    Complex c;
    if(b.r*b.r+b.i*b.i==0)
    {
        cout<<"分子为0,不能相除，a的值不变"<<endl;
        c.r = this->r;
        c.i = this->i;  ///不能相除，a的值不发生变化，返回a原来的值
    }
    else
    {
        c.r = (this->r*b.r+this->i*b.i)/(b.r*b.r+b.i*b.i);
        c,i = (this->i*b.r-this->r*b.i)/(b.r*b.r+b.i*b.i);
    }                    ///计算结果我没有仔细看了
    return c;
}

声明：对于Complex Complex::operator-(const Complex &b),定义的时候，因为是成员函数，所有要遵循类函数定义规则。先是返回类型，然后接类名::，然后是operator@，n目运算符，后参数为n-1.
定义：在定义中，肯定有人发现了这个，this，之前我也被这个整蒙了，在这里你只需要知道，它就相当与友元当中a就完了。this->r,this>i分别表示a.r,a.i。不过还是要说明的是，参数带了个&，表示的是引用(我是理解为C里面的指针的)，对于指针，那就是用箭头了啊。用.的情况我只在学Java见识过。

对于输入输出>>和<<的重载方法：

在类CommEntry中有两个私有数据成员name和tel，分别是电话(string)和姓名(string)
在类中声明：

1
2
friend ostream& operator<<(ostream&, CommEntry&);
friend istream& operator>>(istream&, CommEntry&);

对于函数的实现：

1
2
3
4
5
6
7
8
9
10
11
12
istream& operator>>(istream& in,CommEntry& c )
{
    cout<<"Name:";in>>c.name;
    cout<<"Tel:";  in>>c.tel;
    return in;
}
ostream& operator<<(ostream& out,CommEntry& c )
{
    out<<"Name:"<<c.name<<endl;
    out<<"Tel:" <<c.tel <<endl;
    return out;
}

调用：

1
2
3
CommEntry c1;
cin>>c1;
cout<<c1;

自己的想法：
我们忽略friend和&，那么就变成了 istream operator<<(istream in, CommEntry c);
第一部分：对于第一个出现的istream来说，其实就是返回类型，和成员函数的声明一个意思，相当于写了个void或者int。
第二部分：之后是固定的写法，operator@。
第三部分：在括号中是两个形参，我觉得可以把istream可以int一样的东西，不过是一个类对象。然后接一个名字，后面是类对象加名字，记得两个都是引用，需要加上&。
注意，所有的都是引用，前面有个&，look到没~(不能理解什么是引用？你可以比作是c里面的指针)

经验和教训：
1.我们只能以自定义类的友元函数的形式重载这两个运算符
2.对于输入，形参必须为非 const，因为输入操作符的目的是将数据读到这个对象中。
3.在类声明和定义文件中不需要#include<iostream>，写了也没有什么关系。

为了方便理解，我把全部的代码发了！

读者自己创建三个文件，运行理解一下

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
///main.cpp
#include <iostream>
#include <string>
#include "declaration.h"
#define cin_b; cout<<"b.r:";cin>>b.r;cout<<"b.i:";cin>>b.i;
#define cin_a; cout<<"a.r:";cin>>a.r;cout<<"a.i:";cin>>a.i;
using namespace std;
int displayMenu()
{
    cout << "===================="<<endl;
    cout << "1. 输入复数"         <<endl;
    cout << "2. 查看输入的复数"   <<endl;
    cout << "3. 复数相加"         <<endl;
    cout << "4. 复数相减"         <<endl;
    cout << "5. 复数相乘"         <<endl;
    cout << "6. 复数相除"         <<endl;
    cout << "7. 输出结果"         <<endl;
    cout << "0. 退出"             <<endl;
    cout << "===================="<<endl;
    cout << "请输入操作数："      <<endl;
    int iChoice;
    cin>>iChoice;
    return iChoice;
}
int main()
{
    Complex a,b;
    int iChoice =1;
    while (iChoice!=0)
    {
        iChoice = displayMenu();
        switch (iChoice)
        {
            case 1:{
                cin_a; ///宏定义
                break;
            }
            case 2:{
                a.output();
                break;
            }
            case 3:{       /// +
                cin_b;
                a = a + b;
                break;
            }
            case 4:{       /// -
                cin_b;
                a = a - b;
                break;
              }
            case 5:{       /// *
                cin_b;
                a = a * b;
                break;
            }
            case 6:{       /// /
                cin_b;
                a = a / b;
                break;
            }
            case 7:{       /// /
                a.output();
                break;
            }
            case 0:{
                break;
            }
        }
    }
    return 0;
}
///definition.cpp
#include <iostream>
#include "declaration.h"
using namespace std;
Complex::Complex()
{
    r = i =0;
}
void Complex::input(int r,int i)
{
    this->r = r;
    this->i = i;
}
void Complex::output()
{
    cout<<"r:"<<r<<endl;
    cout<<"i:"<<i<<endl;
}
Complex operator+(Complex &a,Complex &b) /// +
{
    Complex c;
    c.r = a.r+b.r;
    c.i = a.i+b.i;
    return c;
}
Complex operator*(Complex &a,Complex &b) /// *
{
    Complex c;
    c.r = a.r*b.r-a.i*b.i;
    c.i = a.r*b.i+a.i*b.r;
    return c;
}
Complex Complex::operator-(const Complex &b)
{
    Complex c;
    c.r = this->r-b.r;
    c.i = this->i-b.i;
    return c;
}
Complex Complex::operator/(const Complex &b)
{
    Complex c;
    if(b.r*b.r+b.i*b.i==0)
    {
        cout<<"分子为0,不能相除，a的值不变"<<endl;
        c.r = this->r;
        c.i = this->i;
    }
    else
    {
        c.r = (this->r*b.r+this->i*b.i)/(b.r*b.r+b.i*b.i);
        c,i = (this->i*b.r-this->r*b.i)/(b.r*b.r+b.i*b.i);
    }
    return c;
}
///declaration.h
#include <iostream>
using namespace std;
class Complex
{
    public:
        float r;
        float i;
        Complex();
        void input(int ,int);
        void output();
        friend Complex operator+(Complex &,Complex &);/// +
        friend Complex operator*(Complex &,Complex &);/// *
        Complex operator-(const Complex &b);/// -
        Complex operator/(const Complex &b);/// /
};
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
///main.cpp   ///主文件
#include <iostream>
#include <string>
#include "declaration.h"
using namespace std;

int displayMenu()
{
    cout << "==================="<<endl;
    cout << "1.输入通讯录条目"   <<endl;
    cout << "2.输出通讯录条目"   <<endl;
    cout << "3.修改姓名"         <<endl;
    cout << "4.修改电话"         <<endl;
    cout << "0.退出"             <<endl;
    cout << "==================="<<endl;
    cout << "请输入操作数："     <<endl;
    int iChoice;
    cin>>iChoice;
    return iChoice;
}
int main()
{
    CommEntry c1;

    int iChoice =1;   ///获得操作数
    while (iChoice!=0){
    iChoice = displayMenu();
    switch (iChoice)
    {
        case 1:{
            cin>>c1;///c1.input();
            break;
        }
        case 2:{
            cout<<c1;///c1.output();
            break;
        }
        case 3:{
            string nm;
            cout<<"请输入修改之后的名字:";
            cin>>nm;
            c1.setName(nm);
            break;
        }
        case 4:{
            string t;
            cout<<"请输入修改之后的电话：";
            cin>>t;
            c1.setTel(t);
            break;
          }
        case 0:
            break;
       }
    }
    return 0;
}
///declaration.h   函数声明文件
#include <string>
#include <iostream>
using namespace std;
class CommEntry
{
    friend ostream& operator<<(ostream&, CommEntry&);
    friend istream& operator>>(istream&, CommEntry&);
    /*error w  错误的写法
    friend istream operator>>(CommEntry& c);
    friend ostream operator<<(CommEntry& c);
    */
    public:
        void input();
        void output();
        void setName(string nm);
        void setTel(string t);
        string getName();
        string getTel();
    private:
        string name;
        string tel;
};
///definition.cpp   函数定义文件
#include <string>
#include "declaration.h"
#include <iostream>
using namespace std;
void CommEntry::input()
{
    cout<<"Name:";  cin>>name;
    cout<<"Tel:";   cin>>tel;
}
void CommEntry::output()
{
    cout<<"Name:"<<name<<endl;
    cout<<"Tel:" <<tel<<endl;
}
void CommEntry::setName(string nm)
{
    name = nm;
}
void CommEntry::setTel(string t)
{
    tel=t;
}
string CommEntry::getName()
{
   return name;
}
string CommEntry::getTel()
{
    return tel;
}
istream& operator>>( istream& in,CommEntry& c )
{
    cout<<"Name:";in>>c.name;
    cout<<"Tel:";  in>>c.tel;
    return in;
}
ostream& operator<<( ostream& out,CommEntry& c )
{
    out<<"Name:"<<c.name<<endl;
    out<<"Tel:" <<c.tel <<endl;
    return out;
}

如有错误，还请指出~

展开全文 >>

vim以及其他常用命令

下面给出一些常用的vim的命令，主要是编辑文件的时候用的

rm filename:删除文件filename
mv filename1 filename2:将filename1改名为filename2

vim filename： 打开名为filename的文件，没有就创建

vim的三种模式

1.输入vim filename进入普通模式
2.普通模式下，按下(用的最多的还是i)

1
2
3
4
5
6
i 在当前位置生前插入
I 在当前行首插入
a 在当前位置后插入
A 在当前行尾插入
o 在当前行之后插入一行
O 在当前行之前插入一行

进入插入模式
ESC 或 Ctrl + [ 从插入模式回到普通模式
3.普通模式下，按下shift+; 就会在左下角出现 冒号:
就进入了命令模式

1
2
3
4
5
6
7
8
:w 保存文件,如果后面跟上文件名是另存操作  //wq和q！用的比较多
:q 退出编辑器
:w! 强制保存
:q! 强制退出
:wq 保存并退出
:set nu 显示行号
:set nonu 不显示行号
:set syntax=html html语法高亮

常用

正常模式下：

1
2
3
4
5
6
7
8
9
10
11
12
按下v之后，可以选择(有背景覆盖)，然后按下y表示复制，按d键删除，按G表示全选 //这个用的是真多
u:返回上一步骤，撤销
方向键 : 移动光标
hjkl : 移动光标
yy : 复制当前行
p : 黏贴
dd : 删除当前行 (5dd 删除5行 dw删除一个单词 )
u : 撤销
ctrl + f : 向前翻一页
Ctrl + b : 向后翻一页
Ctrl + u : 向上翻半页
Ctrl + d : 向下翻半页

展开全文 >>

Java 学习笔记

其实并没有什么用，只是用来训练一下md的写法和hexo的一些命令，Java是一个完全面向对象的东西，有过C和C++的基础，学起来会狠轻松，稍微写一下与C不同的东西

public：可以省略，默认为public
创建新文件：File->new->java peoject->sre->右键->new->class
调节字体快捷键: ctrl-+=(_-)
扩展以及快捷键:
syso+(alt+/) ： 扩展成为System.out.println();
main+(alt+/) ：扩展main
ctrl+shift+o ：import java.util.Scanner;（需要再用了函数的情况下导入）
ctrl + 鼠标点击： 查看详情
Ctrl+m :左右框消失
alt+s：Generate Getters and Setters…,get和set函数；Constractor 构造函数
Scanner scanner = new Scanner(System.in);
鼠标选择部分代码 然后ctrl+shift+/ 注释
ctrl+d ： 删除一行
如果是static声明的对象，可以直接用类名加函数名的方法调用函数 class.func()

float的最大值（同理可求最小值，double类似）

1
2
float a;
a = scanner.nextFloat();

注释：和c一样，加了一个文档注释/** 然后回车
标识符：数字 字母 下划线 美元符号$

数据类型：
byte(位) 8位
long 64位
boolean 布尔类型 true||false
小数默认是double类型,所以必须加一个f表示float类型
float f = 1.1f;
//Unicode表示字符
char c1 = ‘\u66f9’; \u+编码 上网查

&&短路与 前面不满足条件 直接返回 效率高
&不断路与 所有判断完才返回
^ 异或 关于表达式

break结束本层循环
break加标签(outer)是跳出被标签标记的循环

1
2
3
4
5
6
7
8
outer:
for(int i=1;i<=10;i++) {
	for(int j=1;j<=i;j++) {
		if(i==4)  break outer;
		System.out.print(i + "*" + j + "=" +(i*j)+"  ");//九九乘法表
	}
	System.out.println();//空行
}

return 直接跳出循环

数组定义的两种方式： //栈区初始化为0 默认值是0
int[] []int
静态初始化：

1
int arr[] = new int[] {1,2,3};

动态初始化：

1
2
int a[] = new int[3]; 二维静态初始化：
int a[][] = new int[][] {{1,1,1},{2,2,2},{3,3,3}};

二维动态初始化：

1
int a[][] = new int[3][3];

遍历数组：

1
2
3
for(int i=0;i<arr.length;i++) 
for(int j:a)     //foreach方法遍历
	System.out.println(j);     //每次将数组中的值赋给j

类和对象：

1
2
3
4
Person yy;//定义对象
yy = new Person();//对象实例化
//或者
Person yy = new Person();

函数
对于函数参数的传递，若传送的是对象，则传递的是引用(地址)，在函数中改变对象的值，对象的值会真的改变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//不固定参数的写法 类型+...然后起个名字
public class Person {
	public void HOBBIES(String ...hobbies) {    //String类型
		for(String s:hobbies)
			System.out.println(s+" ");
	}
	public void PRINTINT(int ...numbers) {      //int类型
		for(int i:numbers)
			System.out.println(i);
	}
	public static void main(String[] args) {
		Person yy = new Person();
		yy.HOBBIES("aaa","bbb","ccc");
		yy.PRINTINT(1,321,13,56);
	}
}

返回值
返回值和c差不多，不在赘述

方法

方法的重载：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class study {
	public void add(int a,int b) {
		System.out.println("方法1:"+(a+b));
	}
	public void add(int a,int b,int c) {
		System.out.println("方法2:"+(a+b+c));
	}
	public void add(int a,double b) {
		System.out.println("方法3:"+(a+b));
	}
	public static void main(String[] args) {
		study dx = new study();
		dx.add(1,2);
		dx.add(1,2,3);
		dx.add(1,2.456);
	}
}
//如果add有返回值不同，接收的变量类型和add的返回值类型相对应

静态调用方法

1
2
3
4
5
6
7
8
public class study {
	public static void func() {
		System.out.println("静态");
	}
	public static void main(String[] args) {
		study.func();    //写类名，如果new了一个对象，调用会有警告
	}
}

递归调用方法：：不赘述
this的使用，表示此本对象

1
2
3
4
5
6
Person(String name, int age) {
	System.out.println("非默认");
	this.name = name;
	this.age = age;
	System.out.println(this.name +" "+ this.age);
	}

String类：

1
2
String name1 = "yy";///在对象池赋值
String name2 = new String("yyy");///引用 相当于指针

字符串的反转:

1
2
String name = "123456789";
name = new StringBuffer(name).reverse().toString();

字符有很多要学习的对方，得刷题熟悉一下。

继承
一个包中已经定义了一个Person的类，在另一个Class中定义Yy类，可以这么写

1
public class Yy extends Person

搜一下super的用法，这个不是视频能够完全弄好懂的。

final
1.final声明的类不能被继承
2.final声明的方法不能被子类覆盖
3.final声明的变量不能被修改，即为常量

1
public final class Person

抽象类

1
2
3
public abstract class Study{
	public abstract void fun();
}

相当于模板，天生的父类，不能被实例化，在子类中要具体实现父类中的函数。
在抽象类中函数只需要声明，不能够实现。

接口
interface定义接口

1
public interface A{}

implement实现接口

1
2
3
4
5
public class Test implement A
public class Test implement A,B///实现多个接口
Test  t = new Test();///利用接口
t.a();
t.b();

先继承，后实现接口(写下class这一行的)
接口的继承：接口可以多继承

多态

1
2
3
4
//父类引用指向Dog类的具体实现
Animal animal = new Dog();
animal.func();
//调用的是Dog中的func函数

转型

1
2
Dog dog = (Dog)animal;//向下转型
Animal animal = (Animal)dog//像上转型

Object
Object是所有类的父类

instanceop
返回布尔类型

1
2
System.out.println("dog对象是否属于Animal类"+(dog instanceof Animal));
System.out.println("dog对象是否属于Dog类"+(dog instanceof Dog));
1
2
3
4
5
6
7
8
9
public static void func(Animal animal){
	if(animal instanceof Dog){
		(Dog)animal.say();
	}
	if(animal instanceof Cat){
		(Cat)animal.say();
	}
	
}

匿名内部类
只使用一次，这个不太明白

包装类
装箱和拆箱

1
2
3
int a = 1;
Integer i = new Integer(a); //装箱   Integer i = new Integer(1);
int b = i.intValue(); //拆箱

自动装箱和拆箱

1
2
Integer i = 1; //自动装箱的过程，自动把数据转化为对象
int i2 = i; //自动拆箱，自动把对象传为基本数据

作用

1
2
3
4
5
6
String a = "1";
String b = "2";
int m = Integer.parseInt(a); 
// static int parseInt(String s) static方法可以用类名直接调用 
int n = Integer.parseInt(b);
System.out.println(m+n);

设计模式
饿汉式，懒汉式-单例化

1
2
3
4
5
6
7
8
9
///饿汉式单例实现 先new出一个对象
public class Person {
	private Person() {} // 构造方法私有
	private static final Person p = new Person();//饿汉式单例实现
	public static Person getInstance() { //静态工厂方式
		return p;
	}
	
}
1
2
3
4
5
6
7
8
//懒汉式单例实现 在第一次调用的时候实例化
private static Person p;
public static Person getInstance() { //线程同步 可以加synchronized
	if(p==NULL) {
		p = new Person();
	}
	return p;
}

常用类

日期类:Date​

1
Date date = new Date();

日历类:Calendar

1
2
3
4
5
6
7
Calendar calendar = Calendar.getInstance();//实例化：静态方法，返回一个Calendar实例
calendar.get(Calendar.YEAR);
calendar.get(Calendar.MONTH);
calendar.get(Calendar.DAY_OF_MONTH);
calendar.get(Calendar.HOUR_OF_DAY);
calendar.get(Calendar.MINUTE);
calendar.get(Calendar.SECOND);        ///年月日时分秒 都是int

SimpleDateFormate：

1
2
3
SimpleDateFormat sdf = new SimpleDateFormat(); ///实例化对象
Date date = new Date();                        ///日期对象
System.out.println(sdf.format(date));          ///转化

将输出格式进行封装：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Person {
	public static String PrintFormateDate(Date date,String formate) {
		String s="";
		SimpleDateFormat sdf = new SimpleDateFormat(); 
		if(date!=null) {
			s = sdf.format(date);
		}
		return s;
	}
	public static void main(String[] args) {
		Date date = new Date();
		System.out.println(  PrintFormateDate(date,"yyyy-MM-dd HH:mm:ss")  );
	}
}

String和StringBuffer:
String：对String类型的操作对象，等同于重新生成一个对象，然后将引用指向它；
StringBuffer：操作的始终是一个对象；

1
2
StringBuffer s = new StringBuffer("123");
s.append("456");      ///始终指向一个对象

数学：math(很多都是static类型，类名加函数直接调用)

1
2
3
Math.max(1,2);//比较最大值
Math.round(12.6);//四舍五入
Math.pow(3,4);//求次方，3^4，3的4次方

数组：Arrays

1
2
3
4
5
int arr[] = {5,1,8,44,3,5,8,4,3};
Arrays.toString(arr));   ///toString
Arrays.sort(arr);        ///升序排序
System.out.println( Arrays.binarySearch(arr,44) );//在排好序的arr中，查找位置，从0记
Arrays.fill(arr,0);      ///将arr的值置0

泛型

泛型引入：

我们知道Object是所有类的父类，所以可以运用这个。(这不是泛型)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//ClassOne.java
public class ClassOne {
	private Object object;
	public ClassOne(Object object) {
		super();
		this.object = object;
	}
	public void Print() {
		System.out.println(object.getClass().getName());
	}
    //...省略set函数和get函数
}
//Main.java
ClassOne c1 = new ClassOne(1); //向上转型  这是比较方便好的
c1.Print();
int i = (Integer)c1.getObject();//向下转型  这是比较麻烦的
ClassOne c2 = new ClassOne("111"); 
c2.Print();

泛型：(感觉和c++的差不多一个意思)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
///ClassType 文件
public class ClassType<T> {
	private T a;
	public ClassType(T a) {
		super();
		this.a = a;
	}
	public void Print() {
		System.out.println(a.getClass().getName());
	}
	//...省略set函数和get函数
}
///Main文件
public class Person {
	public static void main(String[] args) {
		ClassType<Integer> c1 = new ClassType<Integer>(1);
		c1.Print();
		ClassType<String> c2 = new ClassType<String>("111");
		c2.Print();	
	}
}

泛型限制

1
2
public class ClassType<T extends Animals> {} ///泛型限制
public class Dog extends Animals{}  //普通限制

通配符泛型

1
2
public static void take(ClassType<?> a){}   //函数
ClassType<Dog> dog = new ClassType<Dog>(new Dog());  //主函数

集合

父类：Collection
List是Collection接口的子接口，也是最常用的接口。此接口对Collection接口进行了大量的扩展，List集合里的元素是允许重复的。

1
2
3
4
5
6
7
//链表 LinkedList
LinkedList<Integer> list = new LinkedList<Integer>();
    list.add(1); list.add(2);list.add(3);
    for(int i=0;i<list.size();i++) {
    	Integer I = list.get(i);
   		System.out.println(I);
    }
1
2
3
4
5
6
7
//ArrayList 
ArrayList<String> al = new ArrayList<String>();
al.add("123");
al.add("456");
for(int i=0;i<al.size();i++) {   //循环输出
    System.out.println(al.get(i));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//HashMap
public static void main(String[] args) {
		HashMap<String,Person> hm = new HashMap<String,Person>();
		hm.put("Person 1", new Person("张三",10));
		hm.put("Person 2", new Person("李四",20));
		//通过key获取values
		Person P = hm.get("Person 1");
		System.out.println(P.getName());//输出的是   张三
    	//遍历
		Iterator<String> it = hm.keySet().iterator();//获取key的集合，然后获取迭代器
		while(it.hasNext()) {
			String key = it.next();
			Person values = hm.get(key);
			System.out.println(values.getName());
		}
	}

集合的遍历

Iterator遍历集合

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) {
    LinkedList<Person> L = new LinkedList<Person>();
    L.add(new Person("张三",10));
    L.add(new Person("李四",20));

    Iterator<Person> it = L.iterator();
    while(it.hasNext()) {
        Person P = it.next();
        System.out.println(P.getName()+P.getAge());
    }
}

foreach集合

1
2
for(Person P:L)
    System.out.println(P.getName()+P.getAge());

展开全文 >>

搭建个人博客

搭建个人博客

经过千辛万苦，终于把自己的个人博客搭建好了，什么
千辛万苦，不过就是一个几个小时而已，再加上git的下载，
幸好提前一天注册了GitHub的账号，并且玩了一下，才会搭建的这么简单。
太开心了啊，哈哈~
下面是基于github平台的个人博客的搭建的命令，不需要购买服务器和域名
有空详细讲一讲自己搭建完成的第二天干了什么事情。
(关于md的图片插入，我还没有完全搞懂)

准备工作一定要做好：

git
在此之前，要下载git，git的下载可以去csdn看一看，有国内的下载地址，国外的真的是太慢了，真的是醉了。
github
熟悉github的一些界面和操作，这个B站也有视频
vim
熟悉vim的操作，可以在左侧所有文章搜索vim

推荐视频
B站搜索个人博客搭建

经验

我是在win10下搭建的，搭建的与苹果系统略有不同，大同小异。
1.创建文件夹是mkdir，与Linux不同，win10下dir是列出全部目录
2.首先是在win10 DOS下输入命令，到后面DOS会输出找不到git，好像是类似的这么一条提示，这个时候就要在Git Bash输入命令了。
3.hexo d的时候，因为推到远端是推在GitHub上，所以会暂停上传要你输入GitHub的账户和密码
4.win 10下生成博客 不用加sudo
5.DOS窗口可以用管理员权限打开(鼠标右键)
6.推到远端后，要过一会儿博客才会更新
7.这是非常重要的一点，如果对博客进行了修改，可与执行hexo s本地运行看一下效果，再推到远端去。
8.更改之后，一般我会执行hexo clean，然后再执行hexo g。再看是要本地运行(hexo s)还是推到远端(hexo d)
9.关于图片的加载，我上传了三张图片，头像，支付宝和微信的支付码，但是加载不出来。翻遍csdn和Google都没有找到自己的解决方法。后来才是看了yilia作者litten备份博客才找到答案
坑点：在yilia的配置文件中，告诉你图片地址assets/ima/.jpg，网上说图片在source文件夹下，但是呢，source有两个。.jpg文件应该放在blog的source文件夹下，而不是yilia文件夹下。(这个点卡了我一晚上)
还有：npg格式不支持，必须改成jpg格式！！！
npg格式不支持，必须改成jpg格式
npg格式不支持，必须改成jpg格式

学习笔记！

安装Nodejs

在https://nodejs.org/ 安装node，下载长期有效版本
检测下载是否成功，可以直接查看版本
*查看node版本: *node -v
*查看npm版本: *npm -v

安装淘宝的cnpm包管理器镜像

先安装cnpm：
npm install -g cnpm registry=http://registry.npm.taobao.org
查看cnpm版本:(是否成功)：
cnpm -v
安装hexo框架：
cnpm install -g hexo-cli
查看hexo版本
hexo -v
创建blog目录(最好记住路径)：
mkdir blog
进入blog目录(之后的很多操作在blog目录下进行):
cd blog
生成博客 初始化博客(这是后已经搭建好了，不过是在本地)：
sudo hexo init
启动本地博客服务
hexo s
http://localhost:4000/ #本地访问地址
创建新的文章(建议进入/blog/source/_posts下vim创建)
vim 我的第一篇博客.md，之后返回blog目录
清理：(在blog目录下)
hexo clean
生成
hexo g

Github创建一个新的仓库 YourGithubName.github.io
在blog目录下安装git部署插件:
cnpm install --save hexo-deployer-git

配置_config.yml

1
2
3
4
5
6
# Deployment
## Docs: https://hexo.io/docs/deployment.html
deploy:
type: git
repo: https://github.com/YourGithubName/YourGithubName.github.io.git
branch: master

部署到Github仓库里：
hexo d
https://YourGithubName.github.io/ #访问这个地址可以查看博客
下载yilia主题到本地
git clone https://github.com/litten/hexo-theme-yilia.git themes/yilia

修改hexo根目录下的 _config.yml 文件 ： theme: yilia
之后执行三条指令：
hexo c #清理一下
hexo g #生成
hexo d #部署到远程Github仓库

csdn: https://blog.csdn.net/qq_43693424/article/details/106069870
如有错误，还请指出
说了这么多，累的想买爽歪歪了。

展开全文 >>

Hello World

###以下巴拉巴拉一大推，其实就是告诉你怎么使用hexo，还有就是kd的格式编写

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家