顺序：数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论
目录
顺序：数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论
数组
基础
数组是存放在连续内存空间上的相同类型数据的集合。（集合可以重复）
一维数组在内存空间的地址是连续的，但是在Java中没有指针，也不对程序员暴露其元素的地址，寻址操作完全交给虚拟机。打印二维数组的地址值不是真正的地址，而是经过处理过后的数值。
相关算法
二分法：要求数组有序且无重复元素！
使用左闭右闭的偏移不变量。
设置两个指针left和right。mid指针指向两个指针中间位置。
基础代码
找到指定元素对应的数组下标。代码如下
class Solution {
public int search(int[] nums, int target) {
// 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
if (target < nums[0] || target > nums[nums.length - 1]) {
return -1;
}
int left =0;
int right = nums.length-1;
while(left<=right){
int mid = left + ((right-left)/2);
if(target == nums[mid]){
return mid;
}
else if(nums[mid] < target){
left = mid+1;
}
else{
right = mid-1;
}
}
return -1;
}
}拓展
1.当数组中不存在该元素时在合适位置插入元素。
class Solution {
public int searchInsert(int[] nums, int target) {
int left =0;
int right = nums.length-1;
while(left<=right){
int mid = left +((right-left)/2);
if(nums[mid] == target){
return mid;
}
else if(nums[mid] > target){
//移动右指针
right = mid -1;
}
else{
left = mid+1;
}
}
//数组中不存在该元素
//此时一定是 right < left
//2.目标值在数组所有元素之前 0
//3.目标值插入数组中 在right的后一位插入
//4.目标值在数组所有元素之后
return right +1;
}
}2.数组有序但是有重复元素，返回元素出现的第一个位置和最后一个位置。
class Solution {
public int[] searchRange(int[] nums, int target) {
//三种情况
int end = rightBorder(nums,target);
int start = leftBorder(nums,target);
if(end == -2 || start == -2){
return new int[]{-1,-1};
}
if(end - start > 1){
return new int [] {start+1,end-1};
}
return new int[]{-1,-1};
//2.target 在数组范围中，但数组中不存在target return {-1,-1}
//3.target 在数组范围中，且数组中存在target return{左边界，右边界}
//分别算左 右边界
}
//算右边界 从左向右寻找第一个 >=target的下标 关注left指针。
public int rightBorder(int[] nums,int target){
int left =0;
int right = nums.length-1;
int[] res = new int[nums.length];
int end = -2;
while(left<=right){
int mid = left+((right-left)/2);
if(nums[mid] > target){
right = mid -1;
}
else{
left = mid +1;
end = left;
}
}
return end;
}
//算左边界 从右向左寻找第一个 <= target 的下标。关注右指针。
public int leftBorder(int[] nums,int target){
int left = 0;
int right = nums.length-1;
int start =-2;
while(left <= right){
int mid = left+((right-left)/2);
if(nums[mid] >= target){
right = mid - 1;
start = right;
}
else{
left = mid + 1;
}
}
return start;
}
}4. 不使用任何内置指数函数和算符计算平方根和完全平方数。
class Solution {
public int mySqrt(int x) {
if(x==0){
return 0;
}
int left = 1;
int right = x;
while(left<=right){
int mid = left+((right-left)/2);
if( mid == x/mid){
return mid;
}
else if(mid > x/mid){
right = mid -1;
}
else{
left = mid+1;
}
}
return right;
}
}双指针法 原地操作数组
要理解slow和fast的含义。slow指针不会移动到fast指针的位置。而是fast指向的元素赋给slow指针指向的位置。
两个指针 fast和slow。fast指向原数组的下标，一直在变化。slow不占用多余的空间在原数组上直接操作。当fast指的元素符合要求时，将该值赋值给slow指针指向的位置。slow指针向后移动一位。当fast遍历完原数组时，slow指向的数组就是符合条件的新数组。
1.要删除原数组的指定元素，剩下的元素组成新数组。fast遍历原数组，满足条件才加入slow指向的新数组。slow指向的下标添加元素了，就要向后移动一位，以便于新的满足要求的元素加入新数组。
class Solution {
public int removeElement(int[] nums, int val) {
int slow =0;
for(int fast =0;fast<nums.length;fast++){
if(nums[fast] != val){
nums[slow] = nums[fast];
slow++;
}
}
return slow;
}
}2. 原地删除非严格递增排列数组中的重复元素
class Solution {
public int removeDuplicates(int[] nums) {
//要判断元素是否在新数组中已经存在了。比较的一定是当前slow指向的位置与fast指向的位置的元素是否一样。不一样才赋值。且赋给slow指针指向的下一个位置（新的元素）。
int slow = 0;
//fast从下标为1的位置开始。
for(int fast =1;fast<nums.length;fast++){
if(nums[fast] != nums[slow]){
//先赋值
nums[slow+1] = nums[fast];
//再移动
slow++;
}
}
return slow+1;
}
}3.移动零。分两步
class Solution {
public void moveZeroes(int[] nums) {
int slow =0;
//1.按顺序得到非零元素 slow是非零元素的个数
for(int fast =0;fast< nums.length;fast++){
if(nums[fast] != 0){
nums[slow] = nums[fast];
slow++;
}
}
//2.计算零元素的个数，将后面的位置变成0。
int count = nums.length - slow;
for(int i =slow;i<nums.length;i++){
nums[i] =0;
}
}
}4.字符串转成字符数组的双指针法 。注意如何将字符串转成字符数组
class Solution {
public boolean backspaceCompare(String s, String t) {
return edit(s).equals(edit(t));
}
public String edit(String str){
//将字符串转成字符数组
char[] charList = str.toCharArray();
int slow =0;
for(int fast =0;fast<charList.length;fast++){
if(charList[fast] == '#'){
if(slow>0){
slow--;
}
}
else{
charList[slow] = charList[fast];
slow++;
}
}
char[] res = Arrays.copyOfRange(charList, 0, slow);
return new String(res);
}
}5. 有序数组的平方 左右指针分别指向数组的开头与结尾。首先得到的是数组的最大值。所以构建新数组右从后向前创建。
class Solution {
public int[] sortedSquares(int[] nums) {
int left =0;
int right = nums.length-1;
int[] res = new int[nums.length];
int j = res.length-1;
while(j>=0){
while(left<= right){
if(nums[left]*nums[left] > nums[right]* nums[right]){
res[j--]= nums[left]*nums[left];
left++;
}
else{
res[j--] = nums[right]* nums[right];
right--;
}
}
}
return res;
}
}滑动窗口 双指针的另一种用法 要求结果连续！
1.连续的最长子序列和 暴力两层for循环 时间复杂度是O（n^2）
滑动窗口用一个for循环。循环的索引表示窗口的终止位置。
关键代码逻辑：
当窗口符合某种条件时，记录结果，左指针向后移动。对应的窗口也要做改变。
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int i =0;
int res = Integer.MAX_VALUE;
int sum =0;
for(int j =0;j<nums.length;j++){
sum +=nums[j];
while(sum >= target){
res = Math.min(res,j-i+1);
sum -= nums[i];
i++;
}
}
return res ==Integer.MAX_VALUE ? 0:res;
}
}关键在于 判断 窗口（连续子序列）和的大小是否大于目标值。
满足条件的话，先计算长度，移动起始指针，重新计算窗口的大小。
while(sum >= target){
res = Math.min(res,j-i+1);
sum -= nums[i];
i++;
}2. 水果成篮
两只篮子。每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
由此，确定需要的数据结构是Map 。map的key必须<=2 ，key对应的value>=1.当value=0 时篮子是空的，能放新的种类的key了，必须将其删掉。
窗口内是什么： 篮子内放的水果。窗口大小指水果的个数。
如何移动窗口的起始位置？
当 map的key >2 必须要缩小窗口。起始指针（key）对应的value要-1。
如果value=0，需要空出来篮子，放新元素。
class Solution {
public int totalFruit(int[] fruits) {
int i=0;//起始位置
//用Map存储窗口
Map<Integer,Integer> map = new HashMap<>();
int ans = 0;
for(int j =0;j<fruits.length;j++){
//放入篮子的动作
map.put(fruits[j],map.getOrDefault(fruits[j],0)+1);
//key的值大于2
while(map.size()>2){
// 缩短窗口长度
map.put(fruits[i],map.get(fruits[i])-1);
//如果减去之后value为0 将对应的键值对删去 保证map的size<=2跳出循环。
if(map.get(fruits[i]) == 0){
map.remove(fruits[i]);
}
//起始指针向后移动
i++;
}
//收集结果
ans = Math.max(ans,j-i+1);
}
return ans;
}
}关键代码逻辑：
1.判断跳出循环的条件 map.size()<=2
2. 循环内：
先操作篮子，将起始指针对应的水果从篮子里拿出去。判断拿出去之后会不会空出来一个篮子放新元素。再操作起始指针向后移动一位。
3.什么时候收集结果？
当key <= 2的时候 计算篮子内水果的个数。
while(map.size()>2){
// 缩短窗口长度
map.put(fruits[i],map.get(fruits[i])-1);
//如果减去之后value为0 将对应的键值对删去 保证map的size<=2跳出循环。
if(map.get(fruits[i]) == 0){
map.remove(fruits[i]);
}
//起始指针向后移动
i++;
}前缀和
计算区间和
import java.util.*;
class Main{
public static void main (String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] nums = new int[n+1];
int num;
for(int i=1;i<=n;i++){
num = sc.nextInt();
nums[i] = nums[i-1]+num;
}
//左闭右闭区间[start,end]
int a,b;
while(sc.hasNextInt()){
a = sc.nextInt()+1;
b = sc.nextInt()+1;
if(a<1) a=1;
if(b>n) b=n;
System.out.println(nums[b]-nums[a-1]);
}
}
}模拟行为
螺旋矩阵
class Solution {
public int[][] generateMatrix(int n) {
int[][] nums = new int[n][n];
int startX = 0, startY = 0; // 每一圈的起始点
int offset = 1;
int count = 1; // 矩阵中需要填写的数字
int loop = 1; // 记录当前的圈数
int i, j; // j 代表列, i 代表行;
while (loop <= n / 2) {
// 顶部
// 左闭右开，所以判断循环结束时， j 不能等于 n - offset
for (j = startY; j < n - offset; j++) {
nums[startX][j] = count++;
}
// 右列
// 左闭右开，所以判断循环结束时， i 不能等于 n - offset
for (i = startX; i < n - offset; i++) {
nums[i][j] = count++;
}
// 底部
// 左闭右开，所以判断循环结束时， j != startY
for (; j > startY; j--) {
nums[i][j] = count++;
}
// 左列
// 左闭右开，所以判断循环结束时， i != startX
for (; i > startX; i--) {
nums[i][j] = count++;
}
startX++;
startY++;
offset++;
loop++;
}
if (n % 2 == 1) { // n 为奇数时，单独处理矩阵中心的值
nums[startX][startY] = count;
}
return nums;
}
}
扫一扫
1098
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
