数组（三）

啵啵薯条

已于 2024-08-05 20:08:55 修改

阅读量357

点赞数 10

分类专栏：算法与数据结构文章标签： java 数据结构算法

于 2024-07-31 21:12:37 首次发布

本文链接：https://blog.youkuaiyun.com/w13114/article/details/140784069

版权

算法与数据结构专栏收录该内容

8 篇文章

订阅专栏

数组二分查找

二分查找概念

二分查找算法（Binary Search Algorithm）：也叫做折半查找算法、对数查找算法，是一种用于在有序数组中查找特定元素的高效搜索算法。

二分查找步骤：

1.初始化两个指针，left 和 right，分别指向数组的开始位置和结束位置。
2.当 left <= right 时，执行以下步骤：
计算中间位置 mid，通常使用 (left + right) / 2 或更安全的 left + (right - left) / 2 来避免整数溢出。

检查中间位置的元素是否等于目标值。
如果等于，返回 mid 作为目标值的索引。
如果中间位置的元素小于目标值，更新 left = mid + 1。
如果中间位置的元素大于目标值，更新 right = mid - 1。

3.如果没有找到目标值，返回 -1 或其他表示未找到的值。

Java代码示例：
public class BinarySearch {
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2; // 防止溢出

            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }

        return -1; // 目标值不在数组中
    }

    public static void main(String[] args) {
        int[] sortedArray = {1, 3, 5, 7, 9, 11, 13, 15};
        int target = 9;

        int index = binarySearch(sortedArray, target);
        if (index != -1) {
            System.out.println("Element found at index: " + index);
        } else {
            System.out.println("Element not found in the array.");
        }
    }
}

数组双指针

双指针概念：

双指针技术是一种常用的算法技巧，特别适用于处理有序数组或链表的问题，它能够有效地减少时间复杂度，将某些问题的解决时间从O(n^2)降低至O(n)。在数组中，双指针通常是指两个索引，它们可以指向数组的不同位置，并根据特定的策略移动。

双指针类型：

1.快慢指针：一个指针移动得比另一个快，通常用于检测循环链表或寻找链表的中间节点。
2.对撞指针：两个指针从数组的两端向中间移动，直到它们相遇或满足某个终止条件。这种类型的双指针特别适用于查找两个数的组合，比如求和等于特定值的问题。

代码示例：

示例：寻找两个数之和等于特定值
假设我们有一个有序数组nums和一个目标值target，我们的任务是找到数组中两个数，使它们的和等于target。
public class TwoSum {
    public static int[] twoSum(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;

        while (left < right) {
            int sum = nums[left] + nums[right];
            if (sum == target) {
                return new int[]{left, right}; // 返回两个数的索引
            } else if (sum < target) {
                left++; // 移动左指针，尝试更大的数
            } else {
                right--; // 移动右指针，尝试更小的数
            }
        }
        return null; // 如果找不到这样的两个数，返回null
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        int target = 7;
        int[] result = twoSum(nums, target);
        if (result != null) {
            System.out.println("Indices of numbers that add up to " + target + ": " + result[0] + ", " + result[1]);
        } else {
            System.out.println("No such pair exists.");
        }
    }
}

数组滑动窗口

滑动窗口概念：

滑动窗口技术是一种在数组或序列上操作的高效算法，主要用于处理涉及连续子数组的问题，如求解最大或最小子数组的和、平均值、最长合法子串等问题。滑动窗口算法通过动态调整窗口的大小，可以在线性时间内解决问题，避免了使用嵌套循环带来的高时间复杂度。

滑动窗口基本思想：

初始化窗口：设定窗口的左右边界，初始时窗口可能为空或包含数组的第一个元素。
扩大窗口：如果当前窗口内的元素不满足条件（如和不够大），则向右移动右边界，扩大窗口。
缩小窗口：如果窗口内的元素满足条件（如和足够大），则尝试向右移动左边界，缩小窗口，以寻找更优解或更新最优解。
重复步骤2和3：直到右边界超出数组范围

Java代码示例：
public class MinSubArrayLen {
    public static int minSubArrayLen(int s, int[] nums) {
        int n = nums.length;
        int minLength = Integer.MAX_VALUE;
        int left = 0;
        int currentSum = 0;

        for (int right = 0; right < n; right++) {
            currentSum += nums[right]; // 扩大窗口

            // 缩小窗口，直到窗口内的和小于s
            while (currentSum >= s) {
                minLength = Math.min(minLength, right - left + 1);
                currentSum -= nums[left];
                left++;
            }
        }

        return minLength == Integer.MAX_VALUE ? 0 : minLength;
    }

    public static void main(String[] args) {
        int[] nums = {2, 3, 1, 2, 4, 3};
        int s = 7;
        int result = minSubArrayLen(s, nums);
        System.out.println("Minimum length of subarray with sum >= " + s + ": " + result);
    }
}