数据结构与算法：数组和字符串

最新推荐文章于 2024-09-12 19:02:20 发布
最新推荐文章于 2024-09-12 19:02:20 发布
阅读量874 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41433002/article/details/122945926
版权

题目来自LeetBook 系列：《数组和字符串》——https://leetcode-cn.com/leetbook/detail/array-and-string/

文章目录

1. 数组简介

No.1991 找到数组的中间位置

https://leetcode-cn.com/problems/find-the-middle-index-in-array/

原始思路：先遍历一遍得到总和，再从左开始遍历累加，直到前缀和为总和一半
错误1：for遍历没有遍历第一个数
错误2：没有判断当前和是否为偶数（奇数除以2即可以是也可以是1和-1）

具体代码：
执行用时：21 ms, 在所有 Java 提交中击败了21.73%的用户
内存消耗：41.5 MB, 在所有 Java 提交中击败了5.00%的用户

public int findMiddleIndex3(int[] nums) {
		
		if(nums.length == 1){
			return 0;
		}
		
		
    	int sum = 0;
    	int sum2 = 0;
    	int curr_sum;
    	
    	//数组总和
    	for (int i=0; i<nums.length; i++){
    		sum = sum + nums[i];
    	}
    	System.out.println("数组总和为：" + sum);
    	  	
    	//从左边开始加到一半
    	for (int i=0; i<nums.length; i++){
    		
    		if(i == 0){
    			sum2 = 0;
    		}else{
    			sum2 = sum2 + nums[i-1];
    		}
    		curr_sum = sum - nums[i];
    		if(curr_sum%2 == 1 || curr_sum%2 == -1){
    			continue;
    		}   		
    	
    		System.out.println("下标为" + i + "的数字左边数字之和为：" + sum2 + "，此时数组总和为：" + curr_sum);
    		if(sum2 == curr_sum/2){
    			return i;
    		}
    	}
    	return -1;
    }

优化思路：如果前缀和的2倍等于总和减去当前值则表示找到数组的中间位置

具体代码：
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：39.5 MB, 在所有 Java 提交中击败了15.12%的用户

public int findMiddleIndex(int[] nums) {
        // 计算nums数组的中所有元素总和
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }

        int preSum = 0;// 前缀和
        for (int i = 0; i < nums.length; i++) {
            // 前缀和 + nums[i] + 后缀和 = 总和
            // if(前缀和==后缀和) return i;
            // 所以：if(2*前缀和=总和-nums[i]) return i;
            // 如果前缀和的2倍等于总和减去当前值则表示找到数组的中间位置
            if (preSum * 2 == sum - nums[i]) {
                return i;
            }
            // 更新前缀和
            preSum += nums[i];
        }

        return -1;
    }

注意：int total = Arrays.stream(nums).sum();可以求和，但是很慢。

No.35 搜索插入位置

https://leetcode-cn.com/problems/search-insert-position/
思路：经典的二分查找题
错误：

  1. while判断结束时是（l<r）还是（l<=r）？
  2. mid是left + (right-left)/2还是(right + left) / 2？
  3. 最后输出是什么？l？l-1？r？r？……

具体代码：

public int searchInsert(int[] nums, int target) {
        int left = 0;
		int right = nums.length -1 ;

		while(left<=right){
			int middle_num = (right + left) / 2
			
			if (target == nums[middle_num]){
				return middle_num;
			}else if(target > nums[middle_num]){
				left = middle_num+1;
			}else if(target < nums[middle_num]){
				right = middle_num-1;
			}
		}
		return left;
    }

注意：左边界的二分查找和右边界的二分查找！https://www.cnblogs.com/kyoner/p/11080078.html

No.56 合并区间（未完成）

https://leetcode-cn.com/problems/merge-intervals/

2. 二维数组

No.48 旋转图像

https://leetcode-cn.com/problems/rotate-image/
解法1：暴力，使用辅助数组
解法2：原地旋转，四个点一组找规律
解法3：先对角线翻转，再上下翻转

public void rotate1(int[][] matrix) {
		int n = matrix.length;
        int[][] matrix_new = new int[n][n];
        for(int i=0; i<n; i++){
        	for(int j=0; j<n; j++){
        		matrix_new[j][n-i-1] = matrix[i][j];
        	}
        }
        
        for(int i=0; i<n; i++){
        	for(int j=0; j<n; j++){
        		matrix[i][j] = matrix_new[i][j];
        	}
        }
    }

public void rotate2(int[][] matrix) {
		int n = matrix.length;
        int temp = 0;
        for(int i=0; i<n/2; i++){
        	for(int j=0; j<(n+1)/2; j++){
        		temp = matrix[i][j];
        		matrix[i][j] = matrix[n-j-1][i];
        		matrix[n-j-1][i] = matrix[n-i-1][n-j-1];
        		matrix[n-i-1][n-j-1] = matrix[j][n-i-1];
        		matrix[j][n-i-1] = temp;
        	}
        }
    }

public void rotate3(int[][] matrix) {
		int n = matrix.length-1;
        int temp = 0;
        
        //第一步，对角翻转
        for(int i=0; i<=n-1; i++){
        	for(int j=0; j<=n-i-1; j++){
        		//System.out.println("当前调换对子为：" + i + j + "和" + (n-i) + (n-j));
        		temp = matrix[i][j];
        		matrix[i][j] = matrix[n-j][n-i];
        		matrix[n-j][n-i] = temp;
        	}
        }
        
        //第二步，上下翻转
        for(int i=0; i<=n/2; i++){
        	for(int j=0; j<=n; j++){ 
        		//System.out.println("当前调换对子为：" + i + j + "和" + i + (n-j));
        		temp = matrix[i][j];
        		matrix[i][j] = matrix[n-i][j];
        		matrix[n-i][j] = temp;
        	}
        }
    }

No.73 矩阵置0

https://leetcode-cn.com/problems/set-matrix-zeroes/

  1. 解法1：用两个标记数组分别记录每一行和每一列是否有零出现
  2. 解法2：我们可以用矩阵的第一行和第一列代替方法一中的两个标记数组，以达到 O(1)O(1) 的额外空间
  3. 解法3：对方法二进一步优化，只使用一个标记变量记录第一列是否原本存在 00。这样，第一列的第一个元素即可以标记第一行是否出现 00
	/**
	 * 解1：大笨方法，全遍历，记录为0的地方，再换为0
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
	 * 内存消耗：42.8 MB, 在所有 Java 提交中击败了11.02%的用户
	 * .
	 * 时间复杂度：O(mn)，其中 m 是矩阵的行数，n 是矩阵的列数。我们至多只需要遍历该矩阵两次。
	 * 空间复杂度：O(m+n)，其中 m 是矩阵的行数，n 是矩阵的列数。我们需要分别记录每一行或每一列是否有零出现。
	 */
	public void setZeroes1(int[][] matrix) {
		int m = matrix.length, n = matrix[0].length;
        boolean[] row = new boolean[m];
        boolean[] col = new boolean[n];
		
		for(int i=0; i<matrix.length; i++){
        	for(int j=0; j<matrix[0].length; j++){
        		if(matrix[i][j] == 0){
        			//如果发现了0  
        			row[i] = col[j] = true;       			
        		}
        	}
		}
		
		for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (row[i] || col[j]) {
                    matrix[i][j] = 0;
                }
            }
        }

    }

	/**
	 * 解2：两个额外标志位，记录第0行和第0列是否为0
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
	 * 内存消耗：42.7 MB, 在所有 Java 提交中击败了12.76%的用户
	 * 时间复杂度：O(mn)，其中 m是矩阵的行数，n是矩阵的列数。我们至多只需要遍历该矩阵两次。
	 * 空间复杂度：O(1)。我们只需要常数空间存储若干变量。
	 */
	public void setZeroes2(int[][] matrix){
		int m = matrix.length, n = matrix[0].length;
		boolean row0 = false;
		boolean col0 = false;
		
		for(int j=0; j<n; j++){
			if(matrix[0][j] == 0){
				row0 = true;
			}
		}
		
		for(int i=0; i<m; i++){
			if(matrix[i][0] == 0){
				col0 = true;
			}
		}
		
		for(int i=1; i<matrix.length; i++){
        	for(int j=1; j<matrix[0].length; j++){
        		if(matrix[i][j] == 0){
        			//如果发现了0  
        			matrix[i][0] = matrix[0][j] = 0;       			
        		}
        	}
		}
		
		for(int i=1; i<matrix.length; i++){
        	for(int j=1; j<matrix[0].length; j++){
        		if(matrix[i][0] == 0 || matrix[0][j] == 0){
        			//如果发现了0  
        			matrix[i][j] = 0;       			
        		}
        	}
		}
		
		if(row0){
			for(int j=0; j<n; j++){
				matrix[0][j] = 0;
			}
		}
		
		if(col0){
			for(int i=0; i<m; i++){
				matrix[i][0] = 0;
			}
		}
	}

解3注意先判断matrix[0][0]，再判断标志位，否则第一列容易全0。

	/**
	 * 解3：一个额外标志位，记录第0行是否为0，第0列是否为0记录在[0][0]位置
	 * 执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
	 * 内存消耗：43.1 MB, 在所有 Java 提交中击败了5.58%的用户
	 */
	public void setZeroes3(int[][] matrix){
		int m = matrix.length, n = matrix[0].length;
		boolean row0 = false;
		
		//第0行是否存在0
		for(int j=0; j<n; j++){
			if(matrix[0][j] == 0){
				row0 = true;
			}
		}
		
		//第0列是否存在0
		for(int i=0; i<m; i++){
			if(matrix[i][0] == 0){
				matrix[0][0] = 0;
			}
		}
		for(int i=1; i<matrix.length; i++){
        	for(int j=1; j<matrix[0].length; j++){
        		if(matrix[i][j] == 0){
        			//如果发现了0  
        			matrix[i][0] = matrix[0][j] = 0;       			
        		}
        	}
		}
		for(int i=1; i<matrix.length; i++){
        	for(int j=1; j<matrix[0].length; j++){
        		if(matrix[i][0] == 0 || matrix[0][j] == 0){
        			//如果发现了0  
        			matrix[i][j] = 0;       			
        		}
        	}
		}
		
		if(matrix[0][0] == 0){
			
			for(int i=0; i<m; i++){
				matrix[i][0] = 0;
			}
		}
		
		if(row0){
			for(int j=0; j<n; j++){
				matrix[0][j] = 0;
			}
		}
		
	}

No.498 对角线遍历（未完成）

https://leetcode-cn.com/problems/diagonal-traverse/

3. 字符串

No.14 最长公共前缀

https://leetcode-cn.com/problems/longest-common-prefix/

  1. 横向扫描
  2. 纵向扫描
  3. 分治（没实现）
  4. 二分（没实现）
//解1：横向比较
	public String longestCommonPrefix1(String[] strs) {
		if(strs.length == 0){
			return "";
		}		
		String ans = strs[0];
		for(int i=1; i<strs.length; i++){
			int j=0;//必须放到外面，不然后面ans = ans.substring(0, j)用不了j
			for(; j<ans.length() && j<strs[i].length(); j++){
				if(ans.charAt(j) != strs[i].charAt(j)){
					break;
				}
			}			
			ans = ans.substring(0, j);//截取子串
			if(ans.equals("")){
				return ans;
			}
		}		
		return ans;
    }

public String longestCommonPrefix2(String[] strs) {
		if(strs.length == 0){
			return "";
		}
		
		
		int len = strs[0].length();//第一个字母长度
		int num = strs.length;//单词个数
		
		//1.遍历每一列（按第一个单词的长度）
		for(int i=0; i<len; i++){
			//2.遍历每一列中的每一个字母
			for(int j=0; j<num; j++){
				char c = strs[0].charAt(i);
				//3.如果字母就这么长 或者 不一样了，截断字符串返回
				if(strs[j].length()==i || strs[j].charAt(i)!=c){
					return strs[0].substring(0, i);
				}
			}
			
		}

		
		//4.否则第一个单词就是公共字串长度
		return strs[0];
		
	}

No.5 最长回文子串（未完成）

https://leetcode-cn.com/problems/longest-palindromic-substring/

No.151 翻转字符串里的单词（未完成）

https://leetcode-cn.com/problems/reverse-words-in-a-string/

4. 双指针

No.344 反转字符串

https://leetcode-cn.com/problems/reverse-string/
一遍过的题目，没啥可说的。

public void reverseString(char[] s) {
		int l = 0;
		int r = s.length - 1;
		
		while(l<r){
			char temp = s[l];
			s[l] = s[r];
			s[r] = temp;
			l++;
			r--;
		}

    }

No.561 数组拆分1

https://leetcode-cn.com/problems/array-partition-i/
一遍过的题目，没啥可说的。

public int arrayPairSum(int[] nums) {
		int sum = 0;
		
		Arrays.sort(nums);
		
		
		for(int i=0; i<nums.length; i++){
			sum = sum+nums[i];
			i++;
		}
		
		return sum;

    }

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

https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/

  1. 暴力算法，对于每一个数，再遍历一遍数组找，结果就是算法超时。
  2. 二分查找。上面有个类似的，但是这题还是没做出来，还是有点问题，不过问题我暂时还没找出来。
  3. 双指针。最快的，每次算l+r和target的大小关系，决定是l+1还是r-1
//解1：暴力算法，超时
	public int[] twoSum1(int[] numbers, int target) {
		int[] ans = new int[]{0,0};//初始化
		int len = numbers.length;//数组长度
		
		for(int i=0; i<len; i++){
			for(int j=len-1; j>0; j--){
				//System.out.println("ij之和为：" + (numbers[i]+numbers[j]));
				if(numbers[i]+numbers[j] == target){
					ans[0] = i+1;
					ans[1] = j+1;
					return ans;
				}
			}
		}
		return ans;	
    }

	/**
	 * 解2：二分查找
	 * 
	 * 
	 */
	public int[] twoSum3(int[] numbers, int target){
		int[] ans = new int[]{0,0};//初始化
		
		for(int i=0; i<numbers.length; i++){
			int rest = target - numbers[i];
			System.out.println("当前处理第" + (i+1) + "个数"+ numbers[i] +"，他的rest的值是" + rest);
			
			int l = i;
			int r = numbers.length-1;
			
			while(l<=r){
				int mid = l + (r-l)/2;
				System.out.println("当前l为" + l + "，当前r为" + r + "，当前mid为" + mid);
				if(rest == numbers[mid]){
					ans[0] = i+1;
					ans[1] = mid+1;
					System.out.println("找到答案" );
					return ans;
				}else if(rest > numbers[mid]){
					
					l = mid + 1;
					System.out.println("rest比mid大，所以l = mid + 1。l变为" + l + "，r仍为" + r);
				}else if(rest < numbers[mid]){
					
					r = mid -1;
					System.out.println("mid比rest大，所以r = mid -1。l仍为：" + l + "，r变为" + r);
				}
			}
			System.out.println("***********************");
		}
		return ans;
	}
	//二分正解
	public int[] twoSum(int[] numbers, int target) {
        for (int i = 0; i < numbers.length; ++i) {
            int low = i + 1, high = numbers.length - 1;
            while (low <= high) {
                int mid = (high - low) / 2 + low;
                if (numbers[mid] == target - numbers[i]) {
                    return new int[]{i + 1, mid + 1};
                } else if (numbers[mid] > target - numbers[i]) {
                    high = mid - 1;
                } else {
                    low = mid + 1;
                }
            }
        }
        return new int[]{-1, -1};
    }

	/**
	 * 解3：双指针
	 * 执行用时：2 ms, 在所有 Java 提交中击败了36.04%的用户
	 * 内存消耗：43.9 MB, 在所有 Java 提交中击败了8.57%的用户
	 */
	public int[] twoSum2(int[] numbers, int target) {
		int[] ans = new int[]{0,0};//初始化
		int l = 0;
		int r = numbers.length-1;
		
		while(l<r){
			if(numbers[l]+numbers[r] == target){
				ans[0] = l+1;
				ans[1] = r+1;
				return ans;
			}else if(numbers[l]+numbers[r] > target){
				r--;
			}else if(numbers[l]+numbers[r] < target){
				l++;
			}
		}
		return ans;
	}

No.27 移除元素

https://leetcode-cn.com/problems/remove-element/submissions/
解：双指针，首尾各一个，往中间凑，该删的放最后。
注意：while终止条件需要等于号，最后return需要算一下

		public int removeElement(int[] nums, int val) {
		int l = 0;
		int r = nums.length-1;

		while(l<=r){
			System.out.println("a.r的值为：" + r);
			//如果靠近末尾的数就是val，那末尾标志左移一个
			if(nums[r] == val){
				//System.out.println("b.r的值为：" + r);
				nums[r] = 0;
				r--;
			}else{
				if(nums[l] == val){
					nums[l] = nums[r];
					nums[r] = 0;
					r--;
				}
				l++;
			}
		}
		//System.out.println("c.r的值为：" + r);
		return r+1;
    }

No.485 最大连续 1 的个数

https://leetcode-cn.com/problems/max-consecutive-ones/
简单题我重拳出击，一遍过。
注意：最后一个1算上之后有可能不加入计算，利用||的性质。

public int findMaxConsecutiveOnes(int[] nums) {
		int one_num = 0;//连续的1的数量
		int max_num = 0;//当前最大连续的1的数量
		
		for (int i=0; i<=nums.length; i++){
			//System.out.println("i=" + i);
			if (i == nums.length || nums[i] == 0){
				if(one_num > max_num){
					max_num = one_num;
				}
				one_num = 0;
				//System.out.println("当前最大数为：" + max_num);
			}else{
				one_num++;
			}
			//System.out.println("one_num=" + one_num);
		}	
		return max_num;
    }

No.209 长度最小的子数组

https://leetcode-cn.com/problems/minimum-size-subarray-sum/

  1. 暴力
  2. 前缀和+二分查找（没实现）
  3. 滑动窗口，判断终止条件花了很多时间
	/**
	 * 解1：暴力
	 * 执行用时：489 ms, 在所有 Java 提交中击败了5.04%的用户
	 * 内存消耗：41 MB, 在所有 Java 提交中击败了18.72%的用户
	 * 
	 * 在>=部分优化之后
	 * 执行用时：135 ms, 在所有 Java 提交中击败了9.70%的用户
	 * 内存消耗：41.2 MB, 在所有 Java 提交中击败了12.96%的用户
	 */
	public int minSubArrayLen1(int target, int[] nums) {
		int short_len = 10000;
		for(int i=0; i<nums.length; i++){
			int now_len = 0; // 当前符合条件的连续子串长度
			int sum = 0;
			for(int j=i; j<nums.length; j++){
				sum = sum + nums[j];
				System.out.println(i + " " + j + "，sum = " + sum);
				now_len++;
				if(sum >= target){
					System.out.println("抓住一个符合条件的子串长为：" + now_len);
					if(short_len > now_len){
						short_len = now_len;
					}
					now_len = 0;
					sum = 0;
					break;
				}else if(sum < target){
					continue;
				}
			}
		}
		
		if(short_len == 10000){
			return 0;
		}
		return short_len;
    }

	/**
	 * 解2：双指针滑动窗口
	 * 执行用时：1 ms, 在所有 Java 提交中击败了99.99%的用户
	 * 内存消耗：41.2 MB, 在所有 Java 提交中击败了14.74%的用户
	 * 
	 */
	public int minSubArrayLen2(int target, int[] nums) {
		int ans = 10000; //最小连续个数
		int sum = nums[0]; //当前总和。sum不够target时候加nums[r]
		int l = 0;
		int r = 0;
		//终止条件：1.
		//r已经到达最右，sum还是不够target
		while(r<nums.length){			
			System.out.println("新一轮开始，" + l + " " + r + "，当前sum = " + sum);
			//如果当前sum不够target，则r右移，count加一
			if(sum < target){
				r++;
				if(r>=nums.length){
					break;
				}
				sum += nums[r];
				
				System.out.println("当前sum不够target，l不变r右移。" + l + " " + r + "，当前sum = " + sum);
				
				
				//如果当前sum够target，则l右移，count减一，sum减去nums[l]
			}else if(sum >= target){
				//System.out.println(sum + "大于等于" + target);
				
				System.out.println("抓住一个符合条件的子串长为：" + (r-l+1));
				if((r-l+1) < ans){
					ans = (r-l+1);
				}
				sum -= nums[l];
				l++;
				System.out.println("当前sum够target，l右移r不变。" + l + " " + r + "，当前sum = " + sum);			
			}
		}
		
		if(ans == 10000){
			return 0;
		}
		return ans;
	}

/**
	 * 官方解
	 * 两个优点：Integer.MAX_VALUE和双while
	 */
	public int minSubArrayLen(int s, int[] nums) {
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        int ans = Integer.MAX_VALUE;
        int start = 0, end = 0;
        int sum = 0;
        while (end < n) {
            sum += nums[end];
            while (sum >= s) {
                ans = Math.min(ans, end - start + 1);
                sum -= nums[start];
                start++;
            }
            end++;
        }
        return ans == Integer.MAX_VALUE ? 0 : ans;
    }

小结

No.118 杨辉三角

https://leetcode-cn.com/problems/pascals-triangle/
没什么难的，就是掌握List<List>的声明创建getset方法。

	List<List<Integer>> ans=new ArrayList<List<Integer>>();
		for(int i=0; i<numRows; i++){
			List<Integer> row = new ArrayList<Integer>();
			for(int j=0; j<=i; j++){
				if(i == 0 || i == 1 || j ==0 || j == i){
					row.add(1);
					continue;
				}
				int now = ans.get(i-1).get(j-1) + ans.get(i-1).get(j);
				row.add(now);
			}
			ans.add(row);
		}
		
		return ans;

No.119 杨辉三角 II

https://leetcode-cn.com/problems/pascals-triangle-ii/
解：

  1. 和上面118类似，求全部，输出最后，小优化滚动数组每次保留一行省点空间
  2. 倒着求解，挺妙，一个空间，倒着为了前面数不变
  3. 直接数学算出相邻数的关系
	/**
	 * 解一：全求出来整体三角。有个小优化只留两行
	 * 执行用时：2 ms, 在所有 Java 提交中击败了25.29%的用户
	 * 内存消耗：39.3 MB, 在所有 Java 提交中击败了5.03%的用户
	 */
	public List<Integer> getRow1(int rowIndex) {
		List<List<Integer>> ans=new ArrayList<List<Integer>>();
		for(int i=0; i<rowIndex+1; i++){
			List<Integer> row = new ArrayList<Integer>();
			for(int j=0; j<=i; j++){
				if(i == 0 || i == 1 || j ==0 || j == i){
					row.add(1);
					continue;
				}
				int now = ans.get(i-1).get(j-1) + ans.get(i-1).get(j);
				row.add(now);
			}
			ans.add(row);
		}
		
		return ans.get(rowIndex);
    }

	/**
	 * 解二，挺妙，创建一个串，倒着求
	 * 
	 */
	public List<Integer> getRow2(int rowIndex) {
        List<Integer> row = new ArrayList<Integer>();
        row.add(1);
        for (int i = 1; i <= rowIndex; ++i) {
            row.add(0);
            System.out.println(row);
            for (int j = i; j > 0; --j) {
                row.set(j, row.get(j) + row.get(j - 1));
                System.out.println(row);
            }
        }
        return row;
    }

	/**
	 * 解3
	 * 直接求出每一个数
	 */
	public List<Integer> getRow(int rowIndex) {
        List<Integer> row = new ArrayList<Integer>();
        row.add(1);
        for (int i = 1; i <= rowIndex; ++i) {
            row.add((int) ((long) row.get(i - 1) * (rowIndex - i + 1) / i));
            System.out.println(row);
        }
        return row;
    }

No.557 反转字符串中的单词 III

https://leetcode-cn.com/problems/reverse-words-in-a-string-iii/
由于java语言的特性，string类型不可变，不能原地操作，需要开辟额外空间。

	//暴力解
	public String reverseWords1(String s) {
		StringBuffer sb = new StringBuffer();
		int i=0;
		int p=0;//连续非空格字母数量
		while(i<=s.length()){
			if(i==s.length()-1){
				for(int j=0; j<p+1; j++){
					sb.append(s.charAt(i-j));
					//System.out.println(j);
					//System.out.println(sb.toString() + "，增加的是第" + (i-j) + "个字符！");
				}
				return sb.toString();
			}
			if(s.charAt(i) == ' '){
				//System.out.println("碰到空格了");
				for(int j=1; j<=p; j++){
					sb.append(s.charAt(i-j));
					//System.out.println(sb.toString() + "，增加的是第" + (i-j) + "个字符");
				}
				sb.append(' ');
				p=0;
			}else if(s.charAt(i) != ' '){
				p++;
			}
			i++;
		}
		return sb.toString();
    }

//官方解，i++写在前面，不需要额外考虑最后一个
	public String reverseWords(String s) {
        StringBuffer ret = new StringBuffer();
        int length = s.length();
        int i = 0;
        while (i < length) {
            int start = i;
            while (i < length && s.charAt(i) != ' ') {
                i++;
            }
            for (int p = start; p < i; p++) {
                ret.append(s.charAt(start + i - 1 - p));
            }
            while (i < length && s.charAt(i) == ' ') {
                i++;
                ret.append(' ');
            }
        }
        return ret.toString();
    }

No.153 寻找旋转排序数组中的最小值

https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/
一次过的，没啥说的。不过还有二分法没实现。

public int findMin(int[] nums) {
		int ans = 0;
		int len = nums.length;
		if(len == 1){
			return nums[0];
		}
		//先判断首尾情况
		if(nums[1]>nums[0] && nums[len-1]>nums[0]){
			return nums[0];
		}
		if(nums[len-2]>nums[len-1] && nums[len-1]<nums[0]){
			return nums[len-1];
		}
		//判断中间
		for(int i=1; i<nums.length-1; i++){
			if(nums[i]<nums[i-1] && nums[i]<nums[i+1]){
				ans = nums[i];
				break;
			}
		}		
		return ans;
    }

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

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/
双指针，一遍过。

public int removeDuplicates(int[] nums) {
        int a = 0; //无重复数组位置
		int now = nums[0]; //当前比较数字
		for(int i=1; i<nums.length; i++){
			if(nums[i] != now){
				nums[a+1] = nums[i];
				now = nums[i];
				a++;
			}
		}				
		return a+1;

    }

No.283 移动零

https://leetcode-cn.com/problems/move-zeroes/
解：非零按顺序前移，后面补0。还有一种更快的双指针，比较简单没写。

	public void moveZeroes(int[] nums) {
		if(nums.length == 1){
			return;
		}
		
		int a=0; //非零数字位置
		for(int i=0; i<nums.length; i++){
			if(nums[i] != 0){
				nums[a] = nums[i];
				a++;
			}
		}
		for(int j=a; j<nums.length; j++){
			nums[j] = 0;
		}
    }
平什么阿
关注
专栏目录
【数据结构】数组和字符串
weixin_50792396的博客
10-19 400
leetbook《数组和字符串
数据结构笔记——数组和字符串
Mouguv的博客
11-07 593
数组和字符串主要内容4.1 串的基本概念4.1.1 串的概念4.2模式匹配4.2.1模式匹配——BF（Brute-Force）算法4.2.2模式匹配——KMP算法4.3 多维数组数组的定义数组的特点数组的基本操作数组的存储结构与寻址——一维数组数组的存储结构与寻址——二维数组4.4 特殊矩阵4.4.1 对称矩阵4.4.2三角矩阵4.4.3 对角矩阵（三对角矩阵为例）4.4.4 稀疏矩阵及存储4.4...
算法 - 每日一题 | 寻找数组的中心索引 724
庭前云落的博客
06-30 180
从今天开始，刷LeetCdoe，每天一道算法题。顺带重学数据结构。 题目描述： 给你一个整数 nums，请计算数组的 中心下标。 数组中心下标：其左侧元素相加的...
leetcode刷题：第一周
weixin_50835854的博客
02-27 1377
系列文章目录 leetcode刷题：第一周 文章目录系列文章目录前言第一天1.二分查找2.第一个错误版本3.搜索插入位置第二天1.有序数组的平方2.轮转数组第三天1.移动零2.两数之和 II - 输入有序数组第四天1.反转字符串2.反转字符串中的单词 III第五天1.链表的中间结点2.删除链表的倒数第 N 个结点第六天1.无重复字符的最长子串2.字符串的排列总结 前言 。 博主刚刚结束了RHCE的学习，下一步决定刷一刷leetcode的算法题，一天2-3道，周末巩固复习。 第一天 1.二分查找 给定
第四天的算法练习
m0_67186869的博客
06-13 81
第四天算法练习。
反转字符串中的单词（力扣）（切记：java中String是不可变量）
txwhmeng的博客
07-29 128
给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。 示例： 输入："Let's take LeetCode contest" 输出："s'teL ekat edoCteeL tsetnoc" 思路与算法 开辟一个新字符串。然后从头到尾遍历原字符串，直到找到空格为止，此时找到了一个单词，并能得到单词的起止位置。随后，根据单词的起止位置，可以将该单词逆序放到新字符串当中。如此循环多次，直到遍历完原字符串，就能得到翻转后的结果。 class Solu
leecode第四天，双指针-反转字符串和反转字符串中的单词
zzzzztwerfxd的博客
11-15 551
闲话不说先看第一题-反转字符串 题目很简单，只要设定双指针交换就行，直接上代码 class Solution { public void reverseString(char[] s) { int n =s.length; int left = 0; int right = n-1; while(left < right){ char middle = s[right]; s
玩转Matlab：数组和字符串操作技巧
08-11
在MATLAB中，数组和字符串是两种非常基础且重要的数据结构。它们在处理数值计算、数据分析、算法实现以及文本处理等方面发挥着核心作用。本文将深入探讨如何在MATLAB中高效地进行数组和字符串的操作。 一、数组操作...
leetcode中DFS与BFS算法在数组和字符串中的应用
12-20
在编程领域，DFS（深度优先遍历）和BFS（广度优先遍历）是两种常用的图和树的遍历算法。它们的核心在于探索数据结构...理解这两种算法的精髓，并能灵活应用于数组和字符串等非传统树形结构，是提升编程技能的重要一步。
吉大数据结构课程 数据结构与算法课程 由浅入深 讲解清晰 03 第三章 数组和字符串（共101页）.pptx
10-06
数据结构是计算机科学中至关重要的基础概念，它关乎如何高效地组织和管理数据，以便...通过吉大的数据结构课程，学习者可以从基础知识到高级技巧逐步掌握数组和字符串的运用，为后续的算法学习和软件开发打下坚实基础。
数据结构课件：第3章 数组和字符串.ppt
09-21
数据结构中的数组和字符串是计算机科学中基础且重要的概念，它们在编程和算法设计中扮演着核心角色。数组，特别是线性数组（一维数组），是数据存储的基础形式，而字符串则是处理文本信息的主要手段。 一维数组是...
15、探索Go语言之美：数组与字符串操作技巧
silenceallat的博客
06-20 678
本文深入探讨了Go语言中的数组和字符串，详细介绍了它们的基本操作和常用函数，并通过实际应用场景和实用技巧，帮助读者快速掌握这一重要知识点。文章逻辑清晰，语言通俗易懂，既适合初学者入门，也适用于有经验的开发者提高。
LeetCode-557 反转字符串种的单词Ⅲ
weixin_53156322的博客
09-26 113
使用StringBuffer拼接字符串，一个大循环，次数是数组的长度，内循环第一个找单词，第二个反转单词，第三个寻找并添加每个单词后面的空格，最后返回新串 这题是应该是中等题吧，自己写的不太行，后面就去看题解了，c或者c++就可以直接在原字符串上操作，对于java这些语言就得使用额外的空间了 class Solution { public String reverseWords(String s) { StringBuffer ret = new StringBuffer();
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 446
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 254
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1140
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1165
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
算法基础-约数
qq_65186476的博客
09-11 289
试除法求约数、约数个数、约数之和、最大公约数
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 550
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

平什么阿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值