算法分享

Question

昨遇1算法 有1无序数组，设计算法按奇数在左，偶数在右排列。对于多年不摸课本的我来说，算法就成了我头痛的问题，夜不能寐。早晨终于忍不住打开了vs.net,还好写出来了，算是复习了。欢迎朋友们拍砖，有更好的方法请赐教！int[] arr ={ 1, 2, 3, 4, 5, 6, 7,8,9,10,12,14,15,17,19};        for (int i = 0; i < arr.Length; i++)
        {
            if (isOdd(arr[i]))
            {
                int temp = arr[i];
                for (int j = i; j >0; j--)
                {
                    arr[j] = arr[j - 1];                
                }
                arr[0] = temp;
            }        
        }
        for (int t = 0; t < arr.Length; t++)
        {            Response.Write(arr[t]+" ");
        }     
   
    //判断是否是奇数
    private bool isOdd(int n)
    {
        return Convert.ToBoolean(n % 2);
    
    }

Answer 1

            int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 17, 19 };            arr = arr.Where(x => x % 2 == 1).Union(arr.Where(x => x % 2 == 0)).ToArray();            for (int t = 0; t < arr.Length; t++)
            {
                Response.Write(arr[t] + " ");
            }

Answer 2

这是一个复杂一点但是通用的方法。
你可以按照模2来分组，也可以按照其他模分组。
比如 n = 3，按照被 3 除余数1、2和能被3整除分类。
1 4 7 10 19 2 5 8 14 17 3 6 9 12 15 
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 17, 19 };int n = 2;
arr = arr.GroupBy(x => x % n, (key, group) => new { key, group }).Aggregate((current, serials) => new { key = current.key, group = current.group.Union(serials.group) }).group.ToArray();for (int t = 0; t < arr.Length; t++)
{
    Response.Write(arr[t] + " ");
}

Answer 3

想复杂了，再给你个简单的，呵呵
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 17, 19 };arr = arr.OrderBy(x => (x + 1) % 2).ToArray();for (int t = 0; t < arr.Length; t++)
{
    Response.Write(arr[t] + " ");
}

Answer 4

能讲一下
arr = arr.OrderBy(x => (x + 1) % 2).ToArray();
这句话内部是用什么方法来做排序的么？其实lz的问题，随便找到一个排序的算法就行了，只不过一般的排序按照大小来排，这个排序是按照奇偶罢了！

Answer 5

分享我的。public class MyArrayTest
    {
        public static void Meth(int [] arr)
        {
            int end = arr.Length-1;            for (int i = 0; i < arr.Length && i <end; i++)
            {
                if (!IsOdd(arr[i]))
                {
                    while (!IsOdd(arr[end]))
                    {
                        end--;
                        if (i >= end)
                        {
                            break;
                        }
                    }
                    if (i < end)
                    {
                        arr[i] = arr[i] + arr[end];
                        arr[end] = arr[i] - arr[end];
                        arr[i] = arr[i] - arr[end];
                    }
                }
            }
        }        private static bool IsOdd(int num)
        {
            return num % 2 != 0;
        }
    }

Answer 6

应该是变种的快排。因为种种实验都表明，似乎OrderBy是稳定的。