1:合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;
2:合并两个单链表;
3:倒序打印一个单链表;
4:给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点;
5:找到链表倒数第K个节点;
6:反转单链表;
7:通过两个栈实现一个队列;
8:二分查找;
9:快速排序;
10:获得一个int型的数中二进制中的个数;
11:输入一个数组，实现一个函数，让所有奇数都在偶数前面;
12:判断一个字符串是否是另一个字符串的子串;
13:把一个int型数组中的数字拼成一个串，这个串代表的数字最小;
14:输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）;
15:输入两个链表，找到它们第一个公共节点;
下面简单说说思路和代码实现。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
//链表节点
NodeL
{
;
;
}
;
//二叉树节点
NodeT
{
;
;
;
}
;
|
1:合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;
合并排序一般的思路都是创建一个更大数组C，刚好容纳两个数组的元素，先是一个while循环比较，将其中一个数组A比较完成，将另一个数组B中所有的小于前一个数组A的数及A中所有的数按顺序存入C中，再将A中剩下的数存入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
|
//合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素
)
{
;
;
;
)
{
)
{
;
{
;
}
}
)
{
;
}
)
{
;
}
}
)
{
;
;
;
)
{
;
}
}
|
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
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
|
//链表节点
NodeL
{
;
;
}
;
//合并两个单链表
)
{
)
;
)
;
;
)
{
;
;
{
;
;
}
;
)
{
)
{
;
;
{
;
;
}
;
}
)
{
;
}
)
{
;
}
;
}
)
{
;
;
)
{
;
;
;
}
;
;
)
{
;
;
;
}
;
)
{
;
;
}
}
|
3:倒序打印一个单链表;
递归实现，先递归在打印就变成倒序打印了，如果先打印在调用自己就是顺序打印了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
//倒序打印一个单链表
)
{
)
{
;
;
}
}
)
{
;
;
)
{
;
;
;
}
;
}
|
4:给定一个单链表的头指针和一个指定节点的指针，在O(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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
//给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点
)
{
)
{
;
}
//删除中间节点
{
;
;
;
;
;
//删除头结点
{
;
;
;
//删除尾节点，考虑到delNode不在head所在的链表上的情况
{
;
)
{
;
}
)
{
;
;
;
}
}
}
)
{
;
)
{
;
;
;
)
{
;
)
{
;
{
;
;
}
)
{
;
}
}
;
}
}
|
5:找到链表倒数第K个节点;
通过两个指针，两个指针都指向链表的开始，一个指针先向前走K个节点，然后再以前向前走，当先走的那个节点到达末尾时，另一个节点就刚好与末尾节点相差K个节点。
|
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
|
//找到链表倒数第K个节点
)
{
)
;
;
)
{
)
{
;
{
;
}
}
;
)
{
;
;
}
;
}
)
{
;
)
{
;
;
)
{
;
)
{
;
{
;
}
}
;
)
{
;
{
;
}
}
}
|
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
|
//反转单链表
)
{
)
{
;
}
;
;
;
)
{
;
)
;
;
;
}
;
}
)
{
)
{
;
;
)
{
;
)
{
;
{
;
}
}
;
)
{
;
;
}
;
}
;
}
|
7:通过两个栈实现一个队列;
直接上代码
|
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
|
//通过两个栈实现一个队列
>
CQueue
{
:
)
{
)
{
;
;
}
;
}
)
{
)
{
;
;
}
;
}
)
{
)
{
;
;
}
;
}
)
{
;
}
:
;
;
;
)
{
;
)
{
;
}
)
{
;
;
}
}
|
8:二分查找;
二分查找记住几个要点就行了，代码也就那几行，反正我现在是可以背出来了，start=0，end=数组长度-1，while(start<=end)，注意溢出
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
//二分查找
)
{
;
;
;
)
{
;
)
{
;
)
{
;
else
{
;
}
}
;
}
|
9:快速排序;
来自百度百科，说不清楚
|
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
|
//快速排序
//之前有个面试叫我写快排，想都没想写了个冒泡,思路早忘了，这段代码来自百度百科
)
{
)
{
;
}
;
;
//用字表的第一个记录作为枢轴
)
{
;
//将比第一个小的移到低端
;
//将比第一个大的移到高端
}
//枢轴记录到位
;
;
}
)
{
;
;
;
)
{
;
}
;
}
|
10:获得一个int型的数中二进制中的个数;
核心实现就是while (num= num & (num-1))，通过这个数和比它小1的数的二进制进行&运算，将二进制中1慢慢的从后往前去掉，直到没有。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
//获得一个int型的数中二进制中1的个数
)
{
)
{
;
}
;
)
{
;
}
;
}
|
11:输入一个数组，实现一个函数，让所有奇数都在偶数前面;
两个指针，一个从前往后，一个从后往前，前面的指针遇到奇数就往后走，后面的指针遇到偶数就往前走，只要两个指针没有相遇，就奇偶交换。
|
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
|
//输入一个数组，实现一个函数，让所有奇数都在偶数前面
)
{
;
)
{
)
;
)
;
)
{
;
}
}
}
)
{
;
;
;
)
{
;
}
;
)
{
;
}
;
)
{
;
}
;
)
{
;
}
;
)
{
;
}
}
|
12:判断一个字符串是否是另一个字符串的子串;
我这里就是暴力的对比
|
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
|
//判断一个字符串是否是另一个字符串的子串
)
{
)
{
;
}
;
;
)
{
;
}
;
)
{
;
)
{
)
{
;
}
}
)
{
;
}
}
;
}
|
13:把一个int型数组中的数字拼成一个串，这个串代表的数字最小;
先将数字转换成字符串存在数组中，在通过qsort排序，在排序用到的比较函数中，将要比较的两个字符串进行组合，如要比较的两个字符串分别是A,B，那么组合成，A+B，和B+A，在比较A+B和B+A，返回strcmp(A+B, B+A)，经过qsort这么一排序,数组就变成从小到大的顺序了，组成的数自然是最小的。
|
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型数组中的数字拼成一个串，是这个串代表的数组最小
#define MaxLen 10
)
{
;
;
;
;
;
;
;
)
{
;
)
{
;
;
}
;
)
{
;
;
}
;
}
)
{
;
;
}
|
14:输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）;
递归实现，只要某个节点的两个子节点都不为空，就左右交换，让左子树交换，让右子树交换。
|
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
|
NodeT
{
;
;
;
}
;
//输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）
)
{
)
;
;
;
;
;
;
}
)
{
)
{
;
;
;
}
}
)
{
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
}
|
15:输入两个链表，找到它们第一个公共节点;
如果两个链表有公共的节点，那么第一个公共的节点及往后的节点都是公共的。从后往前数N个节点（N=短链表的长度节点个数）,长链表先往前走K个节点（K=长链表的节点个数-N），这时两个链表都距离末尾N个节点，现在可以一一比较了，最多比较N次，如果有两个节点相同就是第一个公共节点，否则就没有公共节点。
|
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
|
//输入两个链表，找到它们第一个公共节点
)
{
;
)
{
;
;
}
;
}
)
{
)
;
;
;
;
;
;
)
{
;
;
;
{
;
;
;
}
)
{
;
}
)
{
;
;
}
//如果有公共节点，必不为NULL
{
;
}
}
)
{
;
;
;
;
;
;
;
;
;
;
;
;
//两个链表相交于节点node6
;
;
//两个链表相交于节点node6
;
;
)
{
;
{
;
}
}
|