算法小白学习(1)简单

买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

提示：

• 1 <= prices.length <= 105
• 0 <= prices[i] <= 104

public class Solution {
    public int MaxProfit(int[] prices) {
        int minPrice = int.MaxValue; // 初始设置为最大可能值
            int maxProfit = 0; // 初始利润为0

            foreach (int price in prices)
            {
                // 更新最小买入价格
                minPrice = Math.Min(minPrice, price);

                // 计算当前卖出可能的利润
                int potentialProfit = price - minPrice;

                // 更新最大利润
                maxProfit = Math.Max(maxProfit, potentialProfit);
            }

            return maxProfit;
            
    }
}

多数元素 

 

解释：

1. 我们使用两个变量来跟踪最小买入价格和最大利润。
2. 遍历给定的股票价格数组，对于每一天的价格：
   • 更新最小买入价格，确保始终选择更低的价格。
   • 计算当前卖出可能的利润，即当前价格减去最小买入价格。
   • 更新最大利润，确保始终选择更大的利润。
3. 最终返回最大利润。

 

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：

输入：nums = [3,2,3]
输出：3

示例 2：

输入：nums = [2,2,1,1,1,2,2]
输出：2

提示：

• n == nums.length
• 1 <= n <= 5 * 104
• -109 <= nums[i] <= 109

进阶：尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。

static int MajorityElement(int[] nums)
        {
            Dictionary<int, int> countMap = new Dictionary<int, int>();

            foreach (int num in nums)
            {
                if (countMap.ContainsKey(num))
                    countMap[num]++;
                else
                    countMap[num] = 1;

                if (countMap[num] > nums.Length / 2)
                    return num;
            }

            return -1; // 这里表示未找到多数元素，实际问题中可能需要根据题目要求做不同处理
        }

这个算法使用一个字典来记录每个元素的出现次数，并在循环中检查是否有元素的出现次数超过数组长度的一半。如果找到这样的元素，就返回它。否则，返回 -1 表示未找到多数元素。

移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

提示：

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 50
• 0 <= val <= 100

 public int RemoveElement(int[] nums, int val)
        {
            int newIndex = 0; // 新数组的索引

            for (int i = 0; i < nums.Length; i++)
            {
                if (nums[i] != val)
                {
                    nums[newIndex] = nums[i]; // 将不等于 val 的元素移到新数组的位置
                    newIndex++;
                }
            }

            return newIndex; // 返回新数组的长度
        }

 

1. 我们使用一个 newIndex 变量来跟踪新数组的索引，该变量从0开始，将用于原地修改数组。
2. 我们遍历原数组 nums 中的每个元素，如果当前元素不等于给定值 val，则将该元素移到新数组的位置，并递增 newIndex。
3. 遍历完成后，newIndex 就表示新数组的长度，而 nums 数组中前 newIndex 个元素就是原地移除给定值后的结果。