利用可变数组将用户输入数字排序后输出

来源：互联网发布：python 求均值方差编辑：程序博客网时间：2024/04/29 07:17

对于数字的排序有很多的算法，像冒泡排序法，插入排序法，选择排序法，希尔排序法，快速排序法等

大多数情况下对于用户输入的内容进行排序我们可以直接是使用ArrayList.Sort()方法

代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "";
            ArrayList  al =new ArrayList();
            Console.WriteLine(" 请输入数字，输入exit退出");
            str = Console.ReadLine();
            while (str != "exit")
            {
                int num = int.Parse(str);
                al.Add(num);
                str = Console.ReadLine();                
            }
            al.Sort();
            for (int i = 0; i < al.Count; i++)
            {
                Console.WriteLine("第{0}个数是：{1}", i + 1, al[i]);
            }
            Console.ReadLine();
        }
    }
}

另贴出各种算法的代码

假设用户的输入数据已经存入List数组

         /// <summary> 
         /// 冒泡排序法 
         /// </summary> 
         /// <param name="list"></param>  
          public static void BubbleSort(int[] list)
          {
              for (int i = 0; i < list.Length; i++)
              {
                  for (int j = i; j < list.Length; j++)
                  {
                      if (list[i] < list[j])
                      {
                         int temp = list[i];
                         list[i] = list[j];
                         list[j] = temp;
                     }
                 }
             }
         }
         /// <summary> 
         /// 插入排序法 
         /// </summary> 
         /// <param name="list"></param> 
         public static void InsertionSort(int[] list)
         {
             for (int i = 1; i < list.Length; i++)
              {
                 int t = list[i];
                 int j = i;
                 while ((j > 0) && (list[j - 1] > t))
                 {
                     list[j] = list[j - 1];
                     --j;
                 }
                 list[j] = t;
             }
         }
         //// <summary> 
         /// 选择排序法 
         /// </summary> 
         /// <param name="list"></param> 
         public static void SelectionSort(int[] list)
         {
             int min;
             for (int i = 0; i < list.Length - 1; i++)
             {
                 min = i;
                 for (int j = i + 1; j < list.Length; j++)
                 {
                     if (list[j] < list[min])
                         min = j;
                 }
                 int t = list[min];
                 list[min] = list[i];
                 list[i] = t;
             }
         }
        //// <summary> 
        /// 希尔排序法 
        /// </summary> 
        /// <param name="list"></param> 
        public static void ShellSort(int[] list)
        {
             int inc;
             for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;
             for (; inc > 0; inc /= 3)
             {
                 for (int i = inc + 1; i <= list.Length; i += inc)
                 {
                     int t = list[i - 1];
                     int j = i;
                     while ((j > inc) && (list[j - inc - 1] > t))
                     {
                         list[j - 1] = list[j - inc - 1];
                         j -= inc;
                     }
                     list[j - 1] = t;
                 }
             }
         }
         private static void Swap(ref int l, ref int r)
         {
             int s;
             s = l;
             l = r;
             r = s;
         }
         /// 快速排序法 
         /// </summary> 
         /// <param name="list"></param> 
         /// <param name="low"></param> 
         /// <param name="high"></param> 
         public static void Sort(int[] list, int low, int high)
         {
             int pivot;
             int l, r;
             int mid;
             if (high <= low)
                 return;
             else if (high == low + 1)
             {
                 if (list[low] > list[high])
                     Swap(ref list[low], ref list[high]);
                 return;
             }
             mid = (low + high) >> 1;
             pivot = list[mid];
             Swap(ref list[low], ref list[mid]);
             l = low + 1;
             r = high;
             do
             {
                 while (l <= r && list[l] < pivot)
                     l++;
                 while (list[r] >= pivot)
                     r--;
                 if (l < r)
                     Swap(ref list[l], ref list[r]);
             } while (l < r);
             list[low] = list[r];
             list[r] = pivot;
             if (low + 1 < r)
                 Sort(list, low, r - 1);
             if (r + 1 < high)
                 Sort(list, r + 1, high);
         }

对于用户以字符串形式输入的数据进行排序，我参考了网上的一些帖子，进行如下处理

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = "123,451,908,72,321,456";
            int[] array = Array.ConvertAll<string, int>(str.Split(new char[] { ',' }), new Converter<string, int>(Convert.ToInt32));
            Array.Sort(array);
            foreach (int i in array)
            {
                Console.WriteLine(i);
            }
            Console.ReadLine();
        }
    }
}

对于不是','分隔的处理方法类似,不再累述。