Question

我无法让它工作，我试图通过使用for循环以升序排列数组的值。

        int[] arr = new int[5] { 5, 6, 2, 4, 1 };

        for (int i = 0; i <= arr.Length; i++)
        {
            if (arr[i] > arr[i + 1])
            {
                int temp = arr[i + 1];
                arr[i] = arr[i + 1];
                arr[i] = temp;
            }

            Console.Write(arr[i]);
        }

Answer 1

我假设您没有使用Array.Sort，因为您这样做是为了学习练习;没有其他方法可以避免这种非常常见的库函数。

您的算法不起作用的原因是，仅通过一次数组并交换乱序的项目是不够的。尝试将此作为心理实验，当数组几乎排序，但第一个元素在最后，如下所示：

2 3 4 5 6 7 1

单一路径可以让您更接近，但它不会带您一直到排序数组：

2 3 4 5 6 1 7

如您所见，您必须多次重复此过程，直到对数组进行排序。你怎么知道数组是排序的？你知道当整个内部循环没有单个交换时。

以下是如何实现这一点：

bool didSwap;
do {
    didSwap = false;
    for (int i = 0; i < arr.Length-1; i++)
    {
        if (arr[i] > arr[i + 1])
        {
            int temp = arr[i + 1];
            arr[i + 1] = arr[i];
            arr[i] = temp;
            didSwap = true;
        }
    }
} while (didSwap);
for (int i = 0; i != arr.Length ; i++) {
    Console.Write(arr[i]);
}

请注意代码中的一些更改：

在分拣完成后，在单独的循环中完成打印
循环转到arr.length-1，而不转移到arr.length，否则您的最后一次检查将超出数组的范围。
此排序算法称为Bubble Sort。这种算法有各种优化，可以使它更快一些。
通常，冒泡排序是较慢的排序算法之一。当要排序的项目数量很多时，您应该考虑使用高级算法，或者使用库实现。

Answer 2

int [] Array = {11,33,5，-3,19,8,49};

        int temp;

        for (int i = 0; i < Array.Length - 1; i++)
        {

            for (int j = i + 1; j < Array.Length; j++)
            {
                if (Array[i] > Array[j])
                {

                    temp = Array[i];
                    Array[i] = Array[j];
                    Array[j] = temp;

                }

            }

        }

        Console.Write("Sorted:");

        foreach (int sort in Array)
            Console.Write("{0} ", sort);

Answer 3

如果你想进行自己的排序，那么仅仅循环一次并交换它们是不够的。与此最接近的是bubble sort算法，您可以重复循环遍历数组，直到没有更多要交换的项目为止：

int[] arr = new int[5] { 5, 6, 2, 4, 1 };

bool swapped = true;
while (swapped) {
  swapped = false;
  for (int i = 0; i < arr.Length - 1; i++) {
    if (arr[i] > arr[i + 1]) {
      swapped = true;
      int temp = arr[i + 1];
      arr[i] = arr[i + 1];
      arr[i] = temp;
   }
  }
}
for (int i = 0; i < arr.Length - 1; i++) {
  Console.Write(arr[i]);
}

还有内置的数据排序方法，更易于使用，更高效，并且已经过全面测试：

int[] arr = new int[5] { 5, 6, 2, 4, 1 };
Array.Sort(arr);

Answer 4

使用Linq Order by：

int[] arr = new int[5] { 5, 6, 2, 4, 1 };

int[] ascOrderedArray = (from i in arr orderby i ascending select i).ToArray();

我认为这可能很简单，为什么你需要循环。

Answer 5

using System;
namespace bubble_sort
{
    class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program();
            int[] arr = new int[50]; 
            int n;
            Console.WriteLine("Enter no of elements you want to store in an array");
            n = Convert.ToInt32(Console.ReadLine()); 
            Console.WriteLine("Enter elements in an array");
            for (int i = 1; i <= n; i++)
            {
                arr[i] = Convert.ToInt32(Console.ReadLine());
            }
            p.bubblesort(arr, n);
            Console.ReadKey();
        }
        public void bubblesort(int[] arr, int n)
        {
            int temp;
            for (int i = 1; i <= n; i++)
            {
                for (int j = 1; j <= n - i; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            Console.WriteLine("Array after sorting");
            for (int i = 1; i <= n; i++)
            {
                Console.WriteLine(arr[i]);
            }
        }
    }
}

Answer 6

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace basicsorting
{
    public class Program
    {
        public static void Main(string[] args)
        {
            int i2, k, j;

            Console.WriteLine("How many elements you want to sort? ");

            i2 = Convert.ToInt32(Console.ReadLine());
            int[] values = new int[i2];
            int n1 = 0;
            int n = 0; ;
            int i;
            Console.WriteLine("Enter the elements of array {0}", n1);
            for (i = 0; i < i2; i++)
            {
                Console.WriteLine("Enter the elements of array {0}");
                n = Convert.ToInt32(Console.ReadLine());
                Convert.ToInt32(values[i] = n);
            }

            for (i = 0; i < i2; i++)
            {
                k = Convert.ToInt32(values[i]);
                for (j = i - 1; j >= 0 && k < values[j]; j--)
                    values[j + 1] = values[j];
                values[j + 1] = k;
            }

            for (i = 0; i < i2; i++)
            {
                Console.WriteLine("sorting elements {0}", values[i]);
            }
            Console.ReadLine();
        }

    }
}

Answer 7

        int[] array = new int[] { 8, 9, 5, 6, 7, 4, 3, 2, 1 };
        int[] outPut = new int[] { };
        int temp = 0;
        for (int i = 0; i < array.Length; i++)
        {
            for (int j = 0; j < array.Length; j++)
            {
                var first = array[i];
                var second = array[j];
                if (array[i] < array[j]) {
                    temp = first;
                    array[i] = second;
                    array[j] = temp;
                }
            }
        }
        foreach (var item in array) {
            Console.WriteLine(item);
        }
        Console.ReadKey();
        }
        foreach (var item in array) {
            Console.WriteLine(item);
        }
        Console.ReadKey();

Answer 8

    int temp = 0;
    int[] arr = new int[] { 5, 6, 2, 4, 1 };
    for (int i = 0; i <= arr.Length - 1; i++)
    {
        for (int j = i + 1; j <= arr.Length - 1; j++)
        {
            if (arr[i] > arr[j])     //> Asecnding Order < Desending Order
            {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        Console.Write(arr[i]);
    }
    Console.ReadLine();

Answer 9

   public int[] sortArray(params int[] numbers)

    {
        for(int i = 0; i < numbers.Length; i++)
        {
            for(int j = i + 1; j < numbers.Length; j++)
            {
                if (numbers[i] < numbers[j])
                {
                    continue;
                }else if (numbers[i] > numbers[j])
                {
                    int temp = numbers[i];
                    numbers[i] = numbers[j];
                    numbers[j] = temp;
                }


            }
        }

        return numbers;
    }

Answer 10

你应该这样做：

int [] arr = new int [5] {5,6,2,4,1};

        for (int i = 0; i < arr.Length-1; i++)
        {
            if (arr[i] < arr[i + 1])
            {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }



        }

//验证已排序的数组

for（int i = 0; i＆lt; arr.Length; i ++） { console.write（arr [i] .ToString（））; }

对于最后1个，您无需检查它是否会自动订购。

Answer 11

@Jon Skeet他们想要使用for循环。

有很多种类的种类。最简单的是冒泡排序。

int[] arr = new int[5] { 5, 6, 2, 4, 1 };

//bubble sort
for (int i = arr.Length - 1; i > 0; i--)
{
    for (int j = 0; j <= i - 1; j++)
    {
        if (arr[j] > arr[j + 1])
        {
            int highValue = arr[j];

            arr[j] = arr[j + 1];
            arr[j + 1] = highValue;
        }
    }
}

foreach(int i in arr) Console.Write(i);

按升序排列数组的值

11 个答案: