实现2个有序数组的排序
javascript的实现方法
使用系统array的sort方法实现
在javascript中有针对array的sort方法，通过传入sort方法一个比较方法，可以对数组进行排序例如排序方法为：
1 var sortByNum = function (a, b) {
2 if (a >= b) {
3 return 1;
4 }
5 return -1;
6 };
此方法中，当a>=b的时候返回正值，是将数组进行升序排列，针对sort的使用方法为
1 //生成length长度，最大为max的随机数组
2 var generateOrderedArr = function (max, length) {
3 var arr = new Array();
4 for (var i=0; i<length ; i++)
5 {
6 num = Math.round(Math.random() * max);
7 arr.push(num);
8 }
9 return arr.sort(sortByNum);
10 };
在javascript中我们使用粗暴一点的方法排序两个有序数组可以先使用concat方法将两个数组连接起来，然后使用sort方法进行排序：
1 var sortTwoOrderedArrayBySystemMethod = function(a, b, sortBy) {
2 var c = a.concat(b);
3 return c.sort(sortBy);
4 };
其中sortBy传入sortByNum后就会返回a,b两个数组的排序后的数组。
自定义方法实现
sort为javascript的系统函数，而我们是已有两个有序的数组，此种情况下使用系统方法进行排序效率较低，我们可以自己写一个效率较高的算法：
1 //对于sortBy函数，如果是升序数组则a>b的时候返回true，反之如果是降序数组则a<b的时候返回true
2 var sortTwoOrderedArray = function(a, b, sortBy) {
3 //创建一个新的数组用于保存结果
4 var result = new Array();
5 //两个数组的元素指针
6 var i = 0, j = 0;
7 //遍历两个数组，比较当前指针指向元素，写入满足比较方法的元素，并将该数组的指针前移一位
8 while (i < a.length && j < b.length) {
9 if (sortBy(a[i], b[j])) {
10 result.push(b[j++]);
11 } else {
12 result.push(a[i++]);
13 }
14 }
15 //写入两个数组中剩余的元素
16 while (i < a.length) {
17 result.push(a[i++]);
18 }
19 while (j < b.length) {
20 result.push(b[j++]);
21 }
22 return result;
23 };
此方法传入的sortBy如下：
1 var sortNum = function (a, b) {
2 if (a > b) {
3 return true;
4 }
5 return false;
6 };
此处a,b为数字，如果a,b为对象的时候可以比较对象的属性进行排序。
测试两种方法的效率
1 //比较效率
2 var testEfficiency = function() {
3 var a = generateOrderedArr(1000, 100000);
4 var b = generateOrderedArr(1000, 100000);
5 var startDate = new Date();
6 //printArr(sortTwoOrderedArray(a, b, sortNum));
7 sortTwoOrderedArray(a, b, sortNum);
8 var middleDate = new Date();
9 //print(sortTwoOrderedArrayBySystemMethod(a, b, sortByNum));
10 sortTwoOrderedArrayBySystemMethod(a, b, sortByNum)
11 var endDate = new Date();
12
13 print("粗暴的方法时间：" + (endDate - middleDate));
14 print("高效的方法时间：" + (middleDate - startDate));
15 print(startDate);
16 print(middleDate);
17 print(endDate);
18 };
对1w条数据排序测试结果如下，自定义的方法比系统方法排序要快15倍。
1 粗暴的方法时间：16
2 高效的方法时间：1
3 1330529465677
4 1330529465678
5 1330529465694
对10w条数据测试结果如下，自定义的方法比系统方法排序要快50倍。
1 粗暴的方法时间：493
2 高效的方法时间：9
3 1330529353309
4 1330529353318
5 1330529353811
完整代码如下：
1 //排序方法
2 var sortByNum = function (a, b) {
3 if (a >= b) {
4 return 1;
5 }
6 return -1;
7 };
8
9 //生成length长度，最大为max的随机数组
10 var generateOrderedArr = function (max, length) {
11 var arr = new Array();
12 for (var i=0; i<length ; i++)
13 {
14 num = Math.round(Math.random() * max);
15 arr.push(num);
16 }
17 return arr.sort(sortByNum);
18 };
19
20
21 //排序方法
22 var sortNum = function (a, b) {
23 if (a > b) {
24 return true;
25 }
26 return false;
27 };
28
29 //对于sortBy函数，如果是升序数组则a>b的时候返回true，反之如果是降序数组则a<b的时候返回true
30 var sortTwoOrderedArray = function(a, b, sortBy) {
31 //创建一个新的数组用于保存结果
32 var result = new Array();
33 //两个数组的元素指针
34 var i = 0, j = 0;
35 //遍历两个数组，比较当前指针指向元素，写入满足比较方法的元素，并将该数组的指针前移一位
36 while (i < a.length && j < b.length) {
37 if (sortBy(a[i], b[j])) {
38 result.push(b[j++]);
39 } else {
40 result.push(a[i++]);
41 }
42 }
43 //写入两个数组中剩余的元素
44 while (i < a.length) {
45 result.push(a[i++]);
46 }
47 while (j < b.length) {
48 result.push(b[j++]);
49 }
50 return result;
51 };
52
53 //用粗暴的方法，进行排序
54 var sortTwoOrderedArrayBySystemMethod = function(a, b, sortBy) {
55 var c = a.concat(b);
56 return c.sort(sortBy);
57 };
58
59 //打印出结果
60 var printArr = function(a) {
61 var str = "";
62 for(item in a) {
63 str += a[item] + ",";
64 }
65 print(str);
66 };
67
68 var print = function(str) {
69 document.write(str + "<br />");
70 //console.log(str);
71 };
72
73 //比较效率
74 var testEfficiency = function() {
75 var a = generateOrderedArr(1000, 10000);
76 var b = generateOrderedArr(1000, 10000);
77 var startDate = new Date();
78 //printArr(sortTwoOrderedArray(a, b, sortNum));
79 sortTwoOrderedArray(a, b, sortNum);
80 var middleDate = new Date();
81 //print(sortTwoOrderedArrayBySystemMethod(a, b, sortByNum));
82 sortTwoOrderedArrayBySystemMethod(a, b, sortByNum)
83 var endDate = new Date();
84
85 print("粗暴的方法时间：" + (endDate.getTime() - middleDate.getTime()));
86 print("高效的方法时间：" + (middleDate.getTime() - startDate.getTime()));
87 print(startDate.getTime());
88 print(middleDate.getTime());
89 print(endDate.getTime());
90 };
91
92 $(document).ready(function () {
93 testEfficiency();
94 });
