数组遍历 学习笔记

已于 2024-08-21 15:10:50 修改
阅读量215 收藏
点赞数
分类专栏： 基础知识 算法题 文章标签： java 算法 数据结构
于 2023-04-23 13:08:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37646636/article/details/130318990
版权
文章探讨了数组中下标的意义，如获取信息、元素计数和配对关系。还涉及了数组遍历的不同方式，包括正序、逆序以及特定模式的遍历。此外，提到了动态规划中的回文子串判断和数组折叠概念，展示了多种遍历和操作数组的编程实例。
摘要由CSDN通过智能技术生成

目录

基础逻辑

[Q&A] 下标为5可以获取到什么信息？ 

1 2 3 4 5 6 7 8 9 10
0 1 2 3 4 5 6 7 8 9
          ·
1・下标为5
2・当前为第6号元素
3・前面有5个元素
4・后面有4个元素（10-6）
5・倒数第5

[Q&A] 下标4到下标7有几个元素? 

1 2 3 4 5 6 7 8 9 10
0 1 2 3 4 5 6 7 8 9

0-1-2-3-4
0-1-2-3-4-5-6-7

1・下标为7比下标为4 多3 (7-4)个元素
2・下标为4到下标为7 有4 (7-4+1)个元素
3・subString(3,7).length() 长度为7-3

[Q&A] 数组折叠对应下标相加为 length-1 ( i 和 arr.length-1-i 是前后遥相呼应的两个位置)

# 数组折叠 对应下标相加为 length-1
# i 和 arr.length-1-i 是前后遥相呼应的两个位置

a  b  c  b  a  		a  b  c  c  b  a
0  1  2  3  4  		0  1  2  3  4  5
0+4=4				0+5=5
1+3=4				1+4=5
2+2=4				2+3=5

[Q&A] 区间[0,arr.length/2) 为数组左一半 

区间[0,arr.length/2) 为数组左一半
abcba  ☞ 长度为奇数时 arr.length()/2 ☞ 5/2=2 ☞ [0 1] ② 3 4
abccba ☞ 长度为偶数时 arr.length()/2 ☞ 6/2=3 ☞ [0 1 2] ③ 4 5

使用场景
NC17 最长回文子串
Java 业务原子级常用方法 ☞ 判断子串是不是回文子串

数组遍历

【一维数据】遍历 X2

int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

# 正序
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}
1 2 3 4 5 6 7 8 9 

# 逆序
for (int i = arr.length - 1; i >= 0; i--) {
    System.out.print(arr[i] + " ");
}
9 8 7 6 5 4 3 2 1

【数组遍历】这个行为被重复执行 X4

int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

// 控制[数组遍历]这个行为被重复执行次数--正序逆序不重要
for (int i = 0; i < arr.length; i++) {
// for (int i = arr.length - 1; i >= 0; i--) {
    
    // 数组正序遍历的行为
    for (int j = 0; j < arr.length; j++) {
        System.out.print(arr[j] + "  ");
    }
    
    System.out.print("←分水岭→  ");
    
    // 数组逆序遍历的行为
    for (int k = arr.length - 1; k >= 0; k--) {
        System.out.print(arr[k] + "  ");
    }
    System.out.println();
}

1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  

1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1

【数组元素】被重复执行 X4

int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

// 数组元素排队轮回的顺序--正序 or 逆序
for (int i = 0; i < arr.length; i++) {
// for (int i = arr.length - 1; i >= 0; i--) {

    // 控制[数组元素]被重复执行次数--正序逆序不重要
    for (int j = 0; j < arr.length; j++) {
        System.out.print(arr[i] + "  ");
    }
    
    System.out.print("←分水岭→  ");
    
    // 控制[数组元素]被重复执行次数--正序逆序不重要
    for (int k = arr.length - 1; k >= 0; k--) {
        System.out.print(arr[i] + "  ");
    }
    System.out.println();
}

1  1  1  1  1  1  1  1  1  ←分水岭→  1  1  1  1  1  1  1  1  1
2  2  2  2  2  2  2  2  2  ←分水岭→  2  2  2  2  2  2  2  2  2
3  3  3  3  3  3  3  3  3  ←分水岭→  3  3  3  3  3  3  3  3  3
4  4  4  4  4  4  4  4  4  ←分水岭→  4  4  4  4  4  4  4  4  4
5  5  5  5  5  5  5  5  5  ←分水岭→  5  5  5  5  5  5  5  5  5
6  6  6  6  6  6  6  6  6  ←分水岭→  6  6  6  6  6  6  6  6  6
7  7  7  7  7  7  7  7  7  ←分水岭→  7  7  7  7  7  7  7  7  7
8  8  8  8  8  8  8  8  8  ←分水岭→  8  8  8  8  8  8  8  8  8
9  9  9  9  9  9  9  9  9  ←分水岭→  9  9  9  9  9  9  9  9  9

9  9  9  9  9  9  9  9  9  ←分水岭→  9  9  9  9  9  9  9  9  9
8  8  8  8  8  8  8  8  8  ←分水岭→  8  8  8  8  8  8  8  8  8
7  7  7  7  7  7  7  7  7  ←分水岭→  7  7  7  7  7  7  7  7  7
6  6  6  6  6  6  6  6  6  ←分水岭→  6  6  6  6  6  6  6  6  6
5  5  5  5  5  5  5  5  5  ←分水岭→  5  5  5  5  5  5  5  5  5
4  4  4  4  4  4  4  4  4  ←分水岭→  4  4  4  4  4  4  4  4  4
3  3  3  3  3  3  3  3  3  ←分水岭→  3  3  3  3  3  3  3  3  3
2  2  2  2  2  2  2  2  2  ←分水岭→  2  2  2  2  2  2  2  2  2
1  1  1  1  1  1  1  1  1  ←分水岭→  1  1  1  1  1  1  1  1  1

【外左内左回放的思想】X8 ☞ 动态规划里总结出来的

int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

for (int i = 0; i < arr.length; i++) {
    // 从0回放到i
    // for (int j = 0; j <= i; j++) {
    
    // 从i回退到0
    // for (int j = i; j >= 0; j--) {
    
    // 从i快进到arr.length-1
    // for (int j = i; j < arr.length; j++) {
    
    // 从arr.length-1回退到i
    for (int j = arr.length - 1; j >= i; j--) {
        System.out.print(arr[j] + "  ");
    }
    System.out.println();
}

1                          ←分水岭→  1                          ←分水岭→  1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1
1  2                       ←分水岭→  2  1                       ←分水岭→  2  3  4  5  6  7  8  9     ←分水岭→  9  8  7  6  5  4  3  2   
1  2  3                    ←分水岭→  3  2  1                    ←分水岭→  3  4  5  6  7  8  9        ←分水岭→  9  8  7  6  5  4  3      
1  2  3  4                 ←分水岭→  4  3  2  1                 ←分水岭→  4  5  6  7  8  9           ←分水岭→  9  8  7  6  5  4         
1  2  3  4  5              ←分水岭→  5  4  3  2  1              ←分水岭→  5  6  7  8  9              ←分水岭→  9  8  7  6  5            
1  2  3  4  5  6           ←分水岭→  6  5  4  3  2  1           ←分水岭→  6  7  8  9                 ←分水岭→  9  8  7  6               
1  2  3  4  5  6  7        ←分水岭→  7  6  5  4  3  2  1        ←分水岭→  7  8  9                    ←分水岭→  9  8  7                  
1  2  3  4  5  6  7  8     ←分水岭→  8  7  6  5  4  3  2  1     ←分水岭→  8  9                       ←分水岭→  9  8                     
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  ←分水岭→  9                          ←分水岭→  9                                              

----------------------------------------------------------------------------------------------------
int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int i = 0; i < arr.length; i++) {
    // 位置i处元素遍历i次，正序，逆序无所谓
    // for (int j = 0; j <= i; j++) {
    // for (int j = i; j >= 0; j--) {
    
    // 位置i处元素遍历arr.length-i次，正序逆序无所谓
    // for (int j = i; j < arr.length; j++) {
    for (int j = arr.length - 1; j >= i; j--) {
        System.out.print(arr[i] + "  ");
    }
    System.out.println();
}

1                          ←分水岭→  1                          ←分水岭→  1  1  1  1  1  1  1  1  1  ←分水岭→  1  1  1  1  1  1  1  1  1
2  2                       ←分水岭→  2  2                       ←分水岭→  2  2  2  2  2  2  2  2     ←分水岭→  2  2  2  2  2  2  2  2   
3  3  3                    ←分水岭→  3  3  3                    ←分水岭→  3  3  3  3  3  3  3        ←分水岭→  3  3  3  3  3  3  3      
4  4  4  4                 ←分水岭→  4  4  4  4                 ←分水岭→  4  4  4  4  4  4           ←分水岭→  4  4  4  4  4  4         
5  5  5  5  5              ←分水岭→  5  5  5  5  5              ←分水岭→  5  5  5  5  5              ←分水岭→  5  5  5  5  5            
6  6  6  6  6  6           ←分水岭→  6  6  6  6  6  6           ←分水岭→  6  6  6  6                 ←分水岭→  6  6  6  6               
7  7  7  7  7  7  7        ←分水岭→  7  7  7  7  7  7  7        ←分水岭→  7  7  7                    ←分水岭→  7  7  7                  
8  8  8  8  8  8  8  8     ←分水岭→  8  8  8  8  8  8  8  8     ←分水岭→  8  8                       ←分水岭→  8  8                     
9  9  9  9  9  9  9  9  9  ←分水岭→  9  9  9  9  9  9  9  9  9  ←分水岭→  9                          ←分水岭→  9

【外左内右回放的思想】X8

int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

for (int i = 0; i < arr.length; i++) {
    // 逐级降低目标
    for (int j = 0; j <= arr.length - 1 - i; j++) {
    // 逐级降低目标 ☞ 基于右边界的思想
    // for (int j = 0; j < arr.length - i; j++) {
        str += arr[j] + "  ";
    }
    
    // 从arr.length-1回退到i (相同功能)
    for (int j = arr.length - 1 - i; j >= 0; j--) {
        str += arr[j] + "  ";
    }
    
    // 降低成本，观察是否还能达到预期目标
    for (int j = arr.length - 1 - i; j < arr.length; j++) {
        str += arr[j] + "  ";
    }
    
    // 资本对品质的反向蚕食
    for (int j = arr.length - 1; j >= arr.length - 1 - i; j--) {
        str += arr[j] + "  ";
    }
}
    
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  ←分水岭→  9                          ←分水岭→  9                         
1  2  3  4  5  6  7  8     ←分水岭→  8  7  6  5  4  3  2  1     ←分水岭→  8  9                       ←分水岭→  9  8                      
1  2  3  4  5  6  7        ←分水岭→  7  6  5  4  3  2  1        ←分水岭→  7  8  9                    ←分水岭→  9  8  7                   
1  2  3  4  5  6           ←分水岭→  6  5  4  3  2  1           ←分水岭→  6  7  8  9                 ←分水岭→  9  8  7  6                
1  2  3  4  5              ←分水岭→  5  4  3  2  1              ←分水岭→  5  6  7  8  9              ←分水岭→  9  8  7  6  5             
1  2  3  4                 ←分水岭→  4  3  2  1                 ←分水岭→  4  5  6  7  8  9           ←分水岭→  9  8  7  6  5  4          
1  2  3                    ←分水岭→  3  2  1                    ←分水岭→  3  4  5  6  7  8  9        ←分水岭→  9  8  7  6  5  4  3       
1  2                       ←分水岭→  2  1                       ←分水岭→  2  3  4  5  6  7  8  9     ←分水岭→  9  8  7  6  5  4  3  2    
1                          ←分水岭→  1                          ←分水岭→  1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1 


----------------------------------------------------------------------------------------------------
int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

for (int i = 0; i < arr.length; i++) {
    // 元素遍历其[下标的对折位置的下标]的次数，正序逆序无所谓
    for (int j = 0; j <= arr.length - 1 - i; j++) {
        str += arr[i] + "  ";
    }
    // 元素遍历其[下标的对折位置的下标]的次数，正序逆序无所谓
    for (int j = arr.length - 1 - i; j >= 0; j--) {
        str += arr[i] + "  ";
    }
    // 元素遍历其下标的次数，正序逆序无所谓
    for (int j = arr.length - 1 - i; j < arr.length; j++) {
        str += arr[i] + "  ";
    }
    // 元素遍历其下标的次数，正序逆序无所谓
    for (int j = arr.length - 1; j >= arr.length - 1 - i; j--) {
        str += arr[i] + "  ";
    }
}

1  1  1  1  1  1  1  1  1  ←分水岭→  1  1  1  1  1  1  1  1  1  ←分水岭→  1                          ←分水岭→  1                        
2  2  2  2  2  2  2  2     ←分水岭→  2  2  2  2  2  2  2  2     ←分水岭→  2  2                       ←分水岭→  2  2                     
3  3  3  3  3  3  3        ←分水岭→  3  3  3  3  3  3  3        ←分水岭→  3  3  3                    ←分水岭→  3  3  3                  
4  4  4  4  4  4           ←分水岭→  4  4  4  4  4  4           ←分水岭→  4  4  4  4                 ←分水岭→  4  4  4  4               
5  5  5  5  5              ←分水岭→  5  5  5  5  5              ←分水岭→  5  5  5  5  5              ←分水岭→  5  5  5  5  5            
6  6  6  6                 ←分水岭→  6  6  6  6                 ←分水岭→  6  6  6  6  6  6           ←分水岭→  6  6  6  6  6  6         
7  7  7                    ←分水岭→  7  7  7                    ←分水岭→  7  7  7  7  7  7  7        ←分水岭→  7  7  7  7  7  7  7      
8  8                       ←分水岭→  8  8                       ←分水岭→  8  8  8  8  8  8  8  8     ←分水岭→  8  8  8  8  8  8  8  8   
9                          ←分水岭→  9                          ←分水岭→  9  9  9  9  9  9  9  9  9  ←分水岭→  9  9  9  9  9  9  9  9  9

【外右内左回放的思想】X8

int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

for (int i = arr.length - 1; i >= 0; i--) {
    for (int j = 0; j <= arr.length - 1 - i; j++) {
        str += arr[j] + "  ";
    }
    for (int j = arr.length - 1 - i; j >= 0; j--) {
        str += arr[j] + "  ";
    }
    for (int j = arr.length - 1 - i; j < arr.length; j++) {
        str += arr[j] + "  ";
    }
    for (int j = arr.length - 1; j >= arr.length - 1 - i; j--) {
        str += arr[j] + "  ";
    }
}


1                          ←分水岭→  1                          ←分水岭→  1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  
1  2                       ←分水岭→  2  1                       ←分水岭→  2  3  4  5  6  7  8  9     ←分水岭→  9  8  7  6  5  4  3  2     
1  2  3                    ←分水岭→  3  2  1                    ←分水岭→  3  4  5  6  7  8  9        ←分水岭→  9  8  7  6  5  4  3        
1  2  3  4                 ←分水岭→  4  3  2  1                 ←分水岭→  4  5  6  7  8  9           ←分水岭→  9  8  7  6  5  4           
1  2  3  4  5              ←分水岭→  5  4  3  2  1              ←分水岭→  5  6  7  8  9              ←分水岭→  9  8  7  6  5              
1  2  3  4  5  6           ←分水岭→  6  5  4  3  2  1           ←分水岭→  6  7  8  9                 ←分水岭→  9  8  7  6                 
1  2  3  4  5  6  7        ←分水岭→  7  6  5  4  3  2  1        ←分水岭→  7  8  9                    ←分水岭→  9  8  7                    
1  2  3  4  5  6  7  8     ←分水岭→  8  7  6  5  4  3  2  1     ←分水岭→  8  9                       ←分水岭→  9  8                       
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  ←分水岭→  9                          ←分水岭→  9                          

----------------------------------------------------------------------------------------------------
int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};

for (int i = arr.length - 1; i >= 0; i--) {
    // 元素遍历其[下标的对折位置的下标]的次数，正序逆序无所谓
    for (int j = 0; j <= arr.length - 1 - i; j++) {
        str += arr[i] + "  ";
    }
    // 元素遍历其[下标的对折位置的下标]的次数，正序逆序无所谓
    for (int j = arr.length - 1 - i; j >= 0; j--) {
        str += arr[i] + "  ";
    }
    // 元素遍历其下标的次数，正序逆序无所谓
    for (int j = arr.length - 1 - i; j < arr.length; j++) {
        str += arr[i] + "  ";
    }
    // 元素遍历其下标的次数，正序逆序无所谓
    for (int j = arr.length - 1; j >= arr.length - 1 - i; j--) {
        str += arr[i] + "  ";
    }
}


9                          ←分水岭→  9                          ←分水岭→  9  9  9  9  9  9  9  9  9  ←分水岭→  9  9  9  9  9  9  9  9  9
8  8                       ←分水岭→  8  8                       ←分水岭→  8  8  8  8  8  8  8  8     ←分水岭→  8  8  8  8  8  8  8  8   
7  7  7                    ←分水岭→  7  7  7                    ←分水岭→  7  7  7  7  7  7  7        ←分水岭→  7  7  7  7  7  7  7      
6  6  6  6                 ←分水岭→  6  6  6  6                 ←分水岭→  6  6  6  6  6  6           ←分水岭→  6  6  6  6  6  6         
5  5  5  5  5              ←分水岭→  5  5  5  5  5              ←分水岭→  5  5  5  5  5              ←分水岭→  5  5  5  5  5            
4  4  4  4  4  4           ←分水岭→  4  4  4  4  4  4           ←分水岭→  4  4  4  4                 ←分水岭→  4  4  4  4               
3  3  3  3  3  3  3        ←分水岭→  3  3  3  3  3  3  3        ←分水岭→  3  3  3                    ←分水岭→  3  3  3                  
2  2  2  2  2  2  2  2     ←分水岭→  2  2  2  2  2  2  2  2     ←分水岭→  2  2                       ←分水岭→  2  2                     
1  1  1  1  1  1  1  1  1  ←分水岭→  1  1  1  1  1  1  1  1  1  ←分水岭→  1                          ←分水岭→  1

【外右内右回放的思想】X8

int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int i = arr.length - 1; i >= 0; i--) {
    for (int j = 0; j <= i; j++) {
        str += arr[j] + "  ";
    }
    for (int j = i; j >= 0; j--) {
        str += arr[j] + "  ";
    }
    for (int j = i; j < arr.length; j++) {
        str += arr[j] + "  ";
    }
    for (int j = arr.length - 1; j >= i; j--) {
        str += arr[j] + "  ";
    }
}
1  2  3  4  5  6  7  8  9  ←分水岭→  9  8  7  6  5  4  3  2  1  9                          9                          
1  2  3  4  5  6  7  8     ←分水岭→  8  7  6  5  4  3  2  1     8  9                       9  8                       
1  2  3  4  5  6  7        ←分水岭→  7  6  5  4  3  2  1        7  8  9                    9  8  7                    
1  2  3  4  5  6           ←分水岭→  6  5  4  3  2  1           6  7  8  9                 9  8  7  6                 
1  2  3  4  5              ←分水岭→  5  4  3  2  1              5  6  7  8  9              9  8  7  6  5              
1  2  3  4                 ←分水岭→  4  3  2  1                 4  5  6  7  8  9           9  8  7  6  5  4           
1  2  3                    ←分水岭→  3  2  1                    3  4  5  6  7  8  9        9  8  7  6  5  4  3        
1  2                       ←分水岭→  2  1                       2  3  4  5  6  7  8  9     9  8  7  6  5  4  3  2     
1                          ←分水岭→  1                          1  2  3  4  5  6  7  8  9  9  8  7  6  5  4  3  2  1  

----------------------------------------------------------------------------------------------------
int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int i = arr.length - 1; i >= 0; i--) {
    for (int j = 0; j <= i; j++) {
        str += arr[i] + "  ";
    }
    for (int j = i; j >= 0; j--) {
        str += arr[i] + "  ";
    }
    for (int j = i; j < arr.length; j++) {
        str += arr[i] + "  ";
    }
    for (int j = arr.length - 1; j >= i; j--) {
        str += arr[i] + "  ";
    }
}
9  9  9  9  9  9  9  9  9  ←分水岭→  9  9  9  9  9  9  9  9  9  9                          9                          
8  8  8  8  8  8  8  8     ←分水岭→  8  8  8  8  8  8  8  8     8  8                       8  8                       
7  7  7  7  7  7  7        ←分水岭→  7  7  7  7  7  7  7        7  7  7                    7  7  7                    
6  6  6  6  6  6           ←分水岭→  6  6  6  6  6  6           6  6  6  6                 6  6  6  6                 
5  5  5  5  5              ←分水岭→  5  5  5  5  5              5  5  5  5  5              5  5  5  5  5              
4  4  4  4                 ←分水岭→  4  4  4  4                 4  4  4  4  4  4           4  4  4  4  4  4           
3  3  3                    ←分水岭→  3  3  3                    3  3  3  3  3  3  3        3  3  3  3  3  3  3        
2  2                       ←分水岭→  2  2                       2  2  2  2  2  2  2  2     2  2  2  2  2  2  2  2     
1                          ←分水岭→  1                          1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1

【for (int i = 0; i <= arr.length - 7; i++) 】

int[] arr 

// 考勤迟到
if (arr.length <= 7) {
    return Arrays.stream(arr).sum() > 3;
} else {
    for (int i = 0; i <= arr.length - 7; i++) {
        int[] ints = Arrays.copyOfRange(arr, i, i + 7); // 任意7天
        int sum = Arrays.stream(ints).sum();
        if (sum > 3) {
            return true; // 存在有问题数据就直接终止判断并返回
        }
    }
}

// 滑动窗口
for (int i = 0; i <= nums.length - k; i++) {
    int[] ints = Arrays.copyOfRange(nums, i, i + k);
    Arrays.stream(ints).max().ifPresent(res::add);
}

【 for (int i = 0; i < str.length(); )】

// 字符串8位一截取
List<String> res = new ArrayList<>();
for (int i = 0; i < str.length(); ) {
    if (i + 8 < str.length()) {
        String substring = str.substring(i, i + 8);
        res.add(substring);
        i = i + 8;
    } else {
        String substring = str.substring(i);
        res.add(substring);
        i = i + 8;
    }
}

数组 【范围截取】

int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr.length; j++) {
        str += arr[i] + "  ";
    }
}
for (int i = 1; i < arr.length; i++) {
    String str1 = "";
    for (int j = 1; j < arr.length; j++) {
        str1 += arr[i] + "  ";
    }
}
for (int i = arr.length - 1; i < arr.length; i++) {
    for (int j = arr.length - 1; j < arr.length; j++) {
        str1 += arr[j] + "  ";
    }
}

1  1  1  1  1  1  1  1  1
2  2  2  2  2  2  2  2  2
3  3  3  3  3  3  3  3  3
4  4  4  4  4  4  4  4  4
5  5  5  5  5  5  5  5  5
6  6  6  6  6  6  6  6  6
7  7  7  7  7  7  7  7  7
8  8  8  8  8  8  8  8  8
9  9  9  9  9  9  9  9  9

   2  2  2  2  2  2  2  2
   3  3  3  3  3  3  3  3
   4  4  4  4  4  4  4  4
   5  5  5  5  5  5  5  5
   6  6  6  6  6  6  6  6
   7  7  7  7  7  7  7  7
   8  8  8  8  8  8  8  8
   9  9  9  9  9  9  9  9
   
                        9

参考

数组遍历 ☞ 第1波学习总结
数组遍历 ☞ 第2波学习总结
数组遍历 ☞ 第3波学习总结

张紫娃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA刷Leecode-玩转双指针-Two Sum
水鱼的博客
03-28 167
JAVA刷Leecode-玩转双指针算法思想内容分类Two Sum- 两数之和 II - 输入有序数组（167，easy)题目描述输入输出样例示例1示例2解题思路：题解资源学习 算法思想 双指针一般用来遍历数组，两指针指向不同的元素，从而沟通协调完成任务；也可以延伸到多数组多指针。 大致分为两种情况： 两指针指向同一数组，遍历方向相同且不相交，又称为**滑动窗口**，经常用于区间搜索； 两指针指向同一数组，但遍历方向相反，可以用来进行搜索，待搜索的数组往往是排序好的 内容分类 Two Sum（167）
LeetCode解题（3）Java实现单链表双指针遍历
key_768的博客
02-18 365
题目 面试题 02.02. 返回倒数第 k 个节点 实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。 注意：本题相对原题稍作改动 示例： 输入： 1->2->3->4->5 和 k = 2 输出： 4 说明： 给定的 n 保证是有效的。 解题 class Solution { public int kthToLast(ListNode head, i...
【LeetCode】数组系列-双指针
weixin_51368761的博客
11-15 886
双指针的一些例题
两个指针实现数组遍历_两遍两遍指针有什么区别
weixin_26717681的博客
08-15 405
两个指针实现数组遍历The two-pointer technique is commonly used to optimize solutions to string, array, or linked-list coding problems. In naive solutions, searching for a set of elements in one of those data st...
双指针方法
Hello World!
08-03 1785
如果左指针left 指向的元素等于val，此时将右指针right 指向的元素复制到左指针left 的位置，然后右指针 right 左移一位。如果赋值过来的元素恰好也等于val，可以继续把右指针right 指向的元素的值赋值过来（左指针left 指向的等于val 的元素的位置继续被覆盖），直到左指针指向的元素的值不等于val 为止。根据快慢法则，走的快的一定会追上走得慢的。对于字符串，我们定义两个指针（也可以说是索引下标），一个从字符串前面，一个从字符串后面，两个指针同时向中间移动，并交换元素。.......
php学习笔记 数组遍历实现代码
01-20
* (索引数组下标可以不连续,数组还有关联数组,这两种不能遍历) * * 2.使用foreach语句循环遍历数组 * foreacho(数组变量 as 变量值){ * //循环体 * } * 1.循环次数由数组的元素个数决定 * 2.每一次循环都会将数组中...
Javascript学习笔记之数组的遍历和 length 属性
01-21
尽管数组在 Javascript 中是对象，但是不建议使用 for in 循环来遍历数组，实际上，有很多理由来阻止我们对数组使用 for in 循环。 因为 for in 循环将会枚举原型链上的所有属性，并且唯一阻止的方法是使用 ...
linux shell 中数组的定义和for循环遍历的方法
01-20
今天突然被问到数组怎么去遍历。平时写shell脚本也经常遍历数组，但是一下没答上来，被鄙视了。 所以平时学习还是好好总结吧，不能每次都问度娘谷爷。IT 知识体系较为庞大，细节的东西也太多，平时遇到问题应该的多...
算法——双指针
热门推荐
雪月清的博客
11-18 1万+
双指针的简单介绍及四种常用解题模型
神奇的算法：双指针
我爱小小怪的博客
11-30 267
​ 双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。也可以延伸到多个数组的多个指针。​ 若两个指针指向同一数组，遍历方向相同且不会相交，则也称为滑动窗口（两个指针包围的 区域即为当前的窗口），经常用于区间搜索。​ 若两个指针指向同一数组，但是遍历方向相反，则可以用来进行搜索，待搜索的数组往往是排好序的。如：翻转数组、二分搜索。
双指针（Two Pointers）用法精讲及解题案例
最新发布
白话机器学习
06-03 3537
双指针（Two Pointers）：指的是在遍历元素的过程中，不是使用单个指针进行访问，而是使用两个指针进行访问，从而达到相应的目的。如果两个指针方向相反，则称为「对撞指针」。如果两个指针方向相同，则称为「快慢指针」。如果两个指针分别属于不同的数组 / 链表，则称为「分离双指针」。在数组的区间问题上，暴力算法的时间复杂度往往是 $O(n^2)$。而双指针利用了区间「单调性」的性质，可以将时间复杂度降到 $O(n)$。双指针分为「对撞指针」、「快慢指针」、「分离双指针」。对撞指针：两个指针方向相反。
双指针遍历（解决有序数组的问题）
菜到不敢run
09-22 910
1. 平方数字的个数（排序数组） 问题描述 排序数组，平方后，数组当中有多少不同的数字（相同算一个）。 思路 这里是排序数组，既然有重复，肯定是有负数，0,1这些数字。平方后两头大，中间小，可以用首尾指针共同向中间扫描 ，扫描时去掉重复元素，同时用一个sum来记录有多少个不同数字。 代码 func sortSquare(nums []int) int { var sum int left, right := 0, len(nums) - 1 for left <= right { if n
基础算法-双指针算法
每天进步一点点！
11-23 2991
双指针算法
双指针算法
FraNny13的博客
10-11 2211
双指针算法
JAVA 双指针法(快慢指针法)
ls199848的博客
02-13 955
双指针的巧妙用法
Leetcode-双指针遍历/滑动窗口
qq_49723651的博客
01-20 627
文章目录q3无重复字符的最长子串q11盛最多水的容器q15三数之和q16最接近的三数之和q26 删除有序数组中的重复项q42 接雨水q121买卖股票的最佳时机q209长度最小的子数组 q3无重复字符的最长子串 题目传送门 题解 使用滑动窗口求解，设置左右指针来确定窗口的边界，其中右指针就是循环变量的位置。窗口的变化取决于当前遍历到的字符之前有没有出现过，如果出现过，那么左指针移动到字符上一个位置+1。 func lengthOfLongestSubstring(s string) (ret int)
双指针法---将序列双层遍历问题优化为单层
Sakura_lht
01-31 481
1. 双指针算法介绍 1.1 什么是双指针法 狭义上的双指针法是指利用两个指针去遍历序列（通常为数组或字符串），一个放首，一个放尾，同时向中间遍历，直到两个指针碰撞，完成遍历。 0 1 2 3 4 5 6 i --> <-- j [x x x x x x x] i j [i = 0, j = 6] i j [i = 1, j = 6] i j
【算法基础——第七讲】双指针
m0_63233163的博客
05-05 700
大家好，我是quicklysleep，欢迎大家光临我的博客,算法学习笔记系列持续更新中~ 文章目录一、前言二、双指针算法的介绍三、双指针算法的运用1.最长连续不重复子序列最长连续子序列3.归并排序模板最后 一、前言 双指针说是一种算法,其实就是一个降低时间复杂度的技巧,双指针法充分使用了数组有序这一特征，从而在某些情况下能够简化一些运算,熟练的运用双指针算法,可以快速简洁的解决问题. 二、双指针算法的介绍 双指针指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个相同方向（快慢.
[算法基础] 双指针遍历/滑动窗口-三数之和
whitsats的博客
06-05 386
题目 给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 示例： 给定数组 nums = [-1, 0, 1, 2, -1, -4]， 满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ] 解题思路 方法一 暴力求解 由题干可知，我们需要寻找的是三个数，那就使用三重循环嵌套最为直观 /** * @param {nu
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值