Console.WriteLine("Input 10 numbers: ");
        int[] number = new int[10];
        for (int i = 0; i < number.Length; i++) {
            number[i] = int.Parse(Console.ReadLine());
            if (number[i] == 0) {
                Console.WriteLine("input of 0 is not alllowed!");
                break;
            }
        }
        //EVEN NUMBERS
        for (int i = 0; i < number.Length; i++) {
            if (number[i] % 2 == 0) {
                Console.Write("{0} ", number[i]);
            }
        }
        //ODD NUMBERS
        for (int i = 0; i < number.Length; i++) {
            if (number[i] % 2 != 0) {
                Console.Write("{0} ", number[i]);
            }
        }

你可以实现各种好的排序算法，我不会讨论这些算法，因为这与你的问题有些偏离主题，但这里有一个页面链接，描述了其中的许多算法。

用任何排序算法解决问题的关键是要有一个好的比较函数，它可以告诉你值应该按什么顺序显示。在你的情况下，比较的重要规则是：1.奇数总是在偶数之前2.低奇数应该在高奇数之前3.偶数越高，越低

因此，您的比较函数可能如下所示（注意：我通常不会以这种方式命名函数或参数，但在本例中，它会使其更加清晰）

public bool AComesBeforeB(int a, int b) 
{
    if(IsOdd(a))
    {
        if(IsOdd(b))
        {
            return a < b;
        }
        else
        {
            return true;
        }
    }
    else
    {
        if(isOdd(b))
        {
            return false;
        }
        else
        {
            return a > b;
        }
    }
}

或者，您可以按照yytr3的建议进行操作，将偶数和奇数拆分为不同的数组，然后从中对它们进行排序。我不喜欢这样做，因为它需要更多的代码和内存，但它基本上也能正常工作。

还有几条与您的问题没有直接关系的注释：

1. 看看如果有人输入了0（提示，它没有正确运行）会发生什么

2. 根据您的代码和示例输入，您假设输入始终是一系列整数，如果用户输入一个带小数的数字会发生什么？还是按字母顺序排列的字符串？（提示：异常会使程序崩溃）

3. 确保你的程序能处理负数，就目前的情况来看，我不明白为什么它不能，但在处理数字输入时，这总是一个很好的测试

4. 这看起来像是一项家庭作业，虽然就问题的特定部分寻求建议和帮助是可以的，但不要试图使用SO为你做家庭作业，要明确的是，我不认为你在做这件事，但Rariolu的答案基本上是批发给你代码，如果作为你自己的作品提交，这可能会被视为哗众取宠

5. 当你说你想在"没有任何方法"的情况下完成这项工作时，这就暴露了对方法的误解。这些代码本质上是在方法内部运行的，为了以清晰易懂的方式编写这些代码，你需要编写自己的方法，可以从主方法调用这些方法。我想你真正想说的是"我必须不使用通常用于排序的C#库方法"。

在考虑如何实现以下代码时，应该遵循以下步骤：

• 将数组拆分为两个数组，一个包含奇数，另一个包含偶数
• 创建一个按升序对数组进行排序的方法
• 使用此函数对两个数组进行排序，但将偶数数组的顺序颠倒

在伪代码中，它看起来类似于以下内容：

//Array you get from the user
arr = get_user_inputs()
def split(array) :
  even = []
  odd  = []
  for item in array:
     if( item %2 == 0):
         even.append(item)
     else:
         odd.append(item)
  return (even,odd)
(even,odd) = split(arr)
(even,odd) = ( sort(even) , sort(odd) )
print(odd.toString + even.toString.reverse)

为了实现排序算法本身，我建议查找一些简单的排序算法，如选择排序

youtube上有一段来自CS50的视频，解释了这种算法，它做得很好：

https://www.youtube.com/watch?v=f8hXR_Hvybo

如果您键入一个字母，请检查您的输入是否崩溃。。。

number[i]=int.Parse（Console.ReadLine（））；

您成功地检测到奇数/偶数，但在打印出来之前，您需要将这些数字存储在中间数组中。

有两种方法

1

1. 取最低奇数，从输入列表中删除并添加到新列表中
2. 重复直到没有奇数为止
3. 取最高偶数，从输入列表中删除并添加到新列表中
4. 重复，直到没有偶数为止
5. 打印出新列表

2（利用现有资源）

1. 创建一个列表来存储奇数，一个列表用于存储偶数
2. 当你找到数字时，将它们添加到适当的列表中（奇数/偶数）（而不是像现在这样打印到控制台）。也按要求的顺序添加。例如，对于列表的长度，如果数字大于i处的项目，则在i处插入
3. 打印出两个列表

我会首先将数字拆分为两个列表（是的，我会使用列表而不是数组），然后创建一个BubbleSort函数来确定方向。

https://en.wikipedia.org/wiki/Bubble_sort

如果这个链接不够，您应该能够找到大量的实现链接来帮助您。

这应该有效：（请记住，"数字"是一个包含所有数字的数组。

List<int> oddnumbers = new List<int>();
List<int> evennumbers = new List<int>();
foreach(int number in numbers)
{
    if(numer % 2 == 0)//If number is divisible by 2(is even)
    {
        evennumbers.Add(number);
    }
    else//If number is not divisible by 2(is odd)
    {
        oddnumbers.Add(number);
    }
}
evennumbers = evennumbers.Sort();
oddnumbers = oddnumbers.Sort();//Sort both lists so that they values are in ascending order.
evennumbers = evennumbers.Reverse();//Reverse the items in "evennumbers" into descending order.
List<int> newnumbersequence = new List<int>();
foreach(int number in oddnumbers)
{
    newnumbersequence.Add(number);
}
foreach(int number in evennumbers)
{
    newnumbersequence.Add(number);
}

然后把这些放在一个静态类中

public static List<int> Sort(this List<int> numbers)
{
    int[] temp = numbers.ToArray();
    for(int i = 0; i < temp.Length-1; i++)
    {
        int index = i;
        while(index > -1)
        {
            if (temp[index] > temp[index+1])
            {
                int num1 = temp[index];
                int num2 = temp[index+1];
                temp[index] = num2;
                temp[index+1] = num1;
            }
        }
    }
    return temp.ToList();
}
public static List<int> Reverse(this List<int> numbers)
{
    List<int> returner = new List<int>();
    for(int i = numbers.Count-1; i > -1; i++)
    {
        returner.Add(numbers[i]);
    }
    return returner;
}

主要是伪代码，显示如何分解工作。

// initial conditions
evens = new List  // standard C# List<T> interface
odds = new List
i = 0;
// read numbers
while (i++ < 10) {
  filter(input);
}
print(odds, evens)

以下是"工作者"功能：

// decide if it goes to the even or odd:
filter(input) {
  if(input % 2 == 0) {
     // sort descending
     sort(evens, input, "desc");
  } else {
     sort(odds, input, "asc");
  }
}
// given a list, a new input to add, and direction,
// the function mutates the list accordingly
sort(list, input, direction) {
  for(j = 0; j < list.length; j++) {
    item = list[j];
    if((direction == "desc" && item < input) 
       || (direction == "asc" && item > input))
    {
      list.insert(j, input);
      return
    }
  }
  list.add(input);  // lastly, if nothing else was triggered 

我想最重要的缺失部分是排序算法。上面，我实现了插入排序的变体，它使用List.insert方法作为移动"数组"中已排序部分的快捷方式。