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

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

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

您可以从通过子数组拆分数组开始：

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

那么如果一个初始数组没有排序：

1. 然后使用 QuickSort 将所有子数组逐一排序，这样就得到了一组排序好的数组
2. 然后您可以使用每个子数组的第一个元素对子数组进行排序，因此应保存子数组的顺序（希望我描述得足够清楚）

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

1. 按最初保留的顺序合并子数组