Javascript 对整数数组排序，保持第一位

我将如何按如下方式对数组进行排序：

[10, 7, 12, 3, 5, 6] --> [10, 12, 3, 5, 6, 7]

[12, 8, 5, 9, 6, 10] --> [12, 5, 6, 8, 9, 10] 

• 将数组[0]保留在适当的位置
• 下一个最高整数（如果有）
• 然后从最小整数开始升序

---

一个简单的解决方案是对整个数组进行排序，然后根据初始的第一个元素对结果数组进行分区

即

• 第一次排序

  [10,7,12,3]

  到

  [3,7,10,12]

• 然后将其分为

  =10

  和

  <10

  ：

  [10,12]

  和

  [3,7]

• 最后，将两者结合到

  [10,12,3,7]

未经修饰的示例实现：

函数自定义排序（输入）{
var firstElem=输入[0]；
var sortedInput=input.sort（函数（a，b）{返回a-b；}）；
var firstElemPos=sortedInput.indexOf（firstElem）；
var GREETEREQUALSSFIRSELEM=分拣输入拼接（firstElemPos）；
var lessThanFirstElem=分拣输入拼接（0，firstElemPos）；
返回更大的equalfirstElem.concat（小于firstElem）；
}
log（customSort（[10,7,12,3,5,6]）；
log（customSort（[12,8,5,9,6,10]）；
log（customSort（[12,8,5,9,12,6,10]）；
log（customSort（[12]））；
log（customSort（[]）已更新**

它不适用于array.concat，但使用此合并函数，不知道为什么

这是一种解决方案

Array.prototype.merge = function(/* variable number of arrays */){
    for(var i = 0; i < arguments.length; i++){
        var array = arguments[i];
        for(var j = 0; j < array.length; j++){
            if(this.indexOf(array[j]) === -1) {
                this.push(array[j]);
            }
        }
    }
    return this;
};

var $a = [10, 7, 12, 3, 5, 6];
var $b = [12, 8, 5, 9, 6, 10];

function reorganize($array){

  var $reorganize = [];

  $reorganize.push($array.shift());

  $array.sort(function(a, b) { return a - b; });

  $reorganize.merge($array);

  return $reorganize;
}

console.log(reorganize($a));
console.log(reorganize($b));

Array.prototype.merge=函数（/*数组的可变数目*/）{
for（var i=0；i
看看下面的代码片段

这真的很简单。只需将第一个元素从数组中移除到新数组中即可

对数组的其余部分进行排序，并检查此数组的最大值是否大于第一个元素

如果是，则将其推入结果数组。否则，将使用结果数组在数组的其余部分进行合并


var input1=[10,7,12,3,5,6]；
var expected1=[10,12,3,5,6,7]；
变量输入2=[12,8,5,9,6,10]；
var expected2=[12,5,6,8,9,10]；
函数customSort（aInput）{
var aResult=[aInput.shift（）]；
aInput=aInput.sort（函数（a，b）{返回a-b；}）；
if（aInput[aInput.length-1]>aResult[0]）{
var iMax=aInput.pop（）；
a结果推送（iMax）；
}
aResult=aResult.concat（输入）；
返回结果；
}
log（“预期：”，预期1.toString（）；
log（“排序：”，customSort（input1.toString（））；
log（“预期：”，预期2.toString（）；
log（“排序：”，customSort（input2.toString（））您可以保存第一个元素的值，并在第一个排序增量的条件中使用它。然后按标准增量排序

它的工作原理（排序顺序是从Edge开始的）

不同部分的元素表示其中一个元素进入第一部分，另一个进入第二部分，该值由条件的增量获取

同一节的元素表示两个元素都属于同一节。对于排序，返回值的增量


函数排序（数组）{
var first=数组[0]；
array.sort（函数（a，b）{
返回（a
.as控制台包装{最大高度：100%！重要；顶部：0；}
我的建议基于：


将原始数组减少为两个，其中包含第一个数组的上下数字
对每个数组排序并连接

通过这种方式，初始问题分为两个子问题，这两个子问题更容易处理


功能cSort（arr）{
var retval=arr.REDUCT（功能（acc，val）{
acc[（vala-b）。concat（retval[1]。sort（（a，b）=>a-b））；
}
//
//试验
//
log（cSort（[10,7,12,3,5,6]）；
log（cSort（[12,8,5,9,6,10]）；
log（cSort（[12,8,5,9,12,6,10]）；
console.log（cSort（[12]））；
console.log（cSort（[]）我正在使用Java：

     int[] arr = {10, 7, 12, 3, 5, 6};
     List<Integer> arr_1 = new ArrayList<Integer>();
     for(int i = 0; i < arr.length; i++)
     {
         arr_1.add(arr[i]);
     }
     Collections.sort(arr_1.subList(1,arr_1.size()));


    System.out.println(arr_1);

int[]arr={10,7,12,3,5,6}；
列表arr_1=新的ArrayList（）；
对于（int i=0；i
我的意思是，循环遍历数组，并根据您的要求将值推送到新数组中…@Marvin，谢谢。我修复了这个bug。当有不止一个元素大于<代码>数组[0 ] < /代码>时，这是不起作用的…两次。当然还有改进的余地，但可能是以一些可理解性为代价的（这是我的主要目标）。不过，我个人觉得您的解决方案更优雅。关于您的更新：
concat
返回一个新数组，您使用它就像它会修改您原来的数组一样<代码>$reorganize=$reorganize.concat（$array）应该这样做。
     int[] arr = {10, 7, 12, 3, 5, 6};
     List<Integer> arr_1 = new ArrayList<Integer>();
     for(int i = 0; i < arr.length; i++)
     {
         arr_1.add(arr[i]);
     }
     Collections.sort(arr_1.subList(1,arr_1.size()));


    System.out.println(arr_1);