数组和矩阵处理算法

1、求最大子数组和：

package com.arithmetic.arraymatrix;
//使用动态规划的思想，通过维护两个变量，curSum表示当前子数组的和，maxSum表示到目前位置的最大子数组和。
//遍历数组元素时，更新当前子数组和和最大子数组和。
//最终返回最大子数组和。
public class MaximumSubarraySumDemo {
    public static int maxSubarraySum(int[] nums) {
        // 初始化最大子数组和为第一个元素
        int maxSum = nums[0];
        // 初始化当前子数组和为第一个元素
        int curSum = nums[0];

        // 从第二个元素开始遍历数组
        for (int i = 1; i < nums.length; i++) {
            // 判断当前元素自成一组还是与前面的子数组相连
            curSum = Math.max(nums[i], curSum + nums[i]);
            // 更新最大子数组和
            maxSum = Math.max(maxSum, curSum);
        }

        return maxSum;
    }

    public static void main(String[] args) {
        int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
        int maxSum = maxSubarraySum(nums);
        System.out.println("最大子数组和为: " + maxSum);
    }
}

2、快速幂算法：

package com.arithmetic.arraymatrix;
//快速幂算法

//定义一个函数来计算幂。

//在函数中，检查指数是否为0。

//如果指数为0，返回1作为幂的结果。

//如果指数为负数，将底数取倒数，并将指数取相反数，以确保结果仍然是正数。

//声明一个变量result，并初始化为1，用于保存幂的结果。

//使用循环对指数进行二进制拆分，每次将底数自乘，指数右移一位。

//如果当前最低位的指数为1，将底数乘以当前的结果。

//继续循环直到指数变为0。

//返回result作为幂的最终结果。
public class FastPowerAlgorithmDemo {

	public static double power(double base, int exponent) {
		if (exponent == 0) {
			return 1;
		}
//首先判断指数是正数还是负数，并根据需要将底数取倒数、指数取相反数，确保结果为正数。
		boolean isNegative = false;
		if (exponent < 0) {
			base = 1 / base;
			exponent = -exponent;
			isNegative = true;
		}
//使用循环对指数进行二进制拆分，每次将底数自乘，指数右移一位。
//如果当前最低位的指数为1，则将底数乘以当前的结果。
		double result = 1;
		while (exponent != 0) {
			if ((exponent & 1) == 1) {
				result *= base;
			}
			base *= base;
			exponent >>= 1;
		}
//最后，返回最终的幂结果。
		return isNegative ? 1 / result : result;
	}

//该实现假设底数和指数都是合法的数字，且不考虑溢出的情况。在实际应用中，可能需要根据具体情况进行适当的错误处理和边界检查。
	public static void main(String[] args) {
		double base = 2.0;
		int exponent = 10;
		double powerResult = power(base, exponent);
		System.out.println(base + " 的 " + exponent + " 次幂为：" + powerResult);
	}
}