编程之美2.10：寻找数组中的最大值和最小值

编程之美2.10： 对于一个有N个整数组成的数组，需要比较多少次才能把最大值和最小值找出来呢?

算法的思想是: 分而治之

测试数据：----------------------------------------------------

int [] input1 = { 94, 40, 49, 65, 21, 21, 106, 80, 92, 81, 679, 4, 61, 6, 237, 12, 72, 74, 29, 95, 265, 35, 47, 1, 61, 397, 52, 72, 37, 51, 1, 81, 45, 435, 7, 36, 57, 86, 81, 72 };

最大数据：679

最小数据：1

第二大数：435

--------------------------------------------------------------

方法一：递归

  // 方法一： 递归法 (分而治之）
        public static void FindMaxAndMinValues(int[] array, int startIndex, int endIndex, out int max, out int min)
        {          
            int tempMaxL, tempMaxR, tempMinL, tempMinR;
            tempMaxL = tempMaxR = tempMinL = tempMinR = 0;

            if (endIndex - startIndex > 1)
            {
                FindMaxAndMinValues(array, startIndex, startIndex + (endIndex - startIndex) / 2, out tempMaxL, out tempMinL);
                FindMaxAndMinValues(array, startIndex + (endIndex - startIndex) / 2 + 1, endIndex, out tempMaxR, out tempMinR);
            }
            else
            {
                if (array[startIndex] > array[endIndex])
                {
                    max = array[startIndex];
                    min = array[endIndex];
                }
                else
                {
                    max = array[endIndex];
                    min = array[startIndex];
                }

                return;
            }

            max = tempMaxL > tempMaxR ? tempMaxL : tempMaxR;
            min = tempMinL < tempMinR ? tempMinL : tempMinR;
        }

方法二：非递归方式 

  // 方法二：  非递归的实现分而治之。
        public static void FindMaxAndMinValues2(int[] array, out int max, out int min)
        {
            int startIndex = 0;

            if (array.Length % 2 == 0) // 偶数
            {
                max = array[0] > array[1] ? array[0] : array[1];
                min = array[0] < array[1] ? array[0] : array[1];
                startIndex = 2;
            }
            else // 奇数
            {
                max = min = array[0];
                startIndex = 1;
            }

            for (int i = startIndex; i < array.Length; i += 2)
            {
                int tempMaxValue = Math.Max(array[i], array[i + 1]);
                int tempMinValue = Math.Min(array[i], array[i + 1]);

                if (tempMaxValue > max)
                {
                    max = tempMaxValue;
                }

                if (tempMinValue < min)
                {
                    min = tempMinValue;
                }
            }
        }

可以将递归的分而治之算法划分成以下的步骤：

1) 从图1 4 - 2中的二叉树由根至叶的过程中把一个大问题划分成许多个小问题，小问题的大小为1或2。

2) 比较每个大小为2的问题中的金块，确定哪一个较重和哪一个较轻。在节点D、E、F和G上完成这种比较。大小为1的问题中只有一个金块，它既是最轻的金块也是最重的金块。

3) 对较轻的金块进行比较以确定哪一个金块最轻，对较重的金块进行比较以确定哪一个金块最重。对于节点A到C执行这种比较。根据上述步骤，可以得出程序1 4 - 1的非递归代码。该程序用于寻找到数组w [ 0 : n - 1 ]中的最小数和最大数，若n < 1，则程序返回f a l s e，否则返回t r u e。当n≥1时，程序1 4 - 1给M i n和M a x置初值以使w [ M i n ]是最小的重量，w [ M a x ]为最大的重量。首先处理n≤1的情况。若n>1且为奇数，第一个重量w [ 0 ]将成为最小值和最大值的候选值，因此将有偶数个重量值w [ 1 : n - 1 ]参与f o r循环。当n 是偶数时，首先将两个重量值放在for 循环外进行比较，较小和较大的重量值分别置为Min和Max，因此也有偶数个重量值w[2:n-1]参与for循环。在for 循环中，外层if 通过比较确定( w [ i ] , w [ i + 1 ] )中的较大和较小者。此工作与前面提到的分而治之算法步骤中的2) 相对应，而内层的i f负责找出较小重量值和较大重量值中的最小值和最大值，这个工作对应于3 )。

for 循环将每一对重量值中较小值和较大值分别与当前的最小值w [ M i n ]和最大值w [ M a x ]进行比较，根据比较结果来修改M i n和M a x（如果必要）。

下面进行复杂性分析。注意到当n为偶数时，在for 循环外部将执行一次比较而在f o r循环内部执行3 ( n / 2 - 1 )次比较，比较的总次数为3 n / 2 - 2。当n 为奇数时，f o r循环外部没有执行比较，而内部执行了3(n-1)/2次比较。因此无论n 为奇数或偶数，当n>0时，比较的总次数为「3n/2ù-2次

引申：

1. 如果需要找出N个数组中的第二大数，需要比较多少次呢？是否可以使用类似的分而治之思想来降低比较的次数呢？

 

// 寻找第二大的数.(分而治之）
        public static void FindSecondMaxValue(int[] array, out int max, out int secondMax)
        {
            max = secondMax = 0;

            int startIndex = 0;

            if (array.Length % 2 == 0) // 偶数
            {
                max = array[0] > array[1] ? array[0] : array[1];
                secondMax = array[0] < array[1] ? array[0] : array[1];
                startIndex = 2;
            }
            else // 奇数
            {
                max = secondMax = array[0];
                startIndex = 1;
            }

            for (int i = startIndex; i < array.Length; i += 2)
            {
                int tempMaxValue = Math.Max(array[i], array[i + 1]);               

                if (tempMaxValue > max)
                {
                    secondMax = max;
                    max = tempMaxValue;
                }
                else
                {
                    if (tempMaxValue > secondMax)
                    {
                        secondMax = tempMaxValue;
                    }
                }
            }
        }