算法--数组

最新推荐文章于 2024-04-02 16:14:25 发布

温一杯酒

最新推荐文章于 2024-04-02 16:14:25 发布

阅读量196

点赞数

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

本文链接：https://blog.csdn.net/qq_30281559/article/details/99851503

版权

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

20 篇文章 0 订阅

订阅专栏

二分查找

Leetcode35：查找插入位置（`二分查找` `easy`）

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。你可以假设数组中无重复元素。（二分查找注意边界条件）

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while(left <= right) {        //如果left<right，则下面right=mid；
            int mid = (left + right) / 2;
            if(nums[mid] == target) {
                return mid;
            } else if(nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;//如果这里写成right=mid，会导致无限循环
            }
        }
        return left;
    }
}

《剑指offer》面试题11：旋转数组的最小数字（`二分查找`）

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int len = array.length;
        if(len == 0){
            return 0;
        }
        int low = 0, high = len-1;
        while(low < high){
            int mid = low + ( high - low )/2;
            if(array[mid]>array[high]){
                low = mid+1;
            }else if(array[mid] == array[high]){//{2 3 0 1 1 1 1 1}
                high = high-1;
            }else{
                high = mid;//这里如果写成high=mid-1，那么如果low=high的时候没有比较而退出循环
            }            
        }
        return array[low];
    }
}

Leetcode33：旋转数组中查找数字（`二分查找` `medium`）

假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。你可以假设数组中不存在重复的元素。你的算法时间复杂度必须是 O(log n) 级别。
法：

首先，如果nums[mid] == target，那么找到目标元素，返回mid
如果nums[l] < nums[r]，说明l~r范围的元素有序，那么执行正常的二分查找
否则，根据 mid位置 的值判断mid是在左半部分还是右半部分
如果nums[mid] ≥ nums[l]，说明mid在左半部分
当target > nums[r] && target < nums[mid]，那么target只可能出现在mid的左边，因此在mid左边继续查找
否则，target只可能出现在mid的右边，因此在mid右边继续查找
否则，mid在右半部分
当target > nums[mid] && target < nums[l]，那么target只可能出现在mid的右边，因此在mid右边继续查找
否则，target只可能出现在mid的左边，因此在mid左边继续查找

public class Solution {
public int search(int[] A, int target) {
    if(A.length == 0) return -1;
    int lo = 0;
    int hi = A.length - 1;
    while (lo < hi) {
        int mid = (lo + hi) / 2;
        if (A[mid] == target) return mid;
        
        if (A[lo] <= A[mid]) {
            if (target >= A[lo] && target < A[mid]) {
                hi = mid - 1;
            } else {
                lo = mid + 1;
            }
        } else {
            if (target > A[mid] && target <= A[hi]) {
                lo = mid + 1;
            } else {
                hi = mid - 1;
            }
        }
    }
    return (A[lo] == target ? lo : -1);
}
}

Leetcode81：旋转数组中查找数字II（`二分查找` `medium`）

统计一个数字在排序数组中出现的次数
解答：
1.使用二分查找，分别找到数字的下边界和上边界

public int[] find(int[] nums,int target){
        int[] res = {-1,-1};
        if(nums.length == 0) return res;
        int l = findL(nums,target);
        int r = findR( nums,target);
        res[0] = l;
        res[1] = r;
        return r-l+1;
    }
    public int findL(int[] nums, int tar){
        int l = 0,r = nums.length-1;
        while(l<=r){
           int mid = (l+r)/2;
           if(nums[mid] == tar){
               if(mid == 0 || nums[mid-1] != nums[mid] ) return mid;
               else r = mid-1;
           }
           if(nums[mid] < tar){
               l = mid + 1;
           }else{
               r = mid -1;
           }
        }
        return  -1;
    }
    public int findR(int[] nums, int tar){
        int l = 0,r = nums.length-1;
        while(l<=r){
            int mid = (l+r)/2;
            if(nums[mid] == tar){
                if(mid == r || nums[mid+1] != nums[mid] ) return mid;
                else l = mid+1;
            }
            if(nums[mid] < tar){
                l = mid + 1;
            }else{
                r = mid -1;
            }
        }
        return  -1;
    }

《剑指offer》面试题53(题目一)：有序数组中查找数字的范围（`二分查找`）

《剑指offer》面试题53(题目二)：缺失的数字（`二分查找`）《剑指offer》面试题53(题目三)：数组中数值和下标相等的元素（`二分查找`）

Leetcode162：查找数组中任一峰值的下标（`二分查找` `medium`）

给定一个输入数组 nums，其中 nums[i] ≠ nums[i+1]，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。你可以假设 nums[-1] = nums[n] = -∞。

1）线性查找：遍历数组，对于每个元素，如果该元素的前一元素和后一元素都小于该元素，那么该元素是一个峰值，返回
2）二分查找
如果中间元素比右边的元素小，意味着当前处于一个“升序”中，那么右边(不含当前元素)将会出现一个峰值
如果中间元素比右边的元素大，意味着当前处于一个“降序”中，那么左边(包含当前元素)将会出现一个峰值
如果中间元素等于右边的元素，那么无法减小区间（所以题目给出了nums[i]不等于nums[i+1]）

public int findPeakElement(int[] nums) {
    int N = nums.length;
    if (N == 1) {
        return 0;
    }
   
    int left = 0, right = N - 1;
    while (right > left ) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < nums[mid + 1]) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    
    return (left == N - 1 || nums[left] > nums[left + 1]) ? left : right;
}

Leetcode4：两个排序数组的中值（`二分查找` `hard`）

其它查找

Leetcode41：缺失的第一个正数（`交换` `hard`）

Leetcode287：寻找数组中重复的数（`二分查找` `链表` `medium`）

Leetcode268：0~n中缺失的数字（`位运算` `easy`）

Leetcode136：只出现1次的数字（`位运算` `easy`）

《剑指offer》面试题56(题目一)：数组中只出现1次的2个数（`位运算`）

《剑指offer》面试题56(题目二)：数组中唯一只出现1次的数字（`位运算`）

《剑指offer》面试题41：数据流的中位数（`堆`）

《剑指offer》面试题57(题目一)：和为s的两个数字（`双指针`）

《剑指offer》面试题57(题目二)：和为s的连续正数序列（`双指针`）

Leetcode217：判断数组是否包含重复元素（`哈希表` `easy`）

Leetcode1：两数之和（`哈希表` `easy`）

Leetcode15：三数之和（`排序` `双指针` `medium`）

Leetcode18：四数之和（`排序` `双指针` `medium`）

Leetcode454：四数之和II（`哈希表` `medium`）

《剑指offer》面试题39：数组中出现次数超过一半的数字（`partition`）

《剑指offer》面试题40：数组中最小的k个数（`partition` `海量数据`）

Leetcode347：出现频率最高的k个数字（`medium`）

Leetcode350：两个数组的交集II（`easy`）

数组操作

Leetcode26：删除排序数组中的重复项（`双指针` `easy`）

Leetcode27：删除数组中值为val的元素（`双指针` `easy`）

Leetcode189：旋转数组（`easy`）

Leetcode283：将数组中的零移到尾部（`easy`）

子数组与连续子数组

《剑指offer》面试题42：连续子数组的最大和（`动态规划`）

Leetcode152：连续子数组的最大积（`动态规划` `medium`）

Leetcode128：最长连续序列（`哈希表` `hard`）

Leetcode300：最长升序子序列（`动态规划` `medium`）

Leetcode334：数组的三元升序子序列（`medium`）

排列组合

《剑指offer》面试题38(相关题一)：正方体顶点上放数字（`全排列`）

《剑指offer》面试题38(相关题二)：八皇后（`全排列`）

Leetcode52：N皇后II（`全排列` `hard`）

Leetcode51：N皇后（`全排列` `hard`）

Leetcode31：下一个排列（`排列` `medium`）

Leetcode60：第K个排列（`排列` `medium`）

Leetcode46：不含重复元素数组的全排列（`全排列` `medium`）

Leetcode47：含重复元素数组的全排列（`全排列` `medium`）

Leetcode77：1~n中所有k个数的组合（`组合` `medium`）

Leetcode78：不含重复元素集合的所有子集（`组合` `medium`）

Leetcode90：含重复元素集合的所有子集（`组合` `medium`）

Leetcode39：和为target的数字组合（`组合` `medium`）

Leetcode40：和为target的数字组合II（`组合` `medium`）

排序

《剑指offer》面试题21：调整数组顺序使奇数位于偶数前面（`partition`)

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
法1：使用插入排序的思想
法2：基于快排的partition方法，先统计奇偶个数，然后遍历
使用插入排序编码更简洁，如果要实现O(n)时间复杂度，必须使用一个辅助数组（空间换时间）

public void reOrderArray(int [] array) {
        
        for(int i = 0;i<array.length;i++){
            for(int j = i;j>0;j--){
                if(array[j-1]%2 == 0 && array[j]%2 == 1){
                    int temp = 0;
                    temp = array[j-1];
                    array[j-1] = array[j];
                    array[j] = temp;
                }
            }
        }
    }

/*
整体思路：
首先统计奇数的个数
然后新建一个等长数组，设置两个指针，奇数指针从0开始，偶数指针从奇数个数的末尾开始 遍历，填数
*/
public class Solution {
    public void reOrderArray(int [] array) {
        if(array.length==0||array.length==1) return;
        int oddCount=0,oddBegin=0;
        int[] newArray=new int[array.length];
        for(int i=0;i<array.length;i++){
            if((array[i]&1)==1) oddCount++;
        }
        for(int i=0;i<array.length;i++){
            if((array[i]&1)==1) newArray[oddBegin++]=array[i];
            else newArray[oddCount++]=array[i];
        }
        for(int i=0;i<array.length;i++){
            array[i]=newArray[i];
        }
    }
}

《剑指offer》面试题61：扑克牌中的顺子

Leetcode75：颜色分类（`medium`）

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
法1：两趟扫描算法（归并）。 首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。
法2：使用3个指针：l，m，r。l左边的元素都为0，将其初始化为0，r右边的元素都为2，将其初始化为nums.size() - 1;
首先往右移动l、往左移动r，使这2个指针到达正确的位置。然后初始化m为l，使用m从左往右遍历 [l~r] 中间的元素，因此nums[m]可能有3个值：
* 如果nums[m] == 1，那么不需要交换，直接右移m
* 如果nums[m] == 0，因为l位置的值为1，因此交换m和l位置的值，然后右移l和m
* 如果nums[m] == 2，m位置的值可能为0也可能为1，因此交换m和r位置的值，然后左移r。但是需不需要右移m？不需要。因为如果交换后m位置的值为1，那么下次遍历会递增m；如果交换后m位置的值为0，那么还要与l位置的值进行交换。因此m保持不动

void sortColors(int[] nums) {
        int l = 0,r = nums.size() - 1;
        while(l < nums.size() && nums[l] == 0)  l++;
        while(r >= 0 && nums[r] == 2)   r--;
        int m = l;
        while(m <= r){
            if(nums[m] == 0)  swap(nums[m++],nums[l++]);
            else if(nums[m] == 1) m++;
            else if(nums[m] == 2) swap(nums[m],nums[r--]);
        }
    }

Leetcode179：将一组数拼接成最小数字（`medium`）

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
法：给出数字m和n，需要确定一个规则判断m和n哪个应该排在前面，如果mn<nm，那么m应该排在n前面，此时定义m<n，将每个数字都排序再组合成字符串

public class Solution {
     public static String PrintMinNumber(int [] numbers) {
        int len = numbers.length;
        if(len == 0) return "";
        if(len ==1) return String.valueOf(numbers[0]);
        StringBuffer res = new StringBuffer();
        String[] str = new String[len];
        for(int i=0;i<len;i++){
            str[i] = String.valueOf(numbers[i]);
        }
        Arrays.sort(str,new Comparator<String>(){
            public int compare(String str1,String str2){
                String a = str1+str2;
                String b = str2+str1;
                return a.compareTo(b);
            }
        });
        for(int i=0;i<len;i++){
            res.append(str[i]);
        }
        return res.toString();
    }
}