算法刷题笔记

最新推荐文章于 2022-12-11 20:40:00 发布

蓝天37123

最新推荐文章于 2022-12-11 20:40:00 发布

阅读量431

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/weixin_44207504/article/details/118736401

版权

这篇博客主要探讨了LeetCode和在线判题平台（OJ）上的算法问题，包括字符串操作如二分查找、实现strStr()，线性表与链表的基本操作，以及哈希表、树、图、排序算法的应用。文章还深入讨论了动态规划在解决最大子序和、分发饼干问题中的应用。通过对这些经典算法的实践，提升了解决信息技术问题的能力。

摘要由CSDN通过智能技术生成

一、LeetCode

1.字符串

LeetCode 704

/**
 * LC704二分查找
 * 当left<=right，比较中间元素nums[pivot]和目标值
 * 如果target = nums[pivot]，返回pivot
 * 如果target < nums[pivot]，向左侧继续搜索 right=pivot-1
 * 如果target > nums[pivot]，向右侧继续搜索 left=pivot+1
 * 当跳出while循环没有找到，则返回-1
 */
public class Main {
	public static void main(String[] args) {
		//int[] nums = {-1,0,3,5,9,12};
		int[] nums = {-1,0,3,5,9,12};
		int target = 2;
		int r = search(nums, target);
		System.out.println(r);
	}
	
	public static int search(int[] nums, int target) {
		int pivot, left = 0, right = nums.length - 1;
	    while (left <= right) {
	      pivot = left + (right - left) / 2;
	      if (nums[pivot] == target) return pivot;
	      if (target < nums[pivot]) right = pivot - 1;
	      else left = pivot + 1;
	    }
	    return -1;
	}
}

LeetCode 28

/**
 * LC28 实现strStr()
 * 1.得到needle的length
 * 1.for i loop haystack
 * 2.用substring得到 str = haystack.substring(i，i+length)
 * 3.如果str等于needle就返回i
 * 4.最后如果没有相等的就返回-1
 */
public class Main {
    public int strStr(String haystack, String needle) {
        int length = needle.length();
        if (haystack.equals("") && needle.equals("")) {
            return 0;
        }
        for (int i = 0; i < haystack.length(); i++) {
            if (i + length <= haystack.length()) {
                String str = haystack.substring(i, i + length);
                if (str.equals(needle)) {
                    return i;
                }
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        Main2 main2 = new Main2();
        int result = main2.strStr("aaaaa", "aab");
        System.out.println(result);
    }
}

2.线性表

2.链表

3.哈希表

2.树

2.图

2.排序算法

2.迭代与递归

2.分治思想

2.搜素算法

2.贪心算法

LeetCode 455 分发饼干

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * LC455. 分发饼干
 * 1.把g和s排序，s转成sList
 * 2.嵌套for loop比较选取满足条件sList.get(j)>=g[i]
 * 3.满足条件num++,sList.remove(j),break跳出循环
 */
class Main2 {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        List<Integer> sList = new ArrayList<>();
        for (int i : s) {
            sList.add(i);
        }
        int num = 0;
        for (int i = 0; i < g.length; i++) {
            for (int j = 0; j < sList.size(); j++) {
                if (sList.get(j) >= g[i]) {
                    num++;
                    sList.remove(j);
                    break;
                }
            }
        }
        return num;
    }

    public static void main(String[] args) {
        Main2 main2 = new Main2();
        int[] g = {1, 2, 3};
        int[] s = {1, 1};
        main2.findContentChildren(g, s);
    }
}

LeetCode 53 最大子序和

/**
 * LC53 最大子序和
 * 局部最优：当前连续和为负数时，变为0，从下一个元素崇信计算连续和
 * 全局最优：选取最大连续和
 * 
 */
class Main2 {
    public int maxSubArray(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
        int count = 0;
        int sum = Integer.MIN_VALUE;
        for (int i = 0; i < nums.length; i++) {
            if (count < 0) {
                count = 0;
            }
            count += nums[i];
            sum = Math.max(count,sum);
        }
        return sum;
    }

    public static void main(String[] args) {
        Main2 main2 = new Main2();
        int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
        System.out.println(main2.maxSubArray(nums));
    }
}

2.动态规划

一、OJ