玩转算法 第一天 数组问题

最新推荐文章于 2024-01-16 09:39:49 发布
最新推荐文章于 2024-01-16 09:39:49 发布
阅读量514 收藏
点赞数
分类专栏： # Leetcode 文章标签： 数据结构 leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38847154/article/details/108385889
版权

第一天 数组问题

283、移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

   public void moveZeroes(int[] nums) {
         
         int n=nums.length;
         int j=-1;

         for(int i=0;i<n;i++){
           if(nums[i]!=0){
            j++;
            int temp=nums[i];
            nums[i]=nums[j]; 
            nums[j]=temp;
           }
         }
         
    }

  public void moveZeroes(int[] nums) { 
        int n=nums.length;
        int arr[]=new int[n];
        int j=0;

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

            if(nums[i]!=0){
                arr[j++]=nums[i];
            }
        }

        for(int i=0;i<n;i++){
            nums[i]=arr[i];
        }  
    }

189. 旋转数组

在这里插入图片描述

class Solution {
    public void rotate(int[] nums, int k) {

          int previous;  
 
       for(int i=0;i<k;i++){
         previous=nums[nums.length-1];
         for(int j=0;j<nums.length;j++){
            int temp=nums[j];
            nums[j]=previous;
            previous=temp;
         }
       }

    }
}

27. 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:
给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。

示例 2:
给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。


   public int removeElement(int[] nums, int val) {
        int j=-1;
        int n=nums.length;
          

        for(int i=0;i<n;i++){ 

          if(nums[i]!=val){ 
               j++;
               int temp=nums[i];
               nums[i]=nums[j];
               nums[j]=temp;
          }
        } 
           return j+1; 
    }

26. 删除排序数组中的重复项

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。

    public int removeDuplicates(int[] nums) {

           int n=nums.length;
          if(n<2) return n;

           int j=0; 

         for(int i=1;i<n;i++){
                if(nums[i]!=nums[j])
                nums[++j]=nums[i];
         }
          return j+1;

    }

80. 删除排序数组中的重复项 II

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:给定 nums = [1,1,1,2,2,3],
函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。
你不需要考虑数组中超出新长度后面的元素。

示例 2:给定 nums = [0,0,1,1,1,1,2,3,3],
函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。
你不需要考虑数组中超出新长度后面的元素。

75. 颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:
不能使用代码库中的排序函数来解决这道题。

示例:

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

//方法1 基数排序

class Solution {
    public void sortColors(int[] nums) { 
      int[] count=new int[3]; 
      for(int i=0;i<nums.length;i++){
          count[nums[i]]++;
      } 
 
      int index=0;
      for(int i=0;i<count[0];i++){
          nums[index++]=0;
      }
      for(int i=0;i<count[1];i++){
          nums[index++]=1;
      }
      for(int i=0;i<count[2];i++){
          nums[index++]=2;
      } 
        
    }
}
 

//方法2 快排(荷兰国旗)
   public void sortColors(int[] nums) {
    int i=0;
    int low=0;
    int high=nums.length-1;

     while(i<=high){
        if(nums[i]==1){
            ++i;
        }else if(nums[i]==0){
         int temp=nums[i];
         nums[i]=nums[low];
         nums[low]=temp;
         //等于v部分不用再加
         ++low;
         ++i;
        }else if(nums[i]==2&&i<=high){
            int temp=nums[i];
            nums[i]=nums[high];
            nums[high]=temp;
            --high;
        } 
     } 
    }

88. 合并两个有序数组

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。

说明: 初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

示例:
输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
输出: [1,2,2,3,5,6]

    public void merge(int[] nums1, int m, int[] nums2, int n) {
             int len1 = m - 1;
        int len2 = n - 1;
        int len = m + n - 1;
        while(len1 >= 0 && len2 >= 0) {
            // 注意--符号在后面，表示先进行计算再减1，这种缩写缩短了代码
 nums1[len--] = nums1[len1] > nums2[len2] ? nums1[len1--] : nums2[len2--];
        }
        // 表示将nums2数组从下标0位置开始，拷贝到nums1数组中，从下标0位置开始，长度为len2+1
         while (len2 >= 0) {
            nums1[len--] = nums2[len2--];
        }

    }

215. 数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

class Solution {
    public int findKthLargest(int[] nums, int k) {
           quick_select(nums,k,0,nums.length-1);
        return nums[k-1];
    }
    private void quick_select(int []nums,int k,int start,int end){
            if(start>=end) return ;
         int pivot=nums[start];
         int l=start+1,r=end;
        while(l<=r){
            if(nums[l]>pivot){
                l++;
                continue;
            }
            if(nums[r]<=pivot){
                r--;
                continue;
            }
            swap(nums,l,r);
        }
        swap(nums,start,r);
        
        if(r-start+1==k)return ;
        if(r-start+1>k) quick_select(nums,k,start,r-1);
        else quick_select(nums,k-(l-start),l,end);
          
    }
    private void swap(int[]nums,int i ,int j){
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
}

167. 两数之和 II - 输入有序数组

给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。
函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。

说明:
返回的下标值（index1 和 index2）不是从零开始的。
你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。

示例:
输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2

   /**
     *
     * 思路1 哈希表      时间复杂度O(N)        空间复杂度O(N)
     *
     *
     * @param numbers
     * @param target
     * @return
     */

    public static int[] twoSum(int[] numbers, int target) {

        int n=numbers.length;
        HashMap<Integer,Integer> map=new HashMap<>();

        for(int i=0;i<n;i++){

            if(map.containsKey(target-numbers[i])){
                  return new int[]{map.get(target-numbers[i])+1,i+1};
            }else
                map.put(numbers[i],i);
        }

          return new int[]{};
    }


    /**
     *
     *
     * 思路2 指针碰撞    时间复杂度O(N)      空间复杂度O(1)
     *
     *
     */

    public static int[] twoSum2(int[] numbers, int target) {

        int n=numbers.length;

        int l=0;
        int r=n-1;
        while(l<r){
            if(numbers[l]+numbers[r]==target){
                return new int[]{l+1,r+1};
            }else if(numbers[l]+numbers[r]<target){
                l++;
            }else{
                r--;
            }
        }
        return new int[]{};
    }


    /**
     *
     * 思路3 暴力法
     *
     *
     */

    public static int[] twoSum3(int[] numbers, int target) {

        int n=numbers.length;

        for (int i = 0; i <n ; i++) {
            for (int j = i+1; j <n ; j++) {
                if(numbers[i]+numbers[j]==target){
                    return new int[]{i+1,j+1};
                }
            }

        }
        return new int[]{};
    }

125. 验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。
示例 1:
输入: “A man, a plan, a canal: Panama”
输出: true

 
    /**
     *
     * 方法1 筛选 + 判断
     * @param s
     * @return
     */


        public boolean isPalindrome(String s) {
            StringBuffer sgood = new StringBuffer();
            int length = s.length();
            for (int i = 0; i < length; i++) {
                char ch = s.charAt(i);
                if (Character.isLetterOrDigit(ch)) {
                    sgood.append(Character.toLowerCase(ch));
                }
            }
            StringBuffer sgood_rev = new StringBuffer(sgood).reverse();
            return sgood.toString().equals(sgood_rev.toString());
        }


    /**
     *
     * 思路2 双指针 O(N)
     *
     *
      */


    public boolean isPalindrome2(String s) {
        StringBuffer sgood = new StringBuffer();
        int length = s.length();
        for (int i = 0; i < length; i++) {
            char ch = s.charAt(i);
            if (Character.isLetterOrDigit(ch)) {
                sgood.append(Character.toLowerCase(ch));
            }
        }

        int n = sgood.length();
        int left = 0, right = n - 1;
        while (left < right) {
            if (Character.toLowerCase(sgood.charAt(left)) != Character.toLowerCase(sgood.charAt(right))) {
                return false;
            }
            ++left;
            --right;
        }
        return true;
    }


    /**
     *
     * 思路3  空间复杂度O(1)
     *
     *
     */
    public boolean isPalindrome3(String s) {
        int n = s.length();
        int left = 0, right = n - 1;
        //从左右两边选出第一个字符
        while (left < right) {
            while (left < right && !Character.isLetterOrDigit(s.charAt(left))) {
                ++left;
            }
            while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
                --right;
            }
            //比较左右两个字符
            if (left < right) {
                if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) {
                    return false;
                }
                ++left;
                --right;
            }
        }
        return true;
    }

344. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

 public static void reverseString(char[] s) {

        int n=s.length;
        int l=0;
        int r=n-1;

        while(l<r){
            Character temp=s[l];
            s[l]=s[r];
            s[r]=temp;
            l++;
            r--;
        }

        System.out.println(s);

    }

345. 反转字符串中的元音字母


编写一个函数，以字符串作为输入，反转该字符串中的元音字母。

 

示例 1：

输入："hello"
输出："holle"

示例 2：

输入："leetcode"
输出："leotcede"

11. 盛最多水的容器

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器，且 n 的值至少为 2。

/**
 * 思路1 暴力法
 *
 */


public int maxArea(int[] height) {

    int res=0;
    for (int i = 0; i <height.length ; i++) {
        for (int j = 0; j <height.length ; j++) {
            res=Math.max(res,(j-i)*Math.min(height[i],height[j]));
        }
    }
    return res;
}

 

    /**
     *思路2
     * 双指针 时间复杂度O(N)
     *
     *
     * @param height
     * @return
     */
    public int maxArea2(int[] height) {
        int i = 0, j = height.length - 1, res = 0;
        while(i < j){
            res = height[i] < height[j] ?
                    Math.max(res, (j - i) * height[i++]):
                    Math.max(res, (j - i) * height[j--]);
        }
        return res;
    }

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：
输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

暴力 O(N*N)

    public int minSubArrayLen(int s, int[] nums) {
        int res=nums.length+1;
        for(int i=0;i<nums.length;i++){
             int sum=0;
              for(int j=i;j<nums.length;j++){
                 sum+=nums[j];
                 if(sum>=s){
                  res=Math.min(res,j-i+1);
                  break;
                 } 
              }

        }
        return res=res==nums.length+1?0:res;
    }

滑动窗口O(N)

   public int minSubArrayLen(int s, int[] nums) {

  //    if(nums.length==0||nums==null) return 0;  
      int l=0;
      int r=-1;
      int n=nums.length;
      //sum子序列之和
      int sum=0;
      //res子序列长度
      int res=nums.length+1;



      while( l<n){
        if(r+1<n&&sum<s){
            sum+=nums[++r];
        }
        else{
            sum-=nums[l++];
        }
        if(sum>=s){
        res=Math.min(res,r-l+1);
        }
        
      }

      return res==nums.length+1?0:res;  
    }

3. 无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:
输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

public class lengthOfLongestSubstring {
    /**
     *
     * 思路1 滑动窗口
     *
     *
     */

    public int lengthOfLongestSubstring(String s) {
        int l=0;
        int r=-1;
        int res=0;
        int n=s.length();
        //这里freq存放元素，也可以用其他结构
        // HashSet<Character> subset = new HashSet<>();
        int freq[]=new int[256];//这里freq[k]存放的是acsll为k字符存放的频率


        while(l<n){

            if(r+1<n&&freq[s.charAt(r+1)]==0) {
                freq[s.charAt(++r)]++;
            }

            //当右边元素已经包含于窗口,窗口收缩至重复元素下一个元素
            else{
                freq[s.charAt(l++)]--;
            }

            res=Math.max(res,r-l+1);

        }
        return res==0?0:res;
    }


    /**
     *
     * 思路2 hashset
     *
     *
     */
    public int lengthOfLongestSubstring2(String s) {
        Set<Character> oc=new HashSet<>() ;
        int n=s.length();
        int rk=-1;
        int res=0;

        for(int i=0;i<n;i++){
            //左指针向右移动一格，移除一个字符
            if(i!=0){
                oc.remove(s.charAt(i-1));
            }

            //右指针下一个字符不会溢出并且下一个字符没遇到过
            while(rk+1<n&&!oc.contains(s.charAt(rk+1))){
                oc.add(s.charAt(rk+1));
                rk++;                // 加入右边元素，右移指针
            }

            res=Math.max(res,rk-i+1);
        }
        return res;
        // return res==0?0:res;
    }


/**
 * 思路3  hashmap
 *
 */

public int lengthOfLongestSubstring3(String s) {
    int n = s.length();
    int res = 0;
    int end=0,start=0;
    Map<Character,Integer> map=new HashMap<>();
    for(;start<n && end<n;end++){
        if(map.containsKey(s.charAt(end))){
            start=Math.max(map.get(s.charAt(end)),start);//从有重复的下一个位置继续找
        }
        map.put(s.charAt(end),end+1);//map每次更新
        res=Math.max(res,end-start+1);//结果每次更新
    }
    return res;
}

}

438. 找到字符串中所有字母异位词

给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。
字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。

说明：
字母异位词指字母相同，但排列不同的字符串。
不考虑答案输出的顺序。
示例 1:
输入:
s: “cbaebabacd” p: “abc”
输出:
[0, 6]
解释:
起始索引等于 0 的子串是 “cba”, 它是 “abc” 的字母异位词。
起始索引等于 6 的子串是 “bac”, 它是 “abc” 的字母异位词。

5. 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：
输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：
输入: “cbbd”
输出: “bb”

76. 最小覆盖子串

给你一个字符串 S、一个字符串 T 。请你设计一种算法，可以在 O(n) 的时间复杂度内，从字符串 S 里面找出：包含 T 所有字符的最小子串。

示例：
输入：S = “ADOBECODEBANC”, T = “ABC”
输出：“BANC”

追忆似水_年华
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组相关算法题汇总
qq_43103261的博客
01-05 1477
在属于数组考点系列的题目中，划分为四个常考问题：子数组问题、矩阵问题、O(n)类型问题和思维转换类型问题。 子数组问题：就是给定一个数组，围绕该数组的子数组列出诸多难题，等待我们来解答。 矩阵问题：给定一个矩阵（或者称为二维数组），围绕该矩阵列出不同方式遍历矩阵中元素等难题，等待我们来解答。 O(n)类型问题：O(n)是指时间复杂度为O(n)，给定的题目题意一般很容易理解，其一般解法（俗称暴力解法，时间复杂度一般为O(n^2)，甚至更高）也很简单，但是题目要求你的解法时间复杂度为O(n)。看到这些题目
算法题-数组算法题
diecheng0411的博客
07-16 299
题一：二分查找法-Java：用于有序数组 //实验数据 int[] arr = {3,21,34,46,55,71,74,80,97}; 代码： public int findIndex(int value, int[] arr) { // arr是有序数组 // value是目标值 int min = 0;...
算法题之数组
weixin_42137276的博客
07-30 868
文章目录小总结1、旋转矩阵（中）题目分析解法1解法2扩展复杂度2、三数之和题目分析复杂度3、下一个排列题目分析复杂度4、搜索旋转排序数组&在排序数组中查找元素的第一个和最后一个位置题目分析①目标明确②另一种思路：排除法③避免死循环总结5、盛最多水的容器和数对和题目分析复杂度6、删除排序数组中的重复项题目分析复杂度7、只出现一次的数字I&II & 数组中数字出现的次数题目分析复杂度复杂度复杂度8、合并区间题目分析复杂度9、移动零题目分析复杂度10、旋转数组的最小数字题目分析复杂度11、
数组相关的算法题
rover
08-02 354
// https://www.cnblogs.com/grandyang/category/625406.html 快速排序 void quickSort(int a[], int left, int right) { if(left < right) { int i = left, j = right; int x = a[left]; while(i < j) { while(i < j && a[j] >=
算法之数组常见题目
ChenYiRan123456的博客
01-01 466
数组是存储在连续内存空间上的相同类型数据的集合。在数组中可以方便地通过下标索引的方式获取对应的数据。leedcode26：删除有序数组中的重复项leedcode724：寻找数组的中心下标leedcode59. 螺旋矩阵 II
java算法题 : 数组相关问题
03-14
例如，nums[0]表示数组的第一个元素。 2. 修改元素：直接通过索引赋值即可修改数组中的元素，如nums[2] = 10;。 3. 遍历数组：通常使用for循环来遍历数组，例如： ``` for(int i = 0; i ; i++) { System.out....
实现Python3数组旋转的3种算法实例
09-17
这个方法通过将数组分成两部分来实现旋转，第一部分包含数组的最后`k`个元素，第二部分包含其余元素。然后，将这两部分重新组合起来。关键在于计算`k`对数组长度取模，以确保旋转的正确性。代码如下： ```python ...
Go语言算法之寻找数组第二大元素的方法
09-22
在Go语言中，寻找数组第二大元素的算法是一个常见的编程问题，尤其在数据处理和分析的场景下。这个算法的目标是在不完全排序整个数组的情况下，找到数组中的第二大的数值。这通常可以通过一次遍历来实现，效率较高，...
Golang算法问题之数组按指定规则排序的方法分析
09-21
### Golang算法问题之数组按指定规则排序的方法分析 #### 背景介绍 在处理数据结构时，经常需要对数组或列表中的元素按照特定的规则进行排序。本篇文章将探讨如何在Go语言中实现这样的功能，即对于一个多维数组...
PHP CRC8算法-集成十六进制转byte数组与byte数组转十六进制
05-19
由C代码翻译过来的PHP CRC8算法，内有十六进制转字节数组与字节数组转十六进制，内有十六进制转byte数组与byte数组转十六进制
【算法题】数组中只出现一次的数字
12-20
题目描述 一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。 分析 要解这题需要对异或操作有比较深的理解。 依次将数组中所有元素进行异或得到a，即num1和num2的异或。然后取a中二进制为1的一个位置，找到原数组中所有该位为1的数字进行异或，得到了num1，接下来再将num1与a异或，得到num2。 代码 //num1,num2分别为长度为1的数组。传出参数 //将num1[0],num2[0]设置为返回结果 public class Solution { public void FindNumsAppearOnce(int [] array
算法题-数组题集合
qq_40092110的博客
08-02 261
数组 结题思路 题目输入输出几变量包装 01:与指定数字相同的数的个数 描述 输出一个整数序列中与指定数字相同的数的个数。 输入 输入包含三行： 第一行为N，表示整数序列的长度(N <= 100)； 第二行为N个整数，整数之间以一个空格分开； 第三行包含一个整数，为指定的整数m。 输出 输出为N个数中与m相同的数的个数。 样例输入 3 2 3 2 2 样例输出 2 特殊值的思考方法 待思考的问题 算法步骤 思路1： 输入相关变量，遍历数组，用一个计数器表示与m相同的数的个数。 源代码 #incl
LeetCode数组算法题（Java版）
Vae的黑粉
11-19 1470
文章目录一、删除有序数组中的重复项（26题）1.1双指针解法二、买股票的最佳时机（122题）1.动态规划2.贪心算法 一、删除有序数组中的重复项（26题） 原题如下： 给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。 不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 示例 1： 输入：nums = [1,1,2] 输出：2, nums = [1,2] 解释：函数应该返回新的长度 2 ，并且原
数组面试算法题（yet）
silyvin
05-06 1226
51题 题目：在一个长度为n的数组里的全部数字都在0到n-1的范围内。 数组中某些数字是反复的，但不知道有几个数字反复了。也不知道每一个数字反复的次数。请找出数组中随意一个反复的数字。 比如假设输入长度为7的数组{2,3,1,0,2,5,3},那么相应的输出是反复的数字2或者3. 1.解决问题的一个简单的方法是先把输入的数组排序。从排序的数组中找出反复的
数组的经典算法题练习
ILOVEMYDEAR的博客
04-18 506
数组的经典算法题练习 提示： 例如：第一章 数组的经典算法题练习 文章目录数组的经典算法题练习数组在数据结构和算法中的应用是非常广范的一、组队竞赛总结 数组在数据结构和算法中的应用是非常广范的 接下来，我们需要来看一看一些数组和栈的经典笔试题 提示：以下是本篇文章正文内容，下面案例可供参考 一、组队竞赛 1.链接：https://www.nowcoder.com/questionTerminal/248ccf8b479c49a98790db17251e39bb 来源：牛客网 牛牛举办了
基础算法题-数组相关
manu_zhang的博客
05-21 369
1. 数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。 如果直接排序，后进行选择，则时间复杂度最优为O(nlogn)，这里有两种思路。 第一种，利用快速排序的思想，找到第n/2位置的数。然后扫描数组，确保这个数的确超过数组长度的一半。 第二种，设置两个标记，一个记录值，一个记录次数，当后一个与前一个不同时，记录数减一，当记录数减少到0时候，需要更改值的标记。 时间复杂度都为O
数组算法题型小结
weixin_46746068的博客
08-10 366
1.使用二分法解题，题目一般包含有序数组等条件，解题重点是左右边界一定要定义好 1.1普通二分法查找数据，分清左右区间就行 1.2二分法找重复元素范围，这个需要分左右区间， 1.3找数组中两个元素和等于指定数据。（1）先排序Arrays.sort(),(2)双指针查找 2.快慢指针问题：由于数组的元素地址是连续的，不能删除数据，只能覆盖， 所以涉及到删除元素时，使用快慢指针用快指针元素覆盖慢指针元素 3.双指针法：从数组两端向中间查找找到指定元素 4.滑动窗口法:当问题中涉及到找满足条件的子数组，就要考虑滑
java 完美洗牌,（2）数组相关算法题目
weixin_29149259的博客
03-14 243
数组是最简单的数据结构，占据连续内存并且按顺序存储。以下是与数组有关的算法题目。(1)查询数组中重复数字算法思路：(1)利用hash表，没有便放进去，有就返回(Java中HashMap存数字都是对象，判断数字是否唯一变为对象是否唯一，-128-127好说，其他不好说)。(2)借助基数排序思想，创建一个辅助数组(空间可能会很大)(3)i位置上j和j位置上元素互换，若j等于j位置上元素，说明重复(万一...
有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入一个整数数字。要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧
qq_45634145的博客
01-16 454
执行效果如下：请输入一个整数数字：50生成的新数组是：12 14 23 45 50 66 68 70 77 90 91。
贪心算法解决最大子数组问题
最新发布
05-22
最大子数组问题是在一个数组中找到一个连续的子数组，使得该子数组的元素和最大。贪心算法可以用来解决最大子数组问题。具体来说，贪心算法将问题分解为子问题，并且对于每个子问题都做出一个局部最优解，最终得到整个问题的最优解。 贪心算法解决最大子数组问题的思路如下： 1. 初始化一个变量 max_sum 和一个变量 cur_sum，分别表示当前找到的最大和的子数组和当前遍历的子数组的和。 2. 遍历整个数组，对于每个元素，将其加入当前遍历的子数组中。 3. 每当 cur_sum 大于 max_sum 时，更新 max_sum 的值。 4. 如果 cur_sum 小于零，则将 cur_sum 重置为零。 5. 重复步骤2-4直到遍历完整个数组。 以下是代码示例： ``` int maxSubArray(vector<int>& nums) { int max_sum = INT_MIN; int cur_sum = 0; for (int i = 0; i < nums.size(); i++) { cur_sum += nums[i]; if (cur_sum > max_sum) { max_sum = cur_sum; } if (cur_sum < 0) { cur_sum = 0; } } return max_sum; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值