java，插入删除，返回下标

我想在一个数组中用二分法插入删除数，如果存在，返回下标，不存在就返回插入该数后，该数的下标，我想看看我哪里错了，麻烦大家帮忙改正，指点一下


package homework;
import java.util.Scanner;

public class Work21list {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("你想插入数还是删除数，1  or  0");
        int c=sc.nextInt();
        System.out.println("什么数");
        int n=sc.nextInt();
        if(c==1) {
            System.out.println(insert(find(n)));
        }
        else if(c==0)
            System.out.println(delete((find(n))));    
        else
            System.out.println("请输入0或1");    
    }
    
    
    public static int insert(int n) {
        if(n>=0) {//不存在
            return n;
        }else {//存在
            return -1;
        }
    }
    

    public static int delete(int n) {
        int d=-n;
        int[] arr=bub();
        if(d>0) {//存在
            int[] list=new int[arr.length-1] ;
            for(int j=0;j<arr.length-1;j++) {
                if(j<d) {
                    list[j]=arr[j];
                }else
                 list[j]=arr[j+1];
            }
                return d+1;
        }else //不存在
            return -1;
    }
    
    
    
    public static int[] bub() {
        int[] arr=new int[] {34,76,23, 67, 345, 234, 21, 78, 172, 90};
        for(int j=0;j<arr.length-1;j++) {
            for(int n=0;n<arr.length-1-j;n++) {
                if(arr[n]>arr[n+1]) {
                    int s=arr[n+1];
                    arr[n+1]=arr[n];
                    arr[n]=s;
                }    
            }
        }
        return arr;
    }
    
    
    
    public static int find(int target)     {
        int[] arr=bub();
        int left=0;
        int right=arr.length-1;
        while(left<=right) {
            int mid=(left+right)/2;
            if(arr[mid]>target) {
                right=mid-1;
            }if(arr[mid]<target) {
                left=mid+1;
            }if(arr[mid]==target) {
                return -mid-1;
            }//是否存在该元素
        }
        //如果不存在
        if(target<arr[0])
            return 0;
        if(target>arr[arr.length-1])
            return arr.length;
        while(right-1!=left) {
            int mid=(left+right)/2;
            if(arr[mid]>target) {
                right=mid+1;
            }if(arr[mid]<target) {
                left=mid-1;
            }
        }    
        return right;
    }
}

bub()返回的数据是有序的么？
调试下。

原数组为21,23.....但我输入22会返回0，不知道为什么

这个问题的回答你可以参考下: https://ask.csdn.net/questions/7682771
这篇博客你也可以参考下：Java：给定一个二位数组，随机初始化数组，并以矩阵形式输出，找到数组中最大值与最小值，分别输出最大最小值的行列下标
除此之外, 这篇博客: Java编程题目-1：约瑟夫环问题中的总结：感觉这道题目不太好想的就是数组循环用的下标移动问题，如何控制，怎么控制是关键。上面我写的代码感觉条件控制得并不好，往后改改再看看吧。部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
**
您还可以看一下翟东平老师的支付宝小程序3/3阶段_支付宝支付JAVA版课程中的 1.[免费]支付宝小程序支付_开篇小节, 巩固相关知识点

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

我能够给出以下解决方案：

实现数组的二分法插入操作：

public static int binaryInsert(int[] arr, int num) {
    int left = 0;
    int right = arr.length - 1;
    int mid;
    while (left <= right) {
        mid = (left + right) / 2;
        if (arr[mid] < num) {
            left = mid + 1;
        } else if (arr[mid] > num) {
            right = mid - 1;
        } else {
            return mid; // 如果存在对应的数，返回该数的下标
        }
    }
    // 如果不存在对应的数，返回插入该数后的下标
    int insertIndex = left;
    for (int i = arr.length - 1; i >= left; i--) {
        arr[i] = arr[i - 1];
    }
    arr[insertIndex] = num;
    return insertIndex;
}

该方法可以接收一个已经排好序的整型数组和一个新的整数，通过二分法查找该整数在数组中的位置并实现插入操作。

实现数组的二分法删除操作：

public static int binaryDelete(int[] arr, int num) {
    int left = 0;
    int right = arr.length - 1;
    int mid;
    while (left <= right) {
        mid = (left + right) / 2;
        if (arr[mid] < num) {
            left = mid + 1;
        } else if (arr[mid] > num) {
            right = mid - 1;
        } else {
            for (int i = mid; i < arr.length - 1; i++) {
                arr[i] = arr[i + 1];
            }
            arr[arr.length - 1] = 0; // 数组长度减1，并将最后一位赋值为0
            return mid;
        }
    }
    return -1; // 如果未找到要删除的元素，则返回-1
}

该方法可以接收一个已经排好序的整型数组和一个要删除的整数，通过二分法查找该整数在数组中的位置并从数组中删除。

关于数组排序：

Java中可以使用Arrays类提供的sort方法进行排序。具体代码如下所示：

Arrays.sort(arr); // 排序

关于数组求交集和并集：

Java中可以使用哈希表（HashMap）来求两个数组的交集和并集。具体代码如下所示：

public static void intersection(int[] arr1, int[] arr2) {
    HashMap<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < arr1.length; i++) {
        map.put(arr1[i], i);
    }
    for (int j = 0; j < arr2.length; j++) {
        if (map.containsKey(arr2[j])) {
            System.out.println(arr2[j]);
        }
    }
}

public static void union(int[] arr1, int[] arr2) {
    HashMap<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < arr1.length; i++) {
        map.put(arr1[i], i);
        System.out.print(arr1[i] + " ");
    }
    for (int j = 0; j < arr2.length; j++) {
        if (!map.containsKey(arr2[j])) {
            System.out.print(arr2[j] + " ");
        }
    }
}

关于数组中只出现一次的元素：

可以使用异或运算符来实现。具体代码如下所示：

public static int singleNum(int[] arr) {
    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        sum=sum^arr[i];
    }
    return sum;
}

public static void main(String args[]){
    int[] arr= new int[]{1,2,3,4,5,6,2,3,4,5,6,1,0};
    System.out.println(singleNum(arr));
}

其中使用了异或运算符（^），通过将所有元素都异或一遍来找到只出现一次的元素。如果数组中除了某一个元素以外，其他的元素都出现了两次，那么对所有元素进行异或操作的结果就是那个只出现了一次的元素。