Question

C#比较四个数字大小的思路

C#程序设计里面要求设计一个比较四个数字大小并能从小到大排列显示出来的程序，除了先把数字两两比较得出略大的数字，在把两个略大略小的数字比较出最大最小后，比较中间数的思路以外还有其他什么思路？

Answer 1

你说的那个方法是冒泡排序

其实我可以把你的问题理解为4个数字的数组排序问题，那样的话排序就有好多中方法

一、冒泡排序 

冒泡排序：
public void Sort(int[] array)
 {
            int i, j;  // 循环变量
            int temp;  // 临时变量
            for (i = 0; i < array.Length; i++)
            {
                for (j = 0; j < array.Length - 1 - i; j++)
                {
                    if (array[j] > array[j + 1])
                    {
                        // 交换元素
                        temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                }
            }
 }

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不
变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比较a[3]与a[4]，依此类推，最后比较a[n-1]与
a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是
a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序
排列了。 

优点：稳定，比较次数已知； 

缺点：慢，每次只能移动相邻两个数据，移动数据的次数多。

二、选择排序 

 private static void Shell_Sort(int[] b)        {
            int[] a = new int[b.Length];
            b.CopyTo(a, 0);
            int key;
            Console.WriteLine("Shell排序");
            int gap=5,k;
            for(;gap>0;gap/=2)
                for (int j = gap; j < 10; j++)
                {
                    if (a[j] < a[j - gap])
                    {
                        key = a[j];
                        for (k = j - gap; k >= 0 ; k -= gap)
                        {
                            if (key < a[k])
                            {
                                a[k + gap] = a[k];
                            }
                            else
                                break;
                        }
                        a[k + gap] = key;
                    }
                }
            Print(a);
        }

已
知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不
变。再比较a[1]与a[3]的值，若a[1]大于a[3]则交换两者的值，否则不变。再比较a[1]与a[4]，依此类推，最后比较a[1]与a[n]
的值。这样处理一轮后，a[1]的值一定是这组数据中最小的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是
a[2]~a[n]中最小的。再将a[3]与a[4]~a[n]以相同方法比较一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升
序排列了。 

优点：稳定，比较次数与冒泡排序一样，数据移动次数比冒泡排序少； 

缺点：相对之下还是慢。

三、插入排序 

/** 
* 插入排序数组 
* @author Edwin 
* @version 1.1 
*/ 
public class InsertionArray { 
/** 
  * 插入排序数组 
  * @param lngArr为要排序的数组 
  */ 
    public void insertionSort(long[]lngArr) 
      { 
    int intOut=0,intIn=0,intElems=lngArr.length; 
      for(intOut=1; intOut <intElems; intOut++) 
          { 
          long temp = lngArr[intOut]; 
          intIn = intOut; 
          while(intIn>0 && lngArr[intIn-1] >= temp) 
            { 
          lngArr[intIn] = lngArr[intIn-1]; 
              --intIn; 
            } 
          lngArr[intIn] = temp; 
          }  // end for 
      }    // end insertionSort() 
}

已
知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。首先比较b[1]与
a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数
据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。b[2]~b[m]用相同方法插
入。（若无数组a，可将b[1]当作n=1的数组a） 

优点：稳定，快； 

缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。

四、缩小增量排序 

由希尔在1959年提出，又称希尔排序。 

已
知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。发现当n不大是，插入排序的效果很好。首先取一增量d(d
<n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、
a[2d]、a[3d]……列为最后一组依此类推，在各组内用插入排序，然后取d' <d，重复上述操作，直到d=1。 

优点：快，数据移动少； 

缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。

五、快速排序 

快速排序是冒泡排序的改进版，是目前已知的最快的排序方法。 

已
知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先任取数据a[x]作为基准。比较a[x]与其它数据并排序，使a[x]排在数据
的第k位，并且使a[1]~a[k-1]中的每一个数据
<a[x]，a[k+1]~a[n]中的每一个数据>a[x]，然后采用分治的策略分别对a[1]~a[k-1]和a[k+1]~a[n]两
组数据进行快速排序。 

优点：极快，数据移动少； 

缺点：不稳定。

追问

i < array.Length; i++)
{
for (j = 0; j < array.Length - 1 - i; j++)
这里什么意思？我还没学到这里

追答

array.Length为数组长度 如果你是4个数比较 这里 array.Length就等于4
这是两个for循环 冒泡排序就是两个for循环嵌套

Answer 2

你说的那个方法是冒泡排序
其实我可以把你的问题理解为4个数字的数组排序问题，那样的话排序就有好多中方法
一、冒泡排序
冒泡排序：
public void Sort(int[] array)
{
int i, j; // 循环变量
int temp; // 临时变量
for (i = 0; i < array.Length; i++)
{
for (j = 0; j < array.Length - 1 - i; j++)
{
if (array[j] > array[j + 1])
{
// 交换元素
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不
变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比较a[3]与a[4]，依此类推，最后比较a[n-1]与
a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是
a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序
排列了。
优点：稳定，比较次数已知；
缺点：慢，每次只能移动相邻两个数据，移动数据的次数多。
二、选择排序
private static void Shell_Sort(int[] b) {
int[] a = new int[b.Length];
b.CopyTo(a, 0);
int key;
Console.WriteLine("Shell排序");
int gap=5,k;
for(;gap>0;gap/=2)
for (int j = gap; j < 10; j++)
{
if (a[j] < a[j - gap])
{
key = a[j];
for (k = j - gap; k >= 0 ; k -= gap)
{
if (key < a[k])
{
a[k + gap] = a[k];
}
else
break;
}
a[k + gap] = key;
}
}
Print(a);
}已
知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不
变。再比较a[1]与a[3]的值，若a[1]大于a[3]则交换两者的值，否则不变。再比较a[1]与a[4]，依此类推，最后比较a[1]与a[n]
的值。这样处理一轮后，a[1]的值一定是这组数据中最小的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是
a[2]~a[n]中最小的。再将a[3]与a[4]~a[n]以相同方法比较一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升
序排列了。
优点：稳定，比较次数与冒泡排序一样，数据移动次数比冒泡排序少；
缺点：相对之下还是慢。
三、插入排序
/**
* 插入排序数组
* @author Edwin
* @version 1.1
*/
public class InsertionArray {
/**
* 插入排序数组
* @param lngArr为要排序的数组
*/
public void insertionSort(long[]lngArr)
{
int intOut=0,intIn=0,intElems=lngArr.length;
for(intOut=1; intOut <intElems; intOut++)
{
long temp = lngArr[intOut];
intIn = intOut;
while(intIn>0 && lngArr[intIn-1] >= temp)
{
lngArr[intIn] = lngArr[intIn-1];
--intIn;
}
lngArr[intIn] = temp;
} // end for
} // end insertionSort()
}已
知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。首先比较b[1]与
a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数
据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。b[2]~b[m]用相同方法插
入。（若无数组a，可将b[1]当作n=1的数组a）
优点：稳定，快；
缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。
四、缩小增量排序
由希尔在1959年提出，又称希尔排序。
已
知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。发现当n不大是，插入排序的效果很好。首先取一增量d(d
<n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、
a[2d]、a[3d]……列为最后一组依此类推，在各组内用插入排序，然后取d'
<d，重复上述操作，直到d=1。
优点：快，数据移动少；
缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。
五、快速排序
快速排序是冒泡排序的改进版，是目前已知的最快的排序方法。
已
知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先任取数据a[x]作为基准。比较a[x]与其它数据并排序，使a[x]排在数据
的第k位，并且使a[1]~a[k-1]中的每一个数据
<a[x]，a[k+1]~a[n]中的每一个数据>a[x]，然后采用分治的策略分别对a[1]~a[k-1]和a[k+1]~a[n]两
组数据进行快速排序。
优点：极快，数据移动少；
缺点：不稳定。

Answer 3

你说的那个方法是冒泡排序
其实我可以把你的问题理解为4个数字的数组排序问题，那样的话排序就有好多中方法
一、冒泡排序
冒泡排序：
public void Sort(int[] array)
{
int i, j; // 循环变量
int temp; // 临时变量
for (i = 0; i < array.Length; i++)
{
for (j = 0; j < array.Length - 1 - i; j++)
{
if (array[j] > array[j + 1])
{
// 交换元素
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不
变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比较a[3]与a[4]，依此类推，最后比较a[n-1]与
a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是
a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序
排列了。
优点：稳定，比较次数已知；
缺点：慢，每次只能移动相邻两个数据，移动数据的次数多。
二、选择排序
private static void Shell_Sort(int[] b) {
int[] a = new int[b.Length];
b.CopyTo(a, 0);
int key;
Console.WriteLine("Shell排序");
int gap=5,k;
for(;gap>0;gap/=2)
for (int j = gap; j < 10; j++)
{
if (a[j] < a[j - gap])
{
key = a[j];
for (k = j - gap; k >= 0 ; k -= gap)
{
if (key < a[k])
{
a[k + gap] = a[k];
}
else
break;
}
a[k + gap] = key;
}
}
Print(a);
}已
知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不
变。再比较a[1]与a[3]的值，若a[1]大于a[3]则交换两者的值，否则不变。再比较a[1]与a[4]，依此类推，最后比较a[1]与a[n]
的值。这样处理一轮后，a[1]的值一定是这组数据中最小的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是
a[2]~a[n]中最小的。再将a[3]与a[4]~a[n]以相同方法比较一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升
序排列了。
优点：稳定，比较次数与冒泡排序一样，数据移动次数比冒泡排序少；
缺点：相对之下还是慢。
三、插入排序
/**
* 插入排序数组
* @author Edwin
* @version 1.1
*/
public class InsertionArray {
/**
* 插入排序数组
* @param lngArr为要排序的数组
*/
public void insertionSort(long[]lngArr)
{
int intOut=0,intIn=0,intElems=lngArr.length;
for(intOut=1; intOut <intElems; intOut++)
{
long temp = lngArr[intOut];
intIn = intOut;
while(intIn>0 && lngArr[intIn-1] >= temp)
{
lngArr[intIn] = lngArr[intIn-1];
--intIn;
}
lngArr[intIn] = temp;
} // end for
} // end insertionSort()
}已
知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。首先比较b[1]与
a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数
据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。b[2]~b[m]用相同方法插
入。（若无数组a，可将b[1]当作n=1的数组a）
优点：稳定，快；
缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。
四、缩小增量排序
由希尔在1959年提出，又称希尔排序。
已
知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。发现当n不大是，插入排序的效果很好。首先取一增量d(d
<n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、
a[2d]、a[3d]……列为最后一组依此类推，在各组内用插入排序，然后取d'
<d，重复上述操作，直到d=1。
优点：快，数据移动少；
缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。
五、快速排序
快速排序是冒泡排序的改进版，是目前已知的最快的排序方法。
已
知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先任取数据a[x]作为基准。比较a[x]与其它数据并排序，使a[x]排在数据
的第k位，并且使a[1]~a[k-1]中的每一个数据
<a[x]，a[k+1]~a[n]中的每一个数据>a[x]，然后采用分治的策略分别对a[1]~a[k-1]和a[k+1]~a[n]两
组数据进行快速排序。
优点：极快，数据移动少；
缺点：不稳定。

Answer 4

用列表最方便。调用 .sort（）函数直接排序了

此外，你搜 冒泡排序

追问

我才开始学没多久，貌似我们老师说冒泡排序对于很大的数字就不起作用了？

追答

冒泡排序因为 需要反复两两比较，所以效率低。不过无所谓啊，你又不是要给成千上万个数排序

Answer 5

放到array里，然后array.sort,然后输出