如何用c++比较四个数的大小，用函数方式实现

int max(int a,int b)

{

return a>ba:b;

}

int main()

{

int a,b,c,d;

cin>>a>>b>>c>>d;

cout<<max(max(max(a,b),c),d)<<endl;

return 0;

}

连用3次比较大小函数，也可以用宏定义

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

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

一、冒泡排序 

冒泡排序：

public void Sort(int[] array)

 {

            int i, j;  // 循环变量

            int temp;  // 临时变量

            for (i = 0; i < arrayLength; i++)

            {

                for (j = 0; j < arrayLength - 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[bLength];

            bCopyTo(a, 0);

            int key;

            ConsoleWriteLine("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 11 

/ 

public class InsertionArray { 

/ 

   插入排序数组 

   @param lngArr为要排序的数组 

  / 

    public void insertionSort(long[]lngArr) 

      { 

    int intOut=0,intIn=0,intElems=lngArrlength; 

      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]两

组数据进行快速排序。 

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

缺点：不稳定。

函数的输入分别为存入需比较的数字的数组指针以及数字个数，若找到不小于0的最小值则返回最小值，否则返回-1

int

FindMinNum(int

a,

int

totalNum)

{

int

minNum

=

0;

bool

isFirstNum

=

true;

for(int

t

=

0;

t

<

totalNum;

t

++)

{

if(a[t]

>=

0

&&

(isFirstNum

||

a[t]

<

minNum))

{

minNum

=

a[t];

isFirstNum

=

false;

}

}

if(isFirstNum)

{

return

-1;

}

else

{

return

minNum;

}

}

以上就是关于如何用c++比较四个数的大小，用函数方式实现全部的内容，包括:如何用c++比较四个数的大小，用函数方式实现、C#比较四个数字大小的思路、c++，求4个数字比较大小的代码。等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！