Question

对于与前者的差异小于3的每个元素，按降序排序

numbers = {1,2,3,4,5,6,13,18,25,30,31,32,33}

desired = {6,5,4,3,2,1,13,18,25,33,32,31,30}

例如在数字列表中，因为6和5之间的差异小于3，所以按降序排序

Answer 1

您可以使用LINQ：

var numbers = new int[] { 1, 2, 3, 4, 5, 6, 13, 18, 25, 30, 31, 32, 33 };

var result = numbers.GroupAdjacent((x, y) => y - x < 3)
                    .SelectMany(g => g.OrderByDescending(x => x))
                    .ToArray();

// result == { 6, 5, 4, 3, 2, 1, 13, 18, 25, 33, 32, 31, 30 }

与

static IEnumerable<IEnumerable<T>> GroupAdjacent<T>(
    this IEnumerable<T> source, Func<T, T, bool> adjacent)
{
    var g = new List<T>();
    foreach (var x in source)
    {
        if (g.Count != 0 && !adjacent(g.Last(), x))
        {
            yield return g;
            g = new List<T>();
        }
        g.Add(x);
    }
    yield return g;
}

Answer 2

你好太复杂了..
因为我没有Visual Studio所以我在javascript中编写了代码，以满足您的要求

     <script>
        var a = [1,2,3,4,5,6,13,18,25,30,31,32,33];

        alert(custom_sort(a));

        function custom_sort(a) {
            var objArrayList = {};              
            var index = 0;
            var where_i_am = 0;
            objArrayList[index] = Array();
            if(a[1]-a[0] < 3){
                where_i_am = 1;
                objArrayList[index].push(a[0]);
            } else {
                where_i_am = 2;
                objArrayList[index].push(a[0]);
            }
            for(var i=1;i<a.length;i++) {
                if(a[i]-a[i-1] < 3) {
                    if(where_i_am ==2) {
                        where_i_am = 1;
                        index++;
                        objArrayList[index] = Array();
                    }
                    if(where_i_am==1) 
                        objArrayList[index].push(a[i]);
                } else {
                    if(where_i_am==1) {
                        where_i_am =2;
                        index++;
                        objArrayList[index] = Array();
                    }
                    if(where_i_am==2)  {
                        objArrayList[index].push(a[i]);
                    }
                }
            }
            var new_array = new Array();
            for(var obj in objArrayList) {
                var array_val = objArrayList[obj];
                if(array_val[1] - array_val[0] < 3) {
                    new_array = new_array.concat(sort_desc(array_val));
                } else {
                    new_array = new_array.concat(sort_asc(array_val));
                }
            }
            return new_array;


        }
        function sort_asc(array_val){
            for(var i =0;i<array_val.length;i++) {
                for(var j=0;j<array_val.length;j++) {
                    if(array_val[i] < array_val[j]) {
                        var temp = array_val[i];
                        array_val[i] = array_val[j];
                        array_val[j] = temp;
                    }
                }
            }
            return array_val;
        }
        function sort_desc(array_val){
            for(var i =0;i<array_val.length;i++) {
                for(var j=0;j<array_val.length;j++) {
                    if(array_val[i] > array_val[j]) {
                        var temp = array_val[i];
                        array_val[i] = array_val[j];
                        array_val[j] = temp;
                    }
                }
            }
            return array_val;
        }
    </script>

Answer 3

对我来说，这样的算法看起来非常不标准，所以我觉得应该使用很少的算法来在复杂性方面取得好的结果。有一个非常重要的问题 - 初始数组是否已经排序？

任何方式都可以通过子数组拆分数组开始：

将这样的数组拆分为多个（有一些指示器是否应对每个数组进行排序） ASC或DESC）

然后，如果未对初始数组进行排序：

然后使用QuickSort逐个对所有子数组进行排序，这样您就会得到一组已排序的数组
然后你可以使用每个元素的第一个元素对子数组进行排序，这样就可以保存子数组的顺序（希望我说的很清楚）

但是如果对初始数组进行了排序：

以最初保留的顺序合并子数组

如何在c＃中对数字进行排序？

3 个答案: