LeetCode_414_数组_第三大的数

原创：

int thirdMax(int* nums, int numsSize)
{
    int iThirdMaxNum = 0, iThirdMaxTampNum = 0; /* 最终第三大的数，临时第三大的数 */
    int iSameValCnt = 0; /* 相同数组值计数 */
    int iChangeValCnt = 0; /* 数组值的改变次数 */
    int i = 0;

    if(numsSize <= 2 && numsSize >= 1) /* 数组长度为 1 */
    {
        if(numsSize == 1)
        {
            iThirdMaxTampNum = nums[0]; /* 第三大数为 i = 0 时的值 */
        }
        else 
        {
            iThirdMaxTampNum = (int)fmax(nums[numsSize - 1], nums[numsSize - 2]); /* 比较第 numsSize 和第 numsSize-1 的数组值,返回最大值 */
        }
        iThirdMaxNum = iThirdMaxTampNum;
    }
    else 
    {
        for (int i = 0; i < numsSize - 1; i++) /* 冒泡排序完成 */
        {
            for (int j = i; j < numsSize - 1; j++)
            {
                if (nums[i] < nums[j + 1])    /* 降序 */
                {
                    iThirdMaxTampNum = nums[i];
                    nums[i] = nums[j + 1];
                    nums[j + 1] = iThirdMaxTampNum;
                }
            }
        }

        if(numsSize == 3) /* 如果数组的长度在 3 以内 */
        {
            if(nums[0] == nums[1] && nums[0] == nums[2] && nums[1] == nums[2]) /* 数组的值均相同 */
            {
                iThirdMaxNum = nums[0];
            }
            else if(nums[0] != nums[1] && nums[0] != nums[2] && nums[1] != nums[2]) /* 数组的值均不相同 */
            {
                iThirdMaxNum = nums[2];
            }
            else /* 221 或者 322 样式的，无论怎么样都是第 0 的数组值最大 */
            {
                iThirdMaxNum = nums[0];
            }
        }
        else /* 如果数组的长度在 >3  */
        {
            for(int i = 1; i < numsSize; i++ ) /* 先将变化了多少次的值求出来 */
            {
                if(nums[i] != nums[i - 1]) /* 后面数组值与前面数组值不相等 */
                {
                    iSameValCnt ++;
                }
            }

            if(iSameValCnt == 0) /* 数组的值全部不相同 */
            {
                iThirdMaxNum = nums[2]; /* 全部不相同，那么选第一个数组值就可以 */
            }
            else if(iSameValCnt == 1) /* 数组值变化一次 */
            {
                iThirdMaxNum = nums[0]; /* 说明就两种值，那么选第一个数组值就可以 */
            }
            else if(iSameValCnt >= 2)  /* 如果数组值的变化大于2 */
            {
                while(iChangeValCnt != 2) /* 只需要找到第三大的数组值就可以 */
                {
                    i ++;
                    if(nums[i] != nums[i - 1])
                    {
                        iChangeValCnt ++;
                    }
                }

                iThirdMaxNum = nums[i];
            }
        }
    }

    return iThirdMaxNum;
}

借鉴：

int cmp(const void *a, const void *b){			//按降序排序
    return (*(int*)b > *(int*)a);
}

int thirdMax(int* nums, int numsSize){
  	int count = 1, i;							//count用来记录第几大的数

	qsort(nums, numsSize, sizeof(nums[0]), cmp);//排序 
    for(i = 1; i < numsSize; ++i){				//遍历数组
		if(nums[i] != nums[i-1]){				//遍历元素与前一个不重复
            ++count;
            if(count == 3)						//第三大的数
            	return nums[i];
        }
    }

	return nums[0];								//无第三大的数，返回最大的数
}

修改：

/* 自创解决方法2 */
int thirdMax(int* nums, int numsSize)
{
    int iThirdMaxTampNum = 0; /* 临时第三大的数 */
    int iChangeValCnt = 1; /* 数组值的改变次数 */

    for (int i = 0; i < numsSize - 1; i++) /* 冒泡排序完成 */
    {
        for (int j = i; j < numsSize - 1; j++)
        {
            if (nums[i] < nums[j + 1])    /* 降序 */
            {
                iThirdMaxTampNum = nums[i];
                nums[i] = nums[j + 1];
                nums[j + 1] = iThirdMaxTampNum;
            }
        }
    }

    for(int i = 1; i < numsSize; i++)
    {
        if(nums[i] != nums[i - 1])
        {
            iChangeValCnt++;

            if(iChangeValCnt == 3) /* 只要找到第三大的数就返回 */
            {
                return nums[i];
            }
        }        
    }  

    return nums[0]; /* 其他的情况返回数组的第一个值 */
}

总结：

有时候在你要放弃的时候，挣扎一下，其实你就成功了！