算法必刷系列之数组

增加一个元素

判断是否可以添加，找到添加位置，移动元素，添加

public int addByElementSequence(int[] arr,int size,int element){
    if(size>=arr.length){
        return -1;
    }
    int index = size;
    for(int i=0;i<size;i++){
        if(element<arr[i]){
            index = i;
            break;
        }
    }
    for(int i=size;i>index;i--){
        arr[i] = arr[i-1];
    }
    arr[index] = element;
    return index;
}

删除一个元素

找到待删除元素位置，移动元素进行删除

public int removeByElement(int[] arr,int size,int key){
    int index = -1;
    for(int i=0;i<size;i++){
        if(key==arr[i]){
            index = i;
            break;
        }
    }
    if(index==-1){
        return -1;
    }
    for(int i=index;i<size;i++){
        arr[i] = arr[i+1];
    }
    return size-1;
}

判断数组是否单调

逆向判断，有递增趋势，则非递减序列，反之亦然

public boolean isSorted(int[] nums){
    bollean asc = true;
    boolean desc = true;
    for(int i=0;i<nums.length-2;i++){
        if(num[i]<nums[i+1]){
            desc = false;
        }
        if(num[i]>num[i+1]){
            asc = false;
        }
    }
    return asc || desc;
}

合并有序数组

巧妙利用数组剩余空间，进行从大到小的填充

public void merge(int[] nums1, int m, int[] nums2, int n) {
    int index = m+n-1;
    int i=m-1;
    int j=n-1;
    while(i>=0&&j>=0){
        if(nums1[i]>nums2[j]){
            nums1[index] = nums1[i];
            i--;
        }else{
            nums1[index] = nums2[j];
            j--;
        }
        index--;
    }
    while(i>=0){
        nums1[index] = nums1[i];
        index--;
        i--;
    }
    while(j>=0){
        nums1[index] = nums2[j];
        index--;
        j--;
    }
}

移除指定元素

双指针，fast遍历数组，slow保留非指定元素

public int removeElement(int[] nums, int val) {
    int slow = 0;
    int fast = 0;
    while(fast<nums.length){
        if(nums[fast]!=val){
            nums[slow++] = nums[fast++];
        }else{
            fast++;
        }
    }
    return slow;
}

移除重复元素

双指针，fast遍历数组，slow保留非重复元素

public int removeDuplicates(int[] nums) {
    int slow = 0;
    int fast = 1;
    while (fast < nums.length) {
        if(nums[fast] != nums[slow]){
            slow++;
            nums[slow] = nums[fast];
            fast++;
        }else{
            fast++;
        }
    }
    return slow+1;
}

按奇偶排序数组

对撞双指针，满足条件交换，否则继续遍历

public int[] sortArrayByParity(int[] nums) {
    int left = 0;
    int right = nums.length-1;
    while(left<right){
        if(nums[left]%2==1&&nums[right]%2==0){
            int temp = nums[left];
            nums[left] = nums[right];
            nums[right] = temp;
        }
        if(nums[left]%2==0){
            left++;
        }
        if(nums[right]%2==1){
            right--;
        }
    }
    return nums;
}

轮转数组

三次反转解决轮转问题

public void rotate(int[] nums, int k) {
    k %=nums.length;
    if(k==0){
        return;
    }
    reverse(nums,0,nums.length-1);
    reverse(nums,0,k-1);
    reverse(nums,k,nums.length-1);
}

public void reverse(int[] nums,int start,int end){
    while(start<end){
        int temp = nums[start];
        nums[start] = nums[end];
        nums[end] = temp;
        start++;
        end--;
    }
}

汇总区间

使用快慢双指针，进行区间首尾的判断

public List<String> summaryRanges(int[] nums) {
    List<String> res = new ArrayList<>();
    int slow = 0;
    for(int fast=0;fast<nums.length;fast++){
        if(fast+1==nums.length || nums[fast]+1!=nums[fast+1]){
            StringBuilder sb = new StringBuilder();
            sb.append(nums[slow]);
            if(slow!=fast){
                sb.append("->"+nums[fast]);
            }
            res.add(sb.toString());
            slow = fast+1;
        }
    }
    return res;
}

找出数组中出现超过一半的数字

使用两个变量巧妙计数

public int majorityElement(int[] nums) {
    Map<Integer,Integer> map = new HashMap<>();
    for(int i=0;i<nums.length;i++){
        if(map.containsKey(nums[i])){
            map.put(nums[i],map.get(nums[i])+1);
        }else{
            map.put(nums[i],1);
        }
    }
    int maxCount = Integer.MIN_VALUE;
    int maxNum = Integer.MIN_VALUE;
    for(int num:map.keySet()){
        if(map.get(num)>maxCount){
            maxCount = map.get(num);
            maxNum = num;
        }
    }
    return maxNum;
}

只出现一次的数字（其他数字出现两次）

异或运算消除两个相同数字，最终保留只出现一次的数字

public int singleNumber(int[] nums) {
    int res = 0;
    for(int num:nums){
        res^=num;
    }
    return res;
}

public int singleNumber(int[] nums) {
    Set<Integer> set = new HashSet<>();
    for(int num: nums){
        if(!set.add(num)){
           set.remove(num);
        }
    }
    Integer[] array = set.toArray(new Integer[set.size()]);
    return array[0];
}

只出现一次的数字（其他元素出现三次）

按位相加，对3取余，寻找只出现一次的数字

public int singleNumber(int[] nums) {
    int res = 0;
    for(int i=0;i<32;i++){
        int total = 0;
        for(int num:nums){
            total+=((num>>i)&1);
        }
        if(total%3!=0){
            res |= (1<<i);
        }
    }
    return res;
}

颜色分类问题