写代码题时遇到的问题

Question

我在做代码题时根据我的思路有一步要去掉数组最中间的元素，但自己写的代码出现问题，检查时相关代码处删去后输出的新数组有的是正确的，有的又是错误的，求求帮忙看看是为什么

public static int result(int[] re){
        int num1=0;
        int[] mid=new int[8];
        //get new array
        for(int i=0;i<8;i++){
            if(i<4){
                mid[i]=re[i];
            }
            else if(i>4){
                mid[i]=re[i+1];
            }
            System.out.print(mid[i]+" ");//can
        }
        System.out.println();//can
        int pur=re[4];
        System.out.println("目标cell:"+pur);//can
        //get the number of 1 and 0
        for(int j=0;j<8;j++){
            if(mid[j]==1){
                num1++;//on
            }
        }
        //change the element
        if(pur==0){//dead cell
            if(num1<2||num1>5){
                pur=1;
            }
        }
        else if(pur==1){//live cell
            if(num1<3){
                pur=0;
            }
            else if(num1>=3||num1<=6){
                pur=1;
            }
            else if(num1>6){
                pur=0;
            }
        } 
        System.out.println("LIVE CELL:"+num1);//CAN
        return pur;    
    }

输出：
0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0

0 0 0 1 0 1 0 0 0
0 0 0 1 0 0 0 0
就像这两组，第一组是理想的结果
第二组却不是
不太明白是这部分的问题还是其他部分的问题
完整代码如下：

import java.util.Scanner;
public class A2_CellularAutomaton2 {
    //get a new array
    public static int[][] get_result(int[][] arr,int m,int n,int s){
        int[] re=new int[9];
        int[][] middle =new int[m][n];
        for(int v=0;v<s;v++){
        for(int i =0;i<m;i++){ 
            for(int j=0;j<n;j++){
                //to get a new array
                //for corner
                if(i==0&j==0){
                  int[] a={0,0,0};
                  int[] b={0,arr[0][0],arr[0][1]};
                  int[] c={0,arr[1][0],arr[1][1]};
                  for(int k=0;k<9;k++){
                    if(k<3){
                        re[k]=a[k];
                    }
                    else if(k>=3&k<6){
                        re[k]=b[k-3];
                    }
                    else{
                        re[k]=c[k-6];
                    }
                  }                  
                }
                else if(i==0&j==n-1){
                  int[] a={0,0,0};
                  int[] b={arr[0][n-2],arr[0][n-1],0};
                  int[] c={arr[1][n-2],arr[1][n-1],0};
                  for(int k=0;k<9;k++){
                    if(k<3){
                        re[k]=a[k];
                    }
                    else if(k>=3&k<6){
                        re[k]=b[k-3];
                    }
                    else{
                        re[k]=c[k-6];
                    }
                  }                
                }
                else if(i==m-1&j==0){
                  int[] a={0,arr[m-2][0],arr[m-2][1]};
                  int[] b={0,arr[m-1][0],arr[m-1][1]};
                  int[] c={0,0,0};
                  for(int k=0;k<9;k++){
                    if(k<3){
                        re[k]=a[k];
                    }
                    else if(k>=3&k<6){
                        re[k]=b[k-3];
                    }
                    else{
                        re[k]=c[k-6];
                    }
                  }                
                }
                else if(i==m-1&j==n-1){
                  int[] a={arr[m-2][n-2],arr[m-2][n-1],0};
                  int[] b={arr[m-1][n-2],arr[m-1][n-1],0};
                  int[] c={0,0,0};
                  for(int k=0;k<9;k++){
                    if(k<3){
                        re[k]=a[k];
                    }
                    else if(k>=3&k<6){
                        re[k]=b[k-3];
                    }
                    else{
                        re[k]=c[k-6];
                    }
                  }                
                }//for margin
                else if(i==0&j>0&j<n-1){
                  int[] a={0,0,0};
                  int[] b={arr[i][j-1],arr[i][j],arr[i][j+1]};
                  int[] c={arr[i+1][j-1],arr[i+1][j],arr[i+1][j+1]};
                  for(int k=0;k<9;k++){
                    if(k<3){
                        re[k]=a[k];
                    }
                    else if(k>=3&k<6){
                        re[k]=b[k-3];
                    }
                    else{
                        re[k]=c[k-6];
                    }
                  }
                }
                else if(i==m-1&j>0&j<n-1){
                  int[] a={arr[i-1][j-1],arr[i-1][j],arr[i-1][j+1]};
                  int[] b={arr[i][j-1],arr[i][j],arr[i][j+1]};
                  int[] c={0,0,0};
                  for(int k=0;k<9;k++){
                    if(k<3){
                        re[k]=a[k];
                    }
                    else if(k>=3&k<6){
                        re[k]=b[k-3];
                    }
                    else{
                        re[k]=c[k-6];
                    }
                  }
                }
                else if(j==n-1&i>0&i<m-1){
                  int[] a={arr[i-1][j-1],arr[i-1][j],0};
                  int[] b={arr[i][j-1],arr[i][j],0};
                  int[] c={arr[i+1][j-1],arr[i+1][j],0};
                  for(int k=0;k<9;k++){
                    if(k<3){
                        re[k]=a[k];
                    }
                    else if(k>=3&k<6){
                        re[k]=b[k-3];
                    }
                    else{
                        re[k]=c[k-6];
                    }
                  }
                }
                else if(j==0&i>0&i<m-1){
                  int[] a={0,arr[i-1][j],arr[i-1][j+1]};
                  int[] b={0,arr[i][j],arr[i][j+1]};
                  int[] c={0,arr[i+1][j],arr[i+1][j+1]};
                  for(int k=0;k<9;k++){
                    if(k<3){
                        re[k]=a[k];
                    }
                    else if(k>=3&k<6){
                        re[k]=b[k-3];
                    }
                    else{
                        re[k]=c[k-6];
                    }
                  }
                }//for content
                else if(i>0&i<m-1&j>0&j<n-1){
                  int[] a={arr[i-1][j-1],arr[i-1][j],arr[i-1][j+1]};
                  int[] b={arr[i][j-1],arr[i][j],arr[i][j+1]};
                  int[] c={arr[i+1][j-1],arr[i+1][j],arr[i+1][j+1]};
                  for(int k=0;k<9;k++){
                    if(k<3){
                        re[k]=a[k];
                    }
                    else if(k>=3&k<6){
                        re[k]=b[k-3];
                    }
                    else{
                        re[k]=c[k-6];
                    }
                  }
                }
                //can be deleted
                for(int g =0;g<9;g++){
                    System.out.print(re[g]+" ");//can
                }
                System.out.println();//can
                middle[i][j]=result(re);
                System.out.println("value"+result(re));
            }
        }
    }

    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            arr[i][j]=middle[i][j];
        }
    }
        return arr;

    }

    //to deal with the array
    public static int result(int[] re){
        int num1=0;
        int[] mid=new int[8];
        //get new array
        for(int i=0;i<8;i++){
            if(i<4){
                mid[i]=re[i];
            }
            else if(i>4){
                mid[i]=re[i+1];
            }
            System.out.print(mid[i]+" ");//can
        }
        System.out.println();//can
        int pur=re[4];
        System.out.println("目标cell:"+pur);//can
        //get the number of 1 and 0
        for(int j=0;j<8;j++){
            if(mid[j]==1){
                num1++;//on
            }
        }
        //change the element
        if(pur==0){//dead cell
            if(num1<2||num1>5){
                pur=1;
            }
        }
        else if(pur==1){//live cell
            if(num1<3){
                pur=0;
            }
            else if(num1>=3||num1<=6){
                pur=1;
            }
            else if(num1>6){
                pur=0;
            }
        } 
        System.out.println("LIVE CELL:"+num1);//CAN
        return pur;    
    }
    public static void main(String[] args) {
        // read the datas
        Scanner input = new Scanner(System.in);
        // m&n
        int m = input.nextInt();
        int n = input.nextInt();
        //System.out.println(m + " " + n);
        // get square
        int[][] arr = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = input.nextInt();
            }
        }
        
        // get s steps
        int s = input.nextInt();
        //System.out.println(s);
        //output
        int[][] final_re =get_result(arr, m, n, s);
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(j<n-1){
                    System.out.print(final_re[i][j]+" ");
                }
                else{
                    System.out.print(final_re[i][j]);
                }
            }
            System.out.println();
        }

    }
}

Answer 1

• 这个问题的回答你可以参考下: https://ask.csdn.net/questions/1064306
• 除此之外, 这篇博客: 树的遍历操作详解-附代码中的 我们以下面的这个二叉树结构为例，分别描述一下这几种遍历的方式有什么不同 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• 
  对于一棵二叉树，我们知道它会有左节点，右节点和根节点。无论我们使用哪种遍历，左节点一定会比右节点先访问，而区别前序，后序和中序的方法就是看何时遍历根节点，也就是根节点，左节点，右节点的顺序。

  1. 前序遍历：如果根节点在左节点前面遍历，也就是说遍历顺序为：根节点->左节点->右节点。对于上面那棵树，前序遍历结果为：ABDHIECFJG
  2. 中序遍历：如果根节点在左节点之后，右节点之前遍历，也就是遍历顺序为：左节点->根节点->右节点。对于上面那棵树，中序遍历得到的结果为：HDIBEAFJCG
  3. 后序遍历：如果根节点在右节点之后遍历，也就是遍历顺序为左节点->右节点->根节点。对于上面那棵树，后序遍历的结果为：HIDEBJFGCA
  4. 广度优先遍历(BFS)：对于广度优先遍历，我们把树分层，根节点为第一层，根节点的子节点为第二层，第二层的子节点为第三层，依次递推。例如上面的树，第一层为A，第二层为BC，第三层为DEFG，第四层为HIJ。遍历的时候就对每一层从左到右进行依次访问。例如上面那棵树广度优先遍历得到的结果为：ABCDEFGHIJ
  5. 深度优先遍历(DFS)：深度优先遍历就是从一棵树的根节点开始，一直访问左子节点，一直到为空，然后再向上依次返回访问右子节点(如果右节点不为空，我们就继续对右节点进行深度优先遍历)。例如上面那棵树深度优先遍历得到的结果就是：ABDHIECFJG

  详细算法思路以及源代码见另一篇博客：树的遍历详细算法–C++

• 以下回答由chatgpt基于相关博客总结生成:

  我使用的编程语言有很多，常见的有C++，Java，Python等。在删除数组中间元素的过程中，我通常使用的方法是将要删除的元素后面的元素全部往前移动一位，然后将数组长度减1。以下是C++中删除数组中间元素的代码片段：

  int arr[] = {1,2,3,4,5};
  int len = sizeof(arr) / sizeof(int);
  int index = 2; //要删除的元素的下标
  for(int i = index; i < len - 1; i++){
      arr[i] = arr[i+1]; //元素向前移动一位
  }
  len--; //数组长度减1
  

  在输出结果错误的情况下可能出现的原因有很多，比如数组长度不一致，数组下标越界，计算错误等。因此我们需要认真检查代码，尽可能地避免这些问题的出现。