排序问题！求解答（js）

题目为：将两个已知的，已经排好序的升序数组arr1和arr2，整合为一个仍未升序的新数组arr3，时间复杂度最小的办法是什么？
例：arr1 = [2,4,7,13], a2 = [1,3,5,6,7,9]，
得到：arr3 = [1,2,3,4,5,6,7,7,9,13]

我想到的方法如下：

    var a1 = [2,4,7,13], a2 = [1,3,5,6,7,9];

    function sortAB(a1, a2) {
        var i = 0,
            j = 0,
            a3 = [];
        var length = a1.length + a2.length;
        for(let k=0; k<length; k++){
            if(a1[i] < a2[j]) {
                a3.push(a1[i]);
                i++;
            } else {
                a3.push(a2[j]);
                j++;
            }
        }
        return a3;
    }

    console.log(sortAB(a1, a2));

但得出的结果却是 [1,2,3,4,5,6,7,7,9,undefined]

求问原因何在？？？如何解决？？？

应为你13大于a2中所有元素，所有还是执行else，但是j++大于数组长度导致压入了undefined，并且a1的最大值没有压入，要做个判断是否已经越界


    var a1 = [2, 4, 7, 13], a2 = [1, 3, 5, 6, 7, 9];

    function sortAB(a1, a2) {
        var i = 0,
            j = 0,
            a3 = [];
        var a1l=a1.length,a2l=a2.length
        var length = a1l + a2l;
        for (let k = 0; k < length; k++) {
            if (a1[i] < a2[j]) {
                if (i < a1l) {
                    a3.push(a1[i]);
                    i++;
                } else {//压入b中所有剩余元素
                    for (var l = j; l < a2l; l++) a3.push(a2[l]);
                    break;
                }
            } else {
                if (j < a2l) {
                    a3.push(a2[j]);
                    j++;
                }
                else {//压入a中所有剩余元素

                    for (var l = i; l < a1l; l++) a3.push(a1[l]);
                    break
                }
            }
        }
        return a3;
    }

    console.log(sortAB(a1, a2));

最简单的排序

 var arr1=[1,2,3,4,5];
var arr2=[6,7,10,11,22,23];
function sort(arr1,arr2){
    var arr3=arr1.concat(arr2).sort((a,b)=>{ return a-b});
    console.log(arr3)
}
sort(arr2,arr1);

首先肯定是判断除了问题，a1 13最大值，导致条件恒不满足所以在循环终止时都是在添加push(a2[j]);所以要稍微修改下判断条件即可。

这样判断类似 var a1 = [2,3,5,6,7,9], a2 = [2,3]; 这样的 a2.length<a1.lenght 数组也会出现问题
一般长短循环比较都是用较短的那一个长度，作为循环判断标准，
所以代码

    function sortAB(a1, a2) {
        var i = 0,
            j = 0,
            a3 = [];
        var length = a1.length + a2.length;
        if(a1.length>a2.length){
            var temp = a1;
            a1 = a2;
            a2 = temp;
        }
        for(let k=0; k<length; k++){
            if(a1[i] <= a2[j]||!a2[j]) {
                a3.push(a1[i]);
                i++;
            } else {
                a3.push(a2[j]);
                j++;
            }
        }
        return a3;
    }

插入排序

 var arr1=[1,2,3,4,5];
var arr2=[6,7,10,11,22,23];
function sort(arr1,arr2){
    var arr3=arr1.concat(arr2);
    for(var i=0;i<arr3.length;i++){
        var t=arr3[i];
        var p=i-1;
        while(arr3[p]>t&&p>=0){
            arr3[p+1]=arr3[p];
            p--;
        }
        arr3[p+1]=t;
    }
    return arr3;
}
console.log(sort(arr2,arr1));//[ 1, 2, 3, 4, 5, 6, 7, 10, 11, 22, 23 ]

对两个已经有序的数组排序，最好是归并
var a1 = [2,4,7,13], a2 = [1,3,5,6,7,9];

function sortAB(a1, a2) {
    var i = 0,
        j = 0,
        a3 = [];
            // 先把a1或者a2完全装入到a3中
    while (i < a1.length && j < a2.length) {
        if(a1[i] < a2[j]) {
            a3.push(a1[i]);
            i++;
        } else {
            a3.push(a2[j]);
            j++;
        }
    }
            // 如果a1有剩余, 将剩余元素装入a3
            for (; i < a1.length; i++) a3.push(a1[i]);
            // 如果a2有剩余, 将剩余元素装入a3
            for (; j < a2.length; j++) a3.push(a2[i]);
    return a3;
}

console.log(sortAB(a1, a2));

先把数组合并，在用sort（）排序就行

错就错在你的算法有问题，因为你的那个写法是永远不可能把最大的值加进去的，为什么？因为你所加的都是两个数组中相对较小的一个，因此13是不可能加到里面去的
而又因为你定死了length。所以最后加了个未定义的类别“undefined”，懂？
如果想得到排好序的数组，最好还是用conact还有sort方法

最小时间复杂度O(n)