**给你一个整型数组，我想找出来最大的两个数，能帮我写一个算法吗？
**
在上一遍我们已经解读过这道题目了，包括我们能想到的问题。这里我们按照解决算法题的一般步骤再来一起分析一下这道题：
一、确保我们理解了问题，并且尝试一个例子，确认理解无误。
那现在我们澄清一下问题，我们需要从这样的数组中{ 4， 5，2，3，1}中找出最大的两个数字返回{4，5}，当数组为空的时候我们也返回空的数组。
二、想想你可以用什么方法解决问题，你会选择哪一种，为什么？
我们不想先对他进行排序，原因有两个，数组是引用类型，排序会改变原来的数据结果，我相信你调用别人SDK的时候，肯定也不想自己的数据莫名其妙的被改变了对吧，即使我们能保证不改变原来的次序，我们也会引入额外的存储空间，另外，题目当中没有要求将所有的数字排序返回，排序似乎有些浪费。而且，一般的排序最好能做到n log(n), 而这道题其实只需要o(n)就能解决。
三、 解释你的算法和实现的方法
解释我们的算法，我们申明两个临时变量， max， secondmax，然后开始扫描数组。若数组中当前的数字比max还大，我们就替换到max，当然替换之前，先将max赋值到secondmax里去，若数组中当前的数字比max小，我们再比较是否比secondmax大，倘若大，我们将直接将其赋值到secondmax上去，其他情况我们就不用处理啦。
四、写代码的时候，记住，一定要解释你现在在干什么
public static int[] FindMaxTwo(int[] array)
{
// 如果输入的数组是空，或者数组的长度只有一个，我们也就没有必要处理了，直接返回
if (array == null || array.Length == 1) return array;
// 定义两个临时变量，想一想我们为什么要赋值为int.minvalue
int max = int.MinValue;
int secondMax = int.MinValue;
// 开始扫描数组
for (int index = 0; index < array.Length; index++)
{
// 如果当前的数字比max还大，我们将改变secondmax的值，然后该表max
if (array[index] >= max)
{
secondMax = max;
max = array[index];
}
// 如果当前数字没有比max大，但是比secondmax大，我们直接改变secondmax的值
else if (array[index] >= secondMax)
{
secondMax = array[index];
}
}
// 好了，我们将得到的这两个值放到数组里，准备返回吧
int[] result = new int[2];
result[0] = secondMax;
result[1] = max;
return result;
}
五、拿一个实例，Work Through你的代码（省略了哈)
六、修复缺陷，保证异常情况都被考虑到。我们需要列出来这里的一些特殊情况，如数组中如果存在相同的数字而且都是最大的数，我们返回什么呢？如{5，3，4，1，5}，返回{4，5}还是{5，5}呢，不一样的要求会对处理的细节有所差别。如果数组中全是负数我们的代码还能返回期待的结果吗？
尝试一下： 大家可以把intmax= int.MinValue; int secondMax = int.MinValue;改成intmax;int secondmax;再试试 {-5，-2，-4，-3，-1}试试看，这里会出现一个bug。其根本原因在于，int 的默认值是0。
再尝试一下：我们先定义了两个临时变量，之后又申明了一个数组，是不是有点浪费。不简洁有没有？好的，我们给它优化一下：
public static int[] FindMaxTwoImproved2(int[] array)
{
if (array == null || array.Length == 1) return array;
// Here is a bug when the max value is negative since the initial value in the int array is 0
int[] result = new int[2];
// This is to fix the bug above
for (var index = 0; index < result.Length; index++)
{
result[index] = int.MinValue;
}
Console.WriteLine(result[1]);
for (int index = 0; index < array.Length; index++)
{
if (array[index] >= result[0])
{
result[0] = result[1];
result[1] = array[index];
}
else if (array[index] >= result[1])
{
result[0] = array[index];
}
}
return result;
}
回到上一篇的问题中来，我们曾今问过K是否会变，能不能做到以不变应万变，动态一些，你让我们返回几个我们就返回几个呢？当然可以，这次我们申明一个长度为K的数组，直接来看代码：
// Let's extend the array to get K fliexable
public static int[] FindMaxTwoImproved3(int[] array, int k)
{
if (k < 0) throw new ArgumentException("The K should not be negative.");
if(array != null && array.Length < k) throw new ArgumentException("The K should less than the length of target array.");
if (array == null || array.Length == 1) return array;
// Here is a bug when the max value is negative since the initial value in the int array is 0
int[] result = new int[k];
// This is to fix the bug above
for (var index = 0; index < result.Length; index++)
{
result[index] = int.MinValue;
}
for (int index = 0; index < array.Length; index++)
{
if (array[index] >= result[k - 1])
{
<span style="background-color:rgb(51,204,0);">for (int fallback = 0; fallback < k - 1; fallback++)</span>
<span style="background-color:rgb(51,204,0);"> {</span>
<span style="background-color:rgb(51,204,0);"> result[fallback] = result[fallback + 1];</span>
<span style="background-color:rgb(51,204,0);"> }</span>
<span style="background-color:rgb(51,204,0);"></span>
result[k - 1] = array[index];
}
else
{
for (int fallback = k - 1; fallback >= 0; fallback--)
{
if (array[index] >= result[fallback])
{
<span style="background-color:rgb(51,204,0);">for (int fallback2 = 0; fallback2 < fallback; fallback2++)</span>
<span style="background-color:rgb(51,204,0);"> {</span>
<span style="background-color:rgb(51,204,0);"> result[fallback2] = result[fallback2 + 1];</span>
<span style="background-color:rgb(51,204,0);"> }</span>
result[fallback] = array[index];
}
}
}
}
return result;
} 在这段代码中，大家有没有发现有代码重复的嫌疑？我把他们高亮起来了。我们再定义一个公共方法，
/// <summary>
/// 改方法会负责将当前数组array从前往后的K-1个数字依次赋值成后面的数组，
/// 而最后一个值我们将替换成target
/// </summary>
/// <param name="array"></param>
/// <param name="target"></param>
/// <param name="k"></param>
public static void Fallback(int[] array, int target, int k)
{
if (k > 0)
{
for (int fallback2 = 0; fallback2 < k - 1; fallback2++)
{
array[fallback2] = array[fallback2 + 1];
}
array[k - 1] = target;
}
}
将高亮部分也替换一下，看最后的代码：
// Let's remove the duplication code
public static int[] FindMaxTwoImproved4(int[] array, int k)
{
if (k < 0) throw new ArgumentException("The K should not be negative.");
if (array == null || array.Length == 1) return array;
// Here is a bug when the max value is negative since the initial value in the int array is 0
int[] result = new int[k];
// This is to fix the bug above
for (var index = 0; index < result.Length; index++)
{
result[index] = int.MinValue;
}
for (int index = 0; index < array.Length; index++)
{
if (array[index] >= result[k - 1])
{
Fallback(result, array[index], k);
result[k - 1] = array[index];
}
else
{
for (int fallback = k - 1; fallback >= 0; fallback--)
{
if (array[index] >= result[fallback])
{
Fallback(result, array[index], fallback);
result[fallback] = array[index];
}
}
}
}
return result;
}
大家发现了吗？这是不是我们见过的一种排序算法。没错，当K = N 时，这就是开辟了新存储空间的插入排序了。有没有？
接下来我们就可以定义各种不同的输入去测试我们的算法啦，这里是一个例子。供大家参考：
static void Main(string[] args)
{
int[] array = new int[5] { -5, -3, -4, -5, 10 };
var result = FindMaxTwo(array);
PrintArray(result);
result = FindMaxTwoImproved4(array, 2);
PrintArray(result);
}
public static void PrintArray(int[] array)
{
if (array == null)
{ Console.WriteLine("The array is null or empty"); }
else
{
foreach (var i in array)
{
Console.Write(i + " ");
}
Console.WriteLine();
}
} 欢迎大家关注我的公众号，还有我的系列视频教程, 数据结构与算法 和 经典算法面试题辅导, 排序专题讲解，链表专题讲解。
大家有什么更好的解法，也欢迎讨论哈。
