按升序排列数组的值

【问题标题】：Arranging values of array in Ascending order按升序排列数组的值
【发布时间】：2014-05-10 19:33:52
【问题描述】：

我无法让它工作，我正在尝试使用 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]);
        }

【问题讨论】：

  • 有什么理由不想使用Array.Sort？
  • 我认为你需要阅读数组，以及如何索引它们。
  • 我是编程新手，几周前，我能够做到这一点，但过了几个星期，事情似乎变得一团糟。
  • 我认为你正在努力学习这很好 - 调用 Array.Sort 不会帮助你了解很多关于编程/数组的知识。但是，如果我告诉你答案，你也不会学到很多东西。您需要阅读一些有关数组以及如何为它们编制索引的网页/教程，并进行试验，直到您了解发生了什么。
  • @user2864740：实际上它甚至不会到达那里，它会在i == arr.Length - 1时抛出异常。

标签： c#


【解决方案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。该算法有各种优化，可以使其运行速度稍快。
  • 一般来说，冒泡排序是较慢的排序算法之一。当要排序的项目数量较多时，您应该考虑使用高级算法，或使用库实现。

【讨论】：

    【解决方案2】：

    int[] 数组 = { 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);

    【讨论】：

      【解决方案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);

      【讨论】：

      • 有一个错字，其中 arr[i] 被双重赋值，其中一个应该是 arr[i+1]
      【解决方案4】：

      使用 Linq 排序方式：

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

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

      我认为这很容易，为什么需要 for 循环。

      【讨论】：

        【解决方案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]);
            }
        }
    }
}

        【讨论】：

        • 对于提出问题的人来说，描述为什么他们正在做的事情不起作用而不是仅仅为他们解决这样一个简单的问题可能会有所帮助。
        【解决方案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();
        }

    }
}

        【讨论】：

        • 虽然这段代码 sn-p 可以解决问题，但including an explanation 确实有助于提高帖子的质量。请记住，您是在为将来的读者回答问题，而这些人可能不知道您提出代码建议的原因。
        【解决方案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();

        【讨论】：

          【解决方案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();

          【讨论】：

            【解决方案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;
    }

            【讨论】：

              【解决方案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

              最后1个不用勾选，会自动排序。

              【讨论】：

              • 我认为这不是正确的冒泡排序。一旦发现没有要交换的值，外部循环就应该退出。它不应该计入数组的长度。
              • @Asad 我没有在这里实现冒泡排序。我正在帮助用户解决代码中的问题。如果需要优化和复杂性，也会得到照顾。我的目标是解决问题中提出的问题。谢谢。
              【解决方案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);

              【讨论】：

              • 我认为这不是正确的冒泡排序。一旦发现没有要交换的值，外部循环就应该退出。它不应该计入数组的长度。
              • 有没有没关系。它仍然是一个 O(n^2) 算法。这是出于学习目的。预优化是万恶之源。
              • 是的，这是算法的最坏情况复杂度，但是没有必要编写执行无用迭代的代码。
              • 如果你想展示基础知识，那么你应该使用原始冒泡排序算法，而不是它的优化变体。
              猜你喜欢
              • 2019-04-14
              • 1970-01-01
              • 1970-01-01
              • 2014-04-11
              • 1970-01-01
              • 2018-08-11
              • 2021-04-22
              • 1970-01-01
              • 1970-01-01
              相关资源
              最近更新 更多
              热门标签
              Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode