字符串和数字之间的相互转换

字符串和数字之间的相互转换

数字转为字符串：

方法1：使用sprintf

1
2
3
int num=10;
char str[1024];
str = sprintf(str,"%d",num);

方法2：使用最原始的方式进行转换

1
2
3
4
5
6
7
8
9
10
11
int num=10;
string str1,str2;
while(num)
{
    str+=num%10+'0';
    num/=10;
}
for(int i=str.length()-1;i>=0;i++)
{
    str2+=str[i];
}

方法3：to_string函数

1
2
int num=10;
string str=to_string(num);

方法4：_itoa函数

1
2
3
4
int num=10;
char str[100]={0};
//10代表将num是十进制的数
_itoa(num, str2, 10);

字符串转数字：**

方法1：sscanf

1
2
3
char str[]="100";
int num=0;
sscanf(str,"%d",&num)

方法2：atoi函数

1
2
char str[]="100";
int num=atoi(str);

方法3：

1
2
3
4
5
6
string str="100";
int val=0;
for(int i=0;i<str.length();i++)
{
	val=val*10+str[i]-'0';
}

转载请标明出处，谢谢

展开全文 >>

c++数组

每次学完数组之后就是当时学完，当时特别的清楚，可是过了几天却就忘，今天我就把一维数组二维数组的知识点总结如下：

1.一维数组常见用法如下：

1.1一维数组的数组名称：

除了两种特殊的情况以外，都是指向数组第一个元素的指针。

特殊情况1：sizeof（数组名）求得的是整个数组的大小

特殊情况2：对数组名取地址，是一维的数组指针，它的步长整个一维数组的长度

一维数组名是一维数组的首地址，等于&arr[0]（第一个元素的地址）

1.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
int arr[5] = { 1, 2, 3, 4, 5 };
//方法一，先定义出数组类型，再通过类型定义数组指针变量
typedef int(ARRAY)[5];//ARRARY代表存放5个int类型元素的数组 的数组类型
ARRAY arr1;//arr等同于arr可以向里面插入数据
//数组指针
ARRAY* arr2=&arr;
//方位arr2中的内容  *arr2等同于arr
for (int i = 0; i < 5;i++)
	{
		printf("%d\n", (*arr2)[i]);
	}
//方法2，先定义数组指针类型，再通过类型定义数组指针变量
typedef int(*ARRAY)[5];
//数组指针
ARRAY arr3=&arr；//遍历arr3与arr2一样
for (int i = 0; i < 5;i++)
	{
		printf("%d\n", (*arr3)[i]);
	}    
//方法3，最方便直观的一种
int(*p)[5]=&arr;  
for (int i = 0; i < 5;i++)
	{
		printf("%d\n", (*p)[i]);
	}

2.二维数组常见用法

2.1 二维数组名

二维数组名 除了两种特殊情况外，是指向第一个一维数组的 数组指针（int（*p）【3】）

特殊情况1：sizeof 统计二维数组大小

特殊情况2：对数组名称取地址 int(*p)【3】【3】 = &arr

二维数组的数组指针跟一维数组指针的定义方式类似：只是多了个维度（int（*p）【3】【3】）。

1
2
3
4
5
6
7
8
9
10
 int arr2[][3] = { {1,2,3},{4,5,6},{7,8,9} };
//二维数组的数组名是整个位数数组的首地址等价于，arr2[0]和arr2[0][0],都是二维数组的首地址
//二维数组的访问
for(int i=0;i<5;i++)
{
	for(int j=0;j<5;j++)
	{
		cout<<(*(arr2+i)+j)<<endl;
	}
}

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
//出现乱码,因为str是局部变量开辟在栈区，在当前函数结束就被释放，我们无权操作
char* abtain()
{
	char str[10] = "hello";
	printf("%s\n", str);
	return str;
}
int main()
{
	char* str = abtain();
	return 0;
}
//而下面这个可以  因为char* str = "hello"，的内存是开辟在了常量区，常量区的内容不会随该函数的结束而释放，可以作为返回值，正确
char* abtain()
{
	char* str = "hello";
	printf("%s\n", str);
	return str;
}
int main()
{
	char* str = abtain();
	return 0;
}

转载：请标明原创，谢谢

展开全文 >>

sql语句的超详细笔记

SQL常用语句的增删改查

–创建数据库
create database test
on primary
(name=’test’,–主数据文件的逻辑名称
filename=’D:\shujuku\test.mdf’–主数据文件的物理名称及地址
size=3mb,–主数据文件的初始大小
maxsize=10mb,–主数据文件的最大值
filegrowth=3mb–主数据文件的增长率
)
log on–日志文件
(
name=’test’,
filename=’D:\shujuku\test.ldf’，
size=2mb,
maxsize=100mb,
filegrowth=15%
)

use test–使用test数据库
–创建表
create table ClassIfo
(cId int not null primary key identity(1,1),
cTitle nvarchar(10)
)

创建表
select * from ClassIfo
use test
create table StudentInfo
(
sId int not null primary key identity(1,1),
sName nvarchar(10) not null,
sSex bit default(0),
sBirth date,
sPhone char(11),
sEamil varchar(20),
cid int not null,
foreign key(cid) references ClassIfo(cid)
)

–插入 insert into 表名 values
select * from ClassIfo
insert ClassIfo(cTitle) values(‘张三’)
insert into ClassIfo values(‘张三’),(‘李四’)
insert into ClassIfo values(‘张三’,’李四’)
insert ClassIfo(cTitle) values(‘张三’)
insert into ClassIfo values(‘张三’),(‘李四’)

–修改操作update 表名 set 列名=‘修改的值’，alter table 表名 相应指令
select * from ClassIfo
–为所有的列进行修改
update ClassIfo set cTitle=’展示柜’
–为指定的行进行修改
update ClassIfo set cTitle=’李四’ where cId>2
–删除操作 delete 表名 where
select * from ClassIfo
delete ClassIfo where cid>2
–清空表 truncate table 表名

–查询 select 列名 as 别名，列名 as 别名 from 表名 as 别名（as可以省略）
–取别名 as
select ctitle as 标题 from ClassIfo as al
select al.ctitle astitle from ClassIfo al

–select top n * from classinfo 查询前n行，所有列
–select top n percent * from classinfo 查询前百分之的行的所有列
insert into ClassIfo values(‘张三’),(‘李四’),(‘王五’)
select top 3 *
from ClassIfo

–排序 order by 列名 asc,列名 asc（从小到大）/desc（从大到小），写在from的后面，如果一个列名相等，在比较另外一个列名
select * from ClassIfo
order by cId desc

–distinct 消除重复行
select distinct cid from ClassIfo

–条件查询 写在where后面
select ctitle from ClassIfo
where cId=4
–取出1班或3班的学生的信息
select * from ClassIfo
where cId in(1,3) –in指的是1或3并不是连续的

–模糊查询
–查找姓张的学生信息，%代表一个字符或多个字符
select * from StudentInfo
where sname like ‘张%’
–查询姓名为两个字的姓黄的学生信息,表示一个字符，[^0-2],表示除了0-2之外的所有的数
select * from StudentInfo
where sname like ‘黄‘
–查询一个数值为空的条件用is不能用=

–多表连接查询，两个表之间有对应的关系，可以是内连接，也可以是外连接 select *from classinfo inner join studentinfo on classinfo.cid=studentinfo.cid
–right join–右连接匹配右边边特有的数据
–left join–左连接，匹配左边特有的数据
–full join–完全外连接，同时匹配左边和右边特有的数据
–inner join–内连接，匹配两表中完全匹配的数据
select cl.sname,st.ctitle from ClassIfo as cl inner join studentinfo on cl.cit=st.cid

select * from StudentInfo

–多张表的连接查询，classinfo表和studentinfo表有关系，studentinfo和subjectinfo表有关系，依次类推
–查询三张表的所有信息
select * from classinfo as cl
inner join studentinfo as stu on cl.cid=stu.cid
inner join subjectinfo as sub on stu.cid=sub.cid
–聚合函数
sum（最大值）、avg（平均值）、min（最小值）、count（）统计所有行数的个数
–查询学生表中一共有多少人
select count() as count1 from studentinfo
–查询班级编号为一的人数
select count(*) as count1 from studentinfo where cid=1
–使用count的时候，null不会计数
select count(sphone) from studentinfo
–查询分数最高的成绩
select max(score) from scoreinfo
–查询一班中分数最高的成绩
select max(score) from scoreinfo where cid=1

–开窗函数：over，放在聚合函数后面，作用是将聚合函数统计的信息分布到每一行中
–统计信息分布到行中
select scoreinfo.,avg(score) from scoreinfo where subid=1 –会报错
–正确写法如下
select scoreinfo.,avg(score) over() from scoreinfo where subid=1

–分组：group by
–统计每个班的男女生人数
select sgender,cid count() from studentinfo
group by sgender,cid
–统计学生编号大于2的各班级的男女生人数
select cid,sgender，count() from studentinfo
where sid>2 group by cid,sgender
–分完组之后，如果还想对分组的内容进行筛选，在group by 后面加having加条件，haveing不能使用未参与分组的列
–也可以使用in的方法，having count() in(2,5,8),where中不能使用聚合函数
–统计学生编号大于2的各班级的男女生人数大于3的信息
select cid,sgender,count() from studentinfo
where cid>2 group by cid,sgender having count(*)>3
–isnull(类型,’替换内容’)的用法
–查询英语成绩，如果英语成绩为空则显示缺考
select isnull(convert(varchar(20),singlish(所查询的列名)),’缺考’) from studentinfo
–完整的sql语句及执行顺序
select distinct top n *from
table1 join table2 on …
where …
group by … having …
order by …

–联合查询 只能是有相同列的两个并且每一个列对应的值类型相同才能查询 union（并集）、union all(所有的数，包括重复的数)
–except（补集，找它左边特有的部分），intersect(交集)
–查询cid和sid的交集
select cid from classinfo
intersect
select sid from studentinfo

–将横表变为纵表
select ‘最高成绩’ as 描述信息,max(tenglish) as 成绩 from studentinfo
union
select ‘最低成绩’ as 描述信息,min(tenglish) as 成绩 from studentinfo

–快速备份表 ：select 列名 into 备份表名 from 源表名 如果备份表不存在，则会新建一个表，表的结构完全一致

    --但是不会包含约束条件，如果只想包含表的结构不包含数据可以加一个不存在的条件
--向已有的表中，备份另一个表 insert into 备份表名 select 列名 from 源表名

–将数据备份到一个不存在的test表中
select * into test from classinfo
–将数据备份到一个不存在的test表中，只要结构
select * into test from classinfo where 1=2
–或
select top 0 * into test from classinfo
–将数据备份到一个存在的表中
insert into test select cid from calssinfo

–类型转换：select cast(类型1(被转换) as 类型2(目标))

select convert(数据类型1(目标),数据类型2(被转换))

–将89.0000转换为89.0
select cast(89.0000 as decimal(3,1))
–计算字符的ascii值 select ascii(‘字符’)
–根据ascii的值转到字符 select char(数值)
–返回字符串长度 select len(‘字符串’)
–将字符串转换为小写 select lower(‘大写’)，将字符串转换为大写 select upper(‘小写’)
–截取字符串
–从左边截取字符串
select left(‘字符串’,2)–从左边开始截取两个字符
–从右边截取字符串
select right(‘字符串’,2)–从右边截取两个字符串
select substring(‘字符串’,2,3)–从第二个字符开始，一共截取3个字符
–切掉空格
select ‘哈哈’+ltrim(‘ hello world’)–去掉左边的空格 哈哈hello world
select ‘哈哈’+rtrim( ‘hello’ )–去掉右边的空格 哈哈 hello
–去空格需要嵌套
select ‘哈哈’+rtrim(ltrim(‘ hello world’))–去掉左边的空格 哈哈hello world

–视图(对select语句进行封装，方便使用)
–语法 creat view 视图名 as select的查询语句

–子查询(在一个查询中嵌套另一个查询)关键字有=，in，exits(in的效率低于exits)
–查询参加了考试的学生的信息
select * from studentinfo
where sid in(select distinct stuid from scoreinfo)
–或
select * from studentinfo
where sid exits(select * from scoreinfo where studentinfo.stuid=scoreinfo.sid)

–case语句 语法
–查询学生的所有信息，并且判断该学生是否及格
select *, 是否及格=case
when tenglish>60 then ‘及格’
else ‘差’
end from scoreinfo–可以判断一个区间的值 >=
–case语句第二种表述方式，但是不能用于区间
select *,是否及格=case tenglishscore when 60 then ‘及格’
when 59 then ‘不及格’
else ‘优秀’
end from scoreinfo –不能用域区间判断
–异常处理 ：begin try …
end try
如果上面的语句有错误则执行下面的语句
begin catch …
end catch

–事务 判断一任务是否完成，没有完成则会回到初始的状态
–语法：begin transaction … –开始事务
comit transaction –提交事务,没有错才会执行，执行完了以后就不会执行下面的语句
rollback transaction … –回滚,出错后执行该语句
–锁 防止对数据的误操作
语法：在事务的基础上把提交操作，这样即使修改了还是会回到初始状态
begin transaction …
rollback transaction –回滚

–存储过程 将select语句封装成一个存储过程，语法：create proc 名称 参数列表 as begin … end
调用：exec 名称 参数列表
–将字符串去空格
declare @temp varchar(100)
set @temp=’ abc ‘
select ltrim(rtrim(@temp))
–转换成存储过程
create proc trim
@str1 varchar(100)
as
begin select ltrim(rtrim(@str1))
end

展开全文 >>

常见cc++语言经典实例

常见c/c++语言经典实例

1.求两个数的最大公约数
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
#include<stdio.h>
//用户输入两个数，求这两个数的最大公约数

void test01()
{
	int num1, num2, gcd;
	printf("请输入两个正整数：");
	scanf("%d %d", &num1, &num2);
	for (int i = 1; i <= num1&&i <= num2; i++)
	{
		//找到最大公约数
		if (num1%i == 0 && num2%i == 0)
		{
			gcd = i;
		}
	}
	printf("%d和%d的最大公约数是：%d", num1, num2,gcd);
}
//第二种方法
void test02()
{
	int num1, num2, gcd;
	printf("请输入两个正整数：");
	scanf("%d %d", &num1, &num2);
	while (num1 != num2)
	{
		if (num1 > num2)
		{
			num1 -= num2;
		}
		else
			num2 -= num1;
	}
	printf("%d和%d的最大公约数是：%d", num1, num2, num1);
}
int main()
{
	test01();
	puts("");
	test02();
	puts("");
	system("pause");
	return 0;
}
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
#include<stdio.h>
//用户输入两个数，求这两个数的最小公倍数。
void test01()
{
	int num1, num2, a, b;
	printf("请输入两个正整数：");
	scanf("%d %d", &num1, &num2);
	a = num1;
	b = num2;
	while (num1 != num2)
	{
		if (num1 > num2)
			num1 -= num2;
		else
			num2 -= num1;
	}
	int result = a * b / num1;
	printf("%d和%d的最小公倍数是：%d", a, b, result);
}
//方法2
void test02()
{
	int num1, num2,maxnum;
	printf("请输入两个正整数：");
	scanf("%d %d", &num1, &num2);
	maxnum = (num1 > num2) ? num1 : num2;
	while (1)
	{
		if (maxnum%num1 == 0 && maxnum%num2 == 0)
		{
			printf("%d和%d的最小公倍数是：%d",num1,num2,maxnum);
			break;
		}
		maxnum++;
	}
}
int main()
{
	test01();
	puts("");
	test02();
	puts("");
	system("pause");
	return 0;
}
3.输出九九乘法口诀表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>
//使用嵌套 for 循环输出九九乘法口诀表
int main()
{
	for (int i = 1; i < 10; i++)
	{
		for (int j = 1; j <=i; j++)
		{
			printf("%d*%d=%d\t", i, j, i*j);
		}
		puts("");
	}
	system("pause");
	return 0;
}
4.二进制和十进制的转换
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
#include<stdio.h>
#include<math.h>
//二进制转换为十进制
void test01()
{
	int i = 0, result = 0, rem;
	printf("请输入一个二进制数：");
	int num;
	scanf("%11d", &num);
	while (num != 0)
	{
		rem = num % 10;
		num /= 10;
		result += rem * pow(2, i);
		i++;
	}
	printf("二进制转换为十进制为%d\n", result);
}
//十进制转换为二进制
void test02()
{
	printf("请输入一个十进制数：");
	int num;
	scanf("%d", &num);
	int rem, result = 0, i = 1;
	while (num != 0)
	{
		rem = num % 2;
		num /= 2;
		result += rem * i;
		i *= 10;
	}
	printf("十进制数转换为二进制数为%d\n", result);
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}
5.八进制和十进制的相互转化
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
#include<stdio.h>
#include<math.h>
//八进制转换为十进制
void test01()
{
	int rem, i = 0, result = 0;
	printf("请输入一个八进制数：");
	int num;
	scanf("%d", &num);
	while (num != 0)
	{
		rem = num % 10;
		num /= 10;
		result += rem * pow(8, i);
		i++;
	}
	printf("八进制数转换为十进制数为：%d\n", result);
}
//十进制数转换为八进制数
void test02()
{
	int rem, i = 1, result = 0;
	printf("请输入一个十进制数：");
	int num;
	scanf("%d", &num);
	while (num != 0)
	{
		rem = num % 8;
		num /= 8;
		result += rem * i;
		i *= 10;
	}
	printf("十进制转换为八进制数为：%d\n", result);
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}
6.二进制和八进制的相互转换
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
#include<stdio.h>
#include<math.h>
//二进制转换为八进制
void test01()
{
	int result1 = 0, result2 = 0, i = 0;
	printf("请输入一个二进制数：");
	int num;
	scanf("%d", &num);
	//将二进制转换为十进制
	while (num != 0)
	{
		result1 += (num % 10)*pow(2, i);
		num /= 10;
		i++;

	}
	printf("二进制转换为十进制数为：%d\n", result1);
	//将十进制数转换为八进制数
	i = 1;
	while (result1 != 0)
	{
		result2 += (result1 % 8)*i;
		result1 /= 8;
		i *= 10;
	}
	printf("二进制数转换为八进制数为：%d\n", result2);
}
//八进制数转换为二进制数
void test02()
{
	int i = 0, result1 = 0, result2 = 0;
	printf("请输入一个八进制数：");
	int num;
	scanf("%d", &num);
	//先将八进制转换为十进制
	while (num != 0)
	{
		result1 += (num % 10)*pow(8, i);
		num /= 10;
		i++;

	}
	printf("八进制转换为十进制为：%d\n",result1);
	//将十进制转换为二进制
	i = 1;
	while (result1 != 0)
	{
		result2 += (result1 % 2)*i;
		result1 /= 2;
		i *= 10;
	}
	printf("八进制数转换为二进制数为：%d\n", result2);
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}
7.表格形式输出数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<stdio.h>
//表格显示输出数据
void test01()
{
	int i, j, k;
	for (i = 0; i < 10; i++)
	{
		for (j = 0; j <= 100; j += 10)
		{
			printf("%3d  ", j);
		}
	printf("\n");
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}
8.斐波那契数列的输出
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
//斐波那契数列指的是这样一个数列 1, 1, 2, 3, 5, 8, 13。。。。。
//这个数列从第3项开始，每一项都等于前两项之和。
#include<stdio.h>

//输出指定数字前的斐波那契数列
void test01()
{
	printf("请输入一个正整数：");
	int num, t1 = 0, t2 = 1;
	scanf("%d", &num);
	printf("%d前面的斐波那契数列为：%d %d ", num, t1, t2);
	while (t1 + t2 < num)
	{
		int sum = t1 + t2;
		printf("%d ", sum);
		t1 = t2;
		t2 = sum;
	}
}
// 输出指定数量的斐波那契数列
int main()
{
	int n, t1 = 0, t2 = 1, nextTerm;
	printf("请输入输出斐波那契数列的项数：");
	scanf("%d", &n);
	printf("斐波那契数列：");
	for (int i = 1; i <= n; i++)
	{
		printf("%d  ", t1);
		nextTerm = t1 + t2;
		
		t1 = t2;
		t2 = nextTerm;
	}
	puts("");
	test01();
	puts("");
	system("pause");
	return 0;
}
9.回文数01
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
#include<stdio.h>
//回文数
void test01()
{
	int num, temp;
	int rem, rev = 0;
	printf("请输入一个整数：");
	scanf("%d", &num);
	temp = num;
	//翻转
	while (num != 0)
	{
		rem = num % 10;
		rev = rev * 10 + rem;
		num /= 10;
	}
	if (rev == temp)
	{
		printf("%d是回文数", temp);
	}
	else
		printf("%d不是回文数", temp);
}
int main()
{
	test01();
	puts("");
	system("pause");
	return 0;
}
10.简单的计算器
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
#include<stdio.h>
//计算器
void test01()
{
	printf("请输入一个运算符（+、-、*、/）：");
	char c;
	int num1, num2;
	scanf("%c", &c);
	printf("i请输入两个整数：");
	scanf("%d %d", &num1, &num2);
	switch (c)
	{
	case '+':
		printf("%d+%d=%d", num1, num2, num1 + num2);
		break;
	case '-':
		printf("%d-%d=%d", num1, num2, num1 - num2);
		break;
	case '*':
		printf("%d*%d=%d", num1, num2, num1 * num2);
		break;
	case '/':
		printf("%d/%d=%d", num1, num2, num1 / num2);
		break;
	default:
		break;
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}

有问题疑问请留言，我会第一时间解答，谢谢

由于空间有限剩下的请访问：

https://github.com/zhajianliang/c-c-.git

转载求标明出处：

https://github.com/zhajianliang/c-c-.git

https://zhajianliang.github.io

展开全文 >>

linux之Makefile语法

linux之Makefile语法

1.在同一级目录下创建文本文档Makefile文件，和hello.c的文件，#在Makefile中是注释的意思。
2.用make直接进行编译，会生成.o、.i、.S.等文件。
第一层 显示规则：

1.目标文件：依赖文件（可以省去预编译，汇编，编译）

​ [Tab键]指令

2.第一个目标文件是我们的最终目标，下面的hello是我们的最终目标。

3.伪目标：.PHONY：

rm -rf hello.S hello.i hello.o(指定删除你不需要的文件)

4.Makefile文件书写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
hello:hello.o  //hello是目标文件，hello.i是依赖文件
    gcc hell.o -o hello
hello.o:hello.S
    gcc -c hello.S -o hello.o
hello.S:hello.i
    gcc -S hello.i -o hello.S
hello.i:hello.c   //hello.i是目标文件，hello.c是依赖文件
    gcc -E hello.c -o hello.i
    
        
        
上面的可以直接由下面的得到目标文件hello文件
 hello:hell.o  //hello是目标文件，hello.o是依赖文件
     gcc hello.o -o hello //可以直接得到hello        
hello.o:hello.c
    gcc -c hello.c -o hello.o
     
     
     
     .PHONY:  //固定的格式
clear:   //自定义的名字，作用是删除你不需要的东西，可以在终端执行 make clear进行删除
	rm  -rf   hello.S  hello.i   hello.o
第二层 变量

在第一层的基础上进行变量替换：

变量 = （替换） +=（追加） ：=（恒等于）

示例：

1
2
3
4
5
6
7
8
VAL=hello           //替换
VAL+=hello1         //追加
A：=gcc             //恒等于，gcc为不可变内容
B=hello.o


书写规范：注意加上一个$（变量名）；
$(VAL):$(B)        //VAL是目标文件，B是依赖文件
第三层 隐含规则：

%.c(任意的.c文件 *.c(所有的.c文件)

1
2
%.c:%.o
	gcc -c %.c -o %.o
第四层 通配符

最常见的几个指令：

$@ 所有的目标文件 $^ 所有的依赖文件 $< 所有依赖文件的第一个文件

希望对你们有帮助，制作不易，转载请标明出处：

https://zhajianliang.github.io

展开全文 >>

linux之vi编辑器

超详细的vi的常用命令

1.使用vi命令打开或新建一个文件

指令

1
vi test.c

如果该文件存在则打开，该文件不存在则新建

1.1使用vi可以定位到指定的位置比如我们有一行出错了，就可以快速的定位到该行

指令：

1
vi test.c +16

该指令会打开，并跳转到test.c的第16行，如果只有+号，而没有16，则会直接定位到文件末尾。

1.2 vi的异常处理,如果vi修改了文件但为保存就退出，这时磁盘上就会存在.swp的文件如下：

image-20200606230606299

再次使用vi编辑该文件时会看到如下信息，这时我们按下字母d删除交互文件即可。

image-20200606230729797

2.vi的三种工作模式

2.1命令模式：打开文件首先进入的就是命令模式，通过命令对vi进行常规的编辑工作，如定位，翻页，复制、删除等。
2.2.末行模式：执行保存退出等操作。：q退出，：q！强制退出，：w保存，：w强制保存，：wq！强制保存退出（：x）
2.3.编辑模式：对文件进行编辑操作
2.4.三者之间的关系如下：

image-20200606231637229

3.vi的常用命令

3.1.重复指令：用vi打开文件，在命令模式下输入重复的次数，然后再进入编辑模式，输入所想要重复的内容，然后按下ESC这时该指令就会复制你输入的次数。
3.2.移动光标，j向下，k向上，h向左，l向右。
3.2.1.光标的行内移动：w向前移动一个单词，b向后移动一个单词。0移动到行首，^移动到第一个不是空白子的位置，行首。$移动到行尾。
3.2.1.光标行内移动的第二种方法：gg 文件顶部，G 文件末尾，数字gg 移动到数字对应的行数，数字G 移动到数字对应的行数。：数字移动到数字对应的行数。
3.3.屏幕移动

Ctrl+b 向后翻页，Ctrl+f向前翻页

H 屏幕顶部

M 屏幕中间

L 屏幕底部

3.4.段落移动

{ 上一段

} 下一段

3.5.使程序在()和[]之间的快速切换

指令

1
%
3.6.给某一代码标记

指令

1
2
ma//给一代码标记为a
‘a//可以定位到标记的代码

m后面的值可以使a-z或A-Z.

4.1.选中文本的三种方式

v 可视模式 从光标位置开始按照正常模式选择文本

V 可视行模式 选中光标经过的完整行

Ctrl+v 可视块模式 垂直方向选中文本

4.2.撤销和恢复撤销命令

u 恢复上次的命令

Ctrl+r 恢复撤销的命令

4.3.删除文本

x 删除光标所在的字符

d+移动命令 删除移动命令中对应的内容

dd 删除光标所在的整行

ndd 删除从光标所在的行开始的n行

D 从光标位置开始删除到行尾

5.1.复制和粘贴

y 复制一个字符

yy 复制光标所在的一整行

nyy 复制光标所在的行复制n行

p 进行粘贴

注意：vi中的文本缓冲区与系统中的剪贴板不是同一个

​ 在其他软件中用Ctrl+c复制的内容不能通过p来张贴

​ 可以在编辑模式中通过右键粘贴

5.2.替换命令

r 替换当前字符

R 替换当前行光标前的字符 会进入替换吗模式，替换完成后按ESC回到命令模式

5.3 缩进和重复执行
1
2
3
<<   //向右缩进
>>   //向左缩进 
.    //重复执行上次的命令
5.4 查找命令和替换
1
2
3
4
5
6
7
/str         //注意str为你所要查找的内容
n             //查找下一个str
N             //查找上一个str
*             //向后查找光标所在的单词
#             //向前查找光标所在的单词
：%s/被替换的内容/替换内容/g    //全局替换会把所有的都替换
：s/旧文本/新文本/g            //可视区域替换

确定替换命令

1
：%s/旧文本/新文本/gc            //会提示是否替换命令

y替换，n不替换，a全部替换，q退出替换，l替换最后一个

5.5 插入命令

i 在光标所在字符前插入文本

I 在行首插入文本

a 在光标所在字符后插入文本

A 在行尾插入文本

o 在当前行后面插入一个空行

O 在当前行前面插入一个空行

6.1 常用的末行命令

：e 文件名 打开并编辑这个文件

：e . 会打开内置的文件浏览器，可以打开自己想要的文件

：n 文件名 新建文件

：w 文件名 另存为，但是仍然编辑当前文件，不会切换

6.2 分屏命令

：sp[文件名] 横向增加分屏

：vsp[文件名] 纵向增加分屏

切换分屏窗口

先按Ctrl+w再依次进行切换

w 切换到下一个窗口

r 互换窗口

c 关闭当前的窗口

q 退出当前窗口，如果使最后一个窗口则关闭vi

o 关闭其他窗口

转载请标明出处

https://zhajianliang.github.io

https://blog.csdn.net/qq_46796338/article/details/106597661

展开全文 >>

十大经典的排序算法

排序算法是《数据结构与算法》中最基本的算法之一，下面价绍了七种排序方式，分别是插入排序、希尔排序、选择排序、冒泡排序、归并排序等，附加源代码

1.冒泡排序

算法步骤：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

C源代码：

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
#include<stdio.h>
//按升序排序
void bubblesort(int arr[],int len)
{
	int i, j;
	for (i = 0; i < len-1; i++)
	{
		for (j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}

}
//冒泡排序降序排序
void bubblesort1(int arr[], int len)
{
	int i, j;
	for (i = 0; i < len - 1; i++)
	{
		for (j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] < arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
int main()
{
	int arr[] = {1,5,3,2,9,15,6,4,59,65,32,31};
	int len = sizeof(arr) / sizeof(int);
	bubblesort1(arr, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	puts("");
	system("pause");
	return 0;
}

2.选择排序

算法步骤：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

下面我写了两种，我觉得第一种比较直观易懂

C源代码：

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
#include<stdio.h>
//交换两个数的值
void swap(int *num1,int *num2)
{
	int temp = *num1;
	*num1 = *num2;
	*num2 = temp;
}
//选择排序升序01
void selectsort(int arr[],int len)
{
	int i, j;
	for (i = 0; i < len - 1; i++)
	{
		for (j = i + 1; j < len; j++)
		{
			if (arr[i] > arr[j])
			{
				swap(&arr[i], &arr[j]);
			}
		}
	}
}
//选择排序02
void selectsorT(int arr[], int len)
{
	int i, j;
	for (i = 0; i < len - 1; i++)
	{
		int min = i;//假设i为最小值
		for (j = i + 1; j < len; j++)
		{
			if (arr[i] > arr[j])//找到目前最小值
			{
				min = j;//记录最小值的位置
			}
		}
		swap(&arr[min], &arr[i]);//进行排序，将最小值与之前的假设的最小值i交换
	}
}
int main()
{
	int arr[] = { 1,5,3,2,9,15,6,4,59,65,32,31 };
	int len = sizeof(arr) / sizeof(int);
	selectsorT(arr, len);
	for (int i = 0; i < len; i++)
			{
				printf("%d ", arr[i]);
			}
	system("pause");
	return 0;
}

3.插入排序

算法步骤：

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。

C源代码：

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
#include<stdio.h>
//插入排序,升序排序
void insertsort(int arr[],int len)
{
	int i, j, begin;
	for (i = 0; i < len; i++)
	{
		begin = arr[i];
		j = i - 1;
		while ((j >= 0) && (arr[j] > begin))
		{
			arr[j + 1] = arr[j];
			j--;
		}
		arr[j + 1] = begin;
	}
}
int main()
{
	int arr[] = { 1,5,3,2,9,15,6,4,59,65,32,31 };
	int len = sizeof(arr) / sizeof(int);
	insertsort(arr, len);
	for (int i = 0; i < len; i++)
			{
				printf("%d ", arr[i]);
			}
	system("pause");
	return 0;
}

4.希尔排序

算法步骤：

选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

按增量序列个数 k，对序列进行 k 趟排序；

每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

C源代码：

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
#include<stdio.h>
//希尔排序升序排序
void shellsort(int arr[], int len) {
	int gap, i, j;
	int temp;
	for (gap = len >> 1; gap > 0; gap >>= 1)
	{
		for (i = gap; i < len; i++) 
		{
			temp = arr[i];
			for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
				arr[j + gap] = arr[j];
			arr[j + gap] = temp;
		}
	}
		
}
int main()
{
	int arr[] = { 1,5,3,2,9,15,6,4,59,65,32,31 };
	int len = sizeof(arr) / sizeof(int);
	shellsort(arr, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	system("pause");
	return 0;
}

5.归并排序

算法步骤：

  1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
  2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
  3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
  4. 重复步骤 3 直到某一指针达到序列尾；
  5. 将另一序列剩下的所有元素直接复制到合并序列尾

C源代码：

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
#include<stdio.h>
//归并排序
void mergesort(int arr[], int len) {
	int *a = arr;
	int *b = (int *)malloc(len * sizeof(int));
	int seg, start;
	for (seg = 1; seg < len; seg += seg) {
		for (start = 0; start < len; start += seg * 2) {
			int low = start, mid = min(start + seg, len), high = min(start + seg * 2, len);
			int k = low;
			int start1 = low, end1 = mid;
			int start2 = mid, end2 = high;
			while (start1 < end1 && start2 < end2)
				b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
			while (start1 < end1)
				b[k++] = a[start1++];
			while (start2 < end2)
				b[k++] = a[start2++];
		}
		int *temp = a;
		a = b;
		b = temp;
	}
	if (a != arr) {
		int i;
		for (i = 0; i < len; i++)
			b[i] = a[i];
		b = a;
	}
	free(b);
}
int main()
{
	int arr[] = { 1,5,3,2,9,15,6,4,59,65,32,31 };
	int len = sizeof(arr) / sizeof(int);
	mergesort(arr, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	system("pause");
	return 0;
}

6.快速排序

算法步骤：

  1. 从数列中挑出一个元素，称为 “基准”（pivot）;
  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

C源代码：

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
#include<stdio.h>
//快速排序
typedef struct _Range {
	int start, end;
} Range;

Range new_Range(int s, int e) {
	Range r;
	r.start = s;
	r.end = e;
	return r;
}

void swap(int *x, int *y) {
	int t = *x;
	*x = *y;
	*y = t;
}

void quicksort(int arr[],  int len) {
	if (len <= 0)
		return; 
	Range r[100];
	int p = 0;
	r[p++] = new_Range(0, len - 1);
	while (p) {
		Range range = r[--p];
		if (range.start >= range.end)
			continue;
		int mid = arr[(range.start + range.end) / 2]; 
		int left = range.start, right = range.end;
		do {
			while (arr[left] < mid) ++left;   
			while (arr[right] > mid) --right; 
			if (left <= right) {
				swap(&arr[left], &arr[right]);
				left++;
				right--;               
			}
		} while (left <= right);
		if (range.start < right) r[p++] = new_Range(range.start, right);
		if (range.end > left) r[p++] = new_Range(left, range.end);
	}
}
int main()
{
	int arr[] = { 1,5,3,2,9,15,6,4,59,65,32,31 };
	int len = sizeof(arr) / sizeof(int);
	quicksort(arr, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	system("pause");
	return 0;
}

7.堆排序

算法步骤：

  1. 创建一个堆 H[0……n-1]；
  2. 把堆首（最大值）和堆尾互换；
  3. 把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
  4. 重复步骤 2，直到堆的尺寸为 1。

C源代码：

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
#include <stdio.h>
#include <stdlib.h>
//堆排序
void swap(int *a, int *b) {
	int temp = *b;
	*b = *a;
	*a = temp;
}

void maxheapify(int arr[], int start, int end) {
	
	int dad = start;
	int son = dad * 2 + 1;
	while (son <= end)
	{
		if (son + 1 <= end && arr[son] < arr[son + 1]) 
			son++;
		if (arr[dad] > arr[son]) 
			return;
		else { 
			swap(&arr[dad], &arr[son]);
			dad = son;
			son = dad * 2 + 1;
		}
	}
}

void heapsort(int arr[], int len) {
	int i;
	
	for (i = len / 2 - 1; i >= 0; i--)
		maxheapify(arr, i, len - 1);
	
	for (i = len - 1; i > 0; i--) {
		swap(&arr[0], &arr[i]);
		maxheapify(arr, 0, i - 1);
	}
}
int main()
{
	int arr[] = { 1,5,3,2,9,15,6,4,59,65,32,31 };
	int len = sizeof(arr) / sizeof(int);
	heapsort(arr, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	system("pause");
	return 0;
}

我的github地址：https://github.com/zhajianliang/sort-algorithm.git

个人博客地址：https://zhajianliang.github.io

参考地址：https://zh.wikipedia.org/wiki/%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F

参考地址：https://github.com/hustcc/JS-Sorting-Algorithm/blob/master/1.bubbleSort.md

展开全文 >>

C语言在VisualStudio2017下的一些注意事项和常见错误

1.很多小伙伴在学校期间学习C语言用的大多都是vc6.0,对于刚接触vs的小伙伴在用c写代码时难免会与遇到各种问题，比如下面的这个错误：

image-2020060

解决该错误的方法一共有三种：

第一种：找到项目,点击项目属性

image-20200602161004263

点击配置属性，C/C++，预处理器，预处理器定义然后输入_CRT_SECURE_NO_DEPRECATE，点击确定，配置完成，代码就能正常运行了。

image-20200602162425143

第二种方法：在代码的的开头加上#pragma warning(disable:4996)语句，解决该错误。

第三种方法：将scanf改为scanf_s,解决该错误。

最后希望对你有帮助，加油陌生人。

转载请附原文地址：zhajianliang.github.io

展开全文 >>

Git远程仓库管理的两种超详细教学，带你10分钟玩转git

第一种方法：用git的命令操作

1.创建git的工作区：

新建一个文件夹，进入到该文件夹，鼠标右键，点击进行GIt Bash Here，进行github的基本用户的信息配置（该步骤用于在github显示是谁提交了该文件）及该仓库的初始化指令，下面演示的是用linux的命令行实现，你也可以用鼠标右键创建文件。

指令：

1
2
3
4
5
6
mkdir test//创建test文件；
cd test//进入该文件；
git config --global user.name '自己的github的用户名'//初始化用户name
git config --global user.email '自己的github邮箱'//  初始化用户邮箱
git init  或是用git的图形界面来创建//test仓库的初始化
touch hello.txt 或vim hello.txt//新建一后缀名为txt的文件

image-20200531123957364

这时我们的test文件夹下就会有

image-20200531124122703

我们的工作区就创建完成了。

2.提交暂存区：

把之前的创建好的工作区的内容提交到暂存区

指令：

1
2
git add hello.txt//将hello.txt提交到暂存区
git status//查看是否提交成功

image-20200531125020705

这时test下的hello.txt文件如下，则添加成功

image-20200531125210635

3.将暂存区的内容提交到git仓库：

指令：

1
2
add commit -m "添加描述"//将文件提交到仓库
git status//查看是否添加成功

image-20200531130014952

这时test下的hello.txt文件如下，则添加成功

image-20200531130131248

4.修改或删除git仓库中的内容：

修改指令：

1
vi hello.txt 也可以鼠标右击打开hello.txt //修改文件保存退出

image-20200531161222134

修改以后：

image-20200531161645317

然后再重新添加到暂存区，再提交到Git仓库，修改成功。

删除文件

1
2
3
rm hello.txt  //删除文件hello.txt,或用鼠标右键删除文件
git rm hello.txt //从git仓库中把hello.txt删除
git commit -m "描述" //提交相应的描述

删除成功

5.把git仓库中的内容推送到github的仓库：

首先在github上新建一个仓库

image-20200531163522339

创建完成后，进入到该仓库，复制地址

image-20200531163750830

在Git命令窗口输入

1
2
git remote add origin https://github.com/zhajianliang/testt01.git
git push -u origin master  //将所有的本地文件提交到github.com/zhajianliang/testt01.git仓库中

这时会让你输入自己的用户名和密码

image-20200531164644269

成功推送到自己的github仓库中

image-20200531164749245

第二种方法用TortoiseGit来操作

2.首先下载安装TortoiseGit，官方网址https://tortoisegit.org/

1.初始化仓库

鼠标右键点击，Git在这里创建版本库

image-20200531165921219

初始化完成

image-20200531170326374

2.新建文件夹，右键文件夹选中TortoiseGit点击添加

image-20200531170450986

image-20200531170739226

再点击提交，提交到git的仓库，然后再点击推送，推送到github的远程仓库，这时就成功的推送到远程仓库了。

我建议用第二种方式推送到github的远程仓库，比较方便快捷。

转载此文请标明出处：https://zhajianliang.github.io

展开全文 >>

markdown语法之typora一款很好用的编辑器,教你10分钟玩转typora

1.文字
（1）删除线语法
1
~~文字~~//快捷键：Alt+Shift+5

删除线

（2）斜体语法
1
*文字*//快捷键：Ctrl+I

斜体

（3）加粗
1
**文字**//快捷键：Ctrl+B

加粗

（4）斜体+加粗
1
***斜体+加粗***

斜体+加粗

（5）下划线
1
<u>文字</u>//快捷键Ctrl+u

下划线

2.多级标题，typora一共有六级标题，#+空格+标题1是一级标题，##+空格+标题2是二级标题，###+空格+标题3是三级标题，依此类推一直到六级标题（注意#后面一定要加空格）。效果如下：
1
2
3
4
5
6
7
# 一级标题                   快捷键  ctrl+1
## 二级标题                  快捷键  ctrl+2
### 三级标题                 快捷键  ctrl+3
#### 四级标题                快捷键  ctrl+4
##### 五级标题               快捷键  ctrl+5
###### 六级标题              快捷键  ctrl+6
快捷键  ctrl+0清除标题变为普通文本
3.有序列表（快捷键 Ctrl+Shift+[），语法1+.+空格+内容，此时按回车会自动添加序号。添加或删除某一行内容，序号会自动调整。注意.后面一定的加空格，降级快捷键：Tab；（就是水果里包含了苹果，香蕉等等）升级快捷键（）：Shift+Tab；效果如下：
如果想要跳出无序可以连续按两次回车，或向下的方向键
  1. 水果
    1. 苹果
    2. 香蕉
  2. 蔬菜

白菜

青菜

4.无序列表（快捷键 Ctrl+Shift+]）*+空格+内容或-+空格+内容，注意一定不能把空格忘了，有序列表和无序列表可以交错使用。效果如下：
  • 水果
  • 香蕉
  • 白菜
  • 水果
    1. 苹果
    2. 桃子
    3. 香蕉
  • 白菜
5.任务列表语法（没有快捷键）：-+空格+[空格]+空格+内容。效果如下：
  • 任务列表1
  • 任务列表2
6.插入表格语法（快捷键:Ctrl+T）：|语文|数学|英语|政治|，然后回车，换行添加数据，鼠标指向表格中的任意一行，按Ctrl+Enter。鼠标放在表格中的任意位置，表格左上角会出现对表格的一些操作，鼠标右键可以增加表格删除表格等相关操作。可以对表格进行调整。效果如下：
语文 数学 英语 政治
58 95 125 100
45 98 65 86
7.代码块语法(快捷键：Ctrl+Shift+k)：```(Esc下面的键)+c/c++/java或~+c/c++/java相关设置：文件->偏好设置->markdown->勾选显示行号和代码块自动换行。效果如下：
1
2
3
4
5
6
include<stdio.h>
    int main()
{
    prinf("hello world");
    return 0;
}
8.之行内代码语法:
c++明显跟其他的其不一样，加粗了。
1
2
//（快捷键：Ctrl+Shift+`
//`代码语言`

c++是一类面向对面的编程语言。

9.之插入图片语法：（注意需要先设置图片保存的路径，不然写博客的时候图片会加载失败）
1
![图片名字](图片的路径)

截图

10.超链接语法：
1
2
[我的网址](https://zhajianliang.github.io)//显示的时候只会显示我的网址，点我的网址就会跳转到
   https://zhajianliang.github.io

效果：

我的网址

11.引用语法
1
2
3
>作者 李白
>>作者 王维
>>>作者 白居易

效果如下：

作者 李白

作者 王维

作者 白居易

展开全文 >>

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>谢谢大家