C# 有人能解释一下这个代码是如何工作的吗

我们目前正在做数组中的C。我必须从输入中获取第二大数。但是我不知道这个代码的功能。有人能给我解释一下吗对于整个代码请查看

解释代码：

 static int ztgzahl(int[] ZL)
        {
            int MinZ = Int16.MinValue;
            int MaxZ = Int16.MinValue;
            for(int i = 0; i < ZL.Length; i++)
            {
                if (ZL[i] > MaxZ)
                {
                    MinZ = MaxZ;
                    MaxZ = ZL[i];
                }
                else if (ZL[i] > MinZ)
                {
                    MinZ = ZL[i];
                }
            }
            return MinZ;
        }

static int ztgzahl（int[]ZL）
{
int MinZ=Int16.MinValue；
int MaxZ=Int16.MinValue；
对于（int i=0；iMaxZ）
{
MinZ=MaxZ；
MaxZ=ZL[i]；
}
else if（ZL[i]>MinZ）
{
MinZ=ZL[i]；
}
}
返回明兹；
}

此代码遍历数组，试图找到两个最高的数字。然而，它使用了完全混乱的变量名MinZ和MaxZ。它应该是MaxA和MaxB或者类似的东西

对于每个数字，它检查数字是否大于当前最大值（最高值）。如果是的话，它会把前一个第二大的交给MinZ。如果没有，它会另外检查它是否只是smaler然后MinZ（因为一个数字可以比MaxZ大，而且smaler然后MinZ）

我不是100%确定这是否有效。就我个人而言，我只需要对数组进行排序，然后从右边得到第二个数组。或者，如果这是一个数据库，则使用查询从底部获取第二个。众所周知，这种逻辑容易出错

Int16.MinValue

这将获得Int16允许的最小值

---

然后它迭代ZL数组，如果它找到的值高于找到的最高值，它将替换变量值，如果没有，它将检查它的位置是否可以作为第二高值。

请根据下面的代码段查找我的注释

static int ztgzahl(int[] ZL)
        {
            int MinZ = Int16.MinValue; // Min value of Int16 is -32768
            int MaxZ = Int16.MinValue; 
            for(int i = 0; i < ZL.Length; i++) //Iterating over each index of array
            {
                if (ZL[i] > MaxZ)    //If current element is greater than MaxZ
                {
                    MinZ = MaxZ;    //MinZ remainsthe same
                    MaxZ = ZL[i];   //MaxZ is the current element
                }
                else if (ZL[i] > MinZ) //If current element is greater than MinZ
                {
                    MinZ = ZL[i];      //MinZ is current element
                }
            }
            return MinZ;
        }

static int ztgzahl（int[]ZL）
{
int MinZ=Int16.MinValue；//Int16的最小值为-32768
int MaxZ=Int16.MinValue；
for（int i=0；iMaxZ）//如果当前元素大于MaxZ
{
MinZ=MaxZ；//MinZ保持不变
MaxZ=ZL[i]；//MaxZ是当前元素
}
else if（ZL[i]>MinZ）//如果当前元素大于MinZ
{
MinZ=ZL[i]；//MinZ是当前元素
}
}
返回明兹；
}

基于全snipet，阵列中将不会有任何负元素。考虑一个由4个元素组成的短数组{3,1,5,7}

第一次迭代：

 static int ztgzahl(int[] ZL)
        {
            int MinZ = Int16.MinValue;
            int MaxZ = Int16.MinValue;
            for(int i = 0; i < ZL.Length; i++)
            {
                if (ZL[i] > MaxZ)
                {
                    MinZ = MaxZ;
                    MaxZ = ZL[i];
                }
                else if (ZL[i] > MinZ)
                {
                    MinZ = ZL[i];
                }
            }
            return MinZ;
        }

MinZ和MaxZ=-1

MinZ=-1

MaxZ=3

第二次互动：

 static int ztgzahl(int[] ZL)
        {
            int MinZ = Int16.MinValue;
            int MaxZ = Int16.MinValue;
            for(int i = 0; i < ZL.Length; i++)
            {
                if (ZL[i] > MaxZ)
                {
                    MinZ = MaxZ;
                    MaxZ = ZL[i];
                }
                else if (ZL[i] > MinZ)
                {
                    MinZ = ZL[i];
                }
            }
            return MinZ;
        }

MinZ=1

第三次迭代：

 static int ztgzahl(int[] ZL)
        {
            int MinZ = Int16.MinValue;
            int MaxZ = Int16.MinValue;
            for(int i = 0; i < ZL.Length; i++)
            {
                if (ZL[i] > MaxZ)
                {
                    MinZ = MaxZ;
                    MaxZ = ZL[i];
                }
                else if (ZL[i] > MinZ)
                {
                    MinZ = ZL[i];
                }
            }
            return MinZ;
        }

MinZ=3

MaxZ=5

第四次迭代：

 static int ztgzahl(int[] ZL)
        {
            int MinZ = Int16.MinValue;
            int MaxZ = Int16.MinValue;
            for(int i = 0; i < ZL.Length; i++)
            {
                if (ZL[i] > MaxZ)
                {
                    MinZ = MaxZ;
                    MaxZ = ZL[i];
                }
                else if (ZL[i] > MinZ)
                {
                    MinZ = ZL[i];
                }
            }
            return MinZ;
        }

MinZ=5

MaxZ=7

---

因此，第二大元素是5，由MinZ返回，谢谢您的解释，是的，变量不好！但这是出于学校的目的：）我认为逻辑无法按预期工作的唯一方式是，如果传入一个数组，其中包含的项少于2项。否则，你所说的“这种逻辑是出了名的容易出错”是什么意思@RufusL我不能100%肯定它会起作用。使用嵌套的If，很容易漏掉一个案例。但我无法指出任何具体问题。如果数组中的项少于两个，则可能需要引发异常。如果

ZL

有少于

2个
项，它将返回
Int16.MinValue
，这在技术上是不正确的（或者另一个选项是明确说明该行为）。还要注意
int
（是
Int32
的别名）的范围比
Int16
大得多，因此，您可能应该改用
int.MinValue
，因为所有值都可能小于
Int16.MinValue