力扣网-探索初级算法-数组篇

86 阅读 0 评论 57 点赞

我是靠谱客的博主苹果小蘑菇，最近开发中收集的这篇文章主要介绍力扣网-探索初级算法-数组篇，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

本篇博客题目来自力扣网，分组为初级算法下的数组。适合作为数组方面的练习。上面刷题测试用例真的丰富，总是有很多考虑不到的地方。第一遍做完了，很多解法都不是最优解。主要是分享下。

探索初级算法—力扣网链接

数组
题目的话打开上面的链接就可以看到，这里就不复述了。

从排序数组中删除重复项

    public int removeDuplicates(int[] nums) {
       int index=0;
       int size=nums.length;

       while (index<size){
           for (int i = index+1; i < size; i++) {
               if(nums[i]==nums[index]){
                   for (int j = 0; j < size-1; j++) {
                       if(j<i){
                           nums[j]=nums[j];
                       }else {
                           nums[j]=nums[j+1];
                       }
                   }
                   size--;
               }
           }
           index++;
           if(index>=size){
               continue;
           }else if(nums[index]==nums[index-1]){
               index--;
           }
       }

        return size;
    }

买卖股票的最佳时机 II

 public int maxProfit(int[] prices) {
       int money=0;
        for (int i = 0; i < prices.length-1; i++) {
            if(prices[i]<prices[i+1]){
                money+=prices[i+1]-prices[i];
            }
        }
       return money;
        
    }

旋转数组

public void rotate(int[] nums, int k) {
        int[] copyNums=new int[nums.length];
        for (int i = 0; i < copyNums.length; i++) {
            copyNums[i]=nums[i];
        }
        k=k%nums.length;
        for (int i = 0; i < nums.length; i++) {
            int x=0;
            if(i<k){
                x=nums.length-k+i;
                nums[i]=copyNums[x];
            }else {
                x=i-k;
                nums[i]=copyNums[x];
            }
        }
    }

存在重复

 public boolean containsDuplicate(int[] nums) {
          Set<Integer> list=new HashSet<>();
        for (int i = 0; i <nums.length ; i++) {
            list.add(nums[i]);
        }
       return list.size()!=nums.length;
    }

只出现一次的数字

 public int singleNumber(int[] nums) {
          for (int i = 0; i <nums.length ; i++) {
            int x=1;
            for (int j = 0; j < nums.length; j++) {
               if(i!=j&&nums[i]==nums[j]){
                   x=2;
               }
            }
            if(x==1){
                return nums[i];
            }
        }
         return 0;
    }

两个数组的交集 II

  public int[] intersect(int[] nums1, int[] nums2) {
                ArrayList<Integer> list=new ArrayList<>();
        ArrayList<Integer> num1indexList=new ArrayList<>();
        ArrayList<Integer> indexList=new ArrayList<>();

        for (int i = 0; i <nums1.length ; i++) {

            for (int j = 0; j < nums2.length; j++) {
                if(nums1[i]==nums2[j]){
                    if (indexList.size()>0){
                        int num=0;
                        for (int k = 0; k < indexList.size(); k++) {
                            if(indexList.get(k)==j){
                                num=1;
//                                System.out.println("相同j："+ i+ " "+j);
                            }
                        }
                        for (int k = 0; k <num1indexList.size() ; k++) {
                            if(num1indexList.get(k)==i){
                                num=1;
//                                System.out.println("相同i："+ i+ " "+j);
                            }
                        }
                        if(num==0){
                            num1indexList.add(i);
                            indexList.add(j);
                            list.add(nums2[j]);
                        }
                    }else {
                        num1indexList.add(i);
                        indexList.add(j);
                        list.add(nums2[j]);
                    }

                }



            }
        }

        int[] x=new int[list.size()];
        for (int i = 0; i < x.length; i++) {
            x[i]=list.get(i);
        }
        return x;
    }

加一

public int[] plusOne(int[] digits) {
         int[] newNums=new int[digits.length+1];
        for (int i = digits.length-1; i >=0; i--) {

            if(digits[i]==9){
                digits[i]=0;
                if(i==0){
                    newNums[0]=1;
                    for (int j = 1; j <newNums.length ; j++) {
                        newNums[j]=digits[j-1];
                    }

                    return newNums;
                }
            }else {
                digits[i]=digits[i]+1;
                break;
            }
        }

         return digits;
    }

移动零

 public void moveZeroes(int[] nums) {
          int sum=0;
        for (int i = 0; i < nums.length; i++) {
            if(nums[i]==0){
                sum++;
            }else if(sum>0&&nums[i]!=0){
                //交换位置
                nums[i-sum]=nums[i];
                nums[i]=0;
            }
        }  
    }

两数之和

 public int[] twoSum(int[] nums, int target) {
        int[] result=new int[2];
        for(int i=0;i<nums.length;i++){
                for(int j=0;j<nums.length;j++){
                    if(nums[i]+nums[j]==target&&i!=j){
                        result[0]=i;
                        result[1]=j;
                        return result;
                    }
                }
        }
        return result;
    }

有效的数独

public boolean isValidSudoku(char[][] board) {
          //方案2 一次遍历
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[i].length; j++) {

                //一，横排判断
                if(board[i][j]!='.'){
                    for (int k = j+1; k < board[i].length; k++) {
                        if(board[i][j]==board[i][k]){ return false; }
                    }
                }
                //二，竖排判断
                if(board[j][i]!='.'){
                    for (int k = j+1; k <9 ; k++) {
                        if(board[j][i]==board[k][i]){ return false; }
                    }
                }

                //九方框判断
                if(board[i][j]!='.'){
                    int x=getStartIndex(i);
                    int y=getStartIndex(j);
                    for (int k = x; k < x+3; k++) {
                        for (int l = y; l <y+3 ; l++) {
                            if(i!=k&&y!=l&&board[k][l]==board[i][j]){ return false; }
                        }
                    }
                }
            }
        }

        return true;
    }
    
 public static int getStartIndex(int x){
        if(x<3){
            return 0;
        }else if(3<=x&&x<6){
            return 3;
        }else {
            return 6;
        }
    }

旋转图像
这个解释下，将二维数组看做一个个口型的图案，一个包裹一个，4条边分别当做4个数组，旋转其实就是在这个4个数组中轮换。

public void rotate(int[][] matrix) {
        int a1=0;
        int a2=0;
        int a3=0;
        int len=matrix.length-1;
          int num=matrix.length/2;
        for (int n = 0; n < num; n++) {
            for (int i = 0; i < len-2*n; i++) {
            //第一个
            a1=matrix[i+n][len-n];  
            matrix[i+n][len-n]=matrix[n][n+i];
            //第二个
            a2=matrix[len-n][len-i-n];  
            matrix[len-n][len-i-n]=a1;
            //第三个
            a3=matrix[len-i-n][n];  
            matrix[len-i-n][n]=a2;
            //第四个
            matrix[n][i+n]=a3;
            }
        }
    }