有一个有序的数组，想要将一个元素插入到该数组中，
还要保证该数组是有序的。如何获取该元素在数组中的位置

class chazhao
{
        public static void main(String[] args)
        {
                int[] arr = {3,2,1,5,4,2,9};
                int index = getIndex(arr,2);
                System.out.println("index="+index);
        }
                public static int getIndex(int[] arr,int key)
        {
                for(int x=0; x<arr.length; x++)
                {
                        if(arr[x]==key)
                                return x;
                }
                return -1;
        }


}
就是在上代码的数组中查找,你要找的元素，找到了你要告诉他在数组中的位置，假如要找的元素是2，遍历这个元素，如果找的元素和这个key相等，就是说找到了，那就输出这个数x，否则也就是没找到，输出-1.

要是我的话，会用这个数从第一个数开始比较大小，当这个数比前面一个数大，比后面一个数小，那么它的位置就定了。不知道能不能帮你，希望有点帮助。

有序的数组的话,定义两个数组a[],b[],数组b比数组a长度要多1,用来打印插入数据后的数组
先接收这个插入的数
用循环跟a[]数组的元素值进行比较
循环里写个if语句,当插入的数小于或者等于a[i]的时候,跳出,否则把a[i]的值赋值给b数组同样位置的元素
再把插入的数据放到b数组里,进行个冒泡排序就好了.

//要在一个有序的数组中插入一个数，插入完成后保持数组的有序
public class ZheBan {
        public static void main(String[] args) {
                int[] arr = {1,3,5,8,10,15,46};
               
                System.out.println(getIndex(arr, 10));
        }
        /*
         * 折半排序
         */
        public static int getIndex(int[] arr,int key){
                int max = arr.length-1,min = 0,mid;
                while (min <= max) {
                        mid = (min + max) / 2;
                        if (key > arr[mid]) {
                                min = mid + 1;
                        }else if (key < arr[mid]) {
                                max = mid -1;
                        }else{
                                return mid;
                        }
                }
                return min;
        }
}

看代码 不明白问我！！！！！！！

老毕的视频有讲啊在数组的折半排序中就有这个，你去看下就行了

你得说是整型数组呢还是字符型数组哈？要是我，我会存入数组，一个冒泡排序；想要找某个元素的话，直接遍历数组，看哪个元素跟指定元素相同就输出其角标；o了

毕老师第4天视频，折半查找里面有讲。

我也看到过  看视频后自己多敲代码

视频中就有讲解的，折半排序，获取的min值即是

过来看看

火车上睡不着

这个我是真的不知道不知道

折半遍历数组，返回最小值就是要插入元素的位置

折半查找，

去看老毕的视频吧

/*练习插入一个数进一个数组，并保证数组有序*/
public class HalfSeach
{
        public static int halfSeach(int[] n,int key)
        {
                int min=0,max=n.length-1,mid;
                mid=(min+max)>>1;
                while(n[mid]!=key)
                {
                        if(key>n[mid])
                        min=mid+1;
                        else if(key<n[mid]) max=mid-1;
                        mid=(min+max)>>1;
                        while(min>max) return -1;
                } return mid;
        }
       
        public static int halfSeach2(int[] n,int key)
        {
                int min=0,max=n.length-1;
                int mid=(min+max)>>1;
                while(min<=max)
                {        if(key>n[mid]) min=mid+1;
                        else if(key<n[mid]) max=mid-1;
                        else return mid;    //这里的mid'包含数组只有一个数和插入的数和数组中的数相同的情况，这里就是插入的下标值；
                        mid=(min+max)>>1;     
                } return -1;               //这里将-1改为min值，就是插入数的下标值。
        }
        /*public static void inserNumber(int[] n,int inserNum)   java中数组不可扩容，要通过collection来做ArrayList.
        {       
                int min=0,max=n.length-1,mid;
                mid=(min+max)/2;
                while(min==max)
                {
                        if(inserNum>n[mid]) min=mid+1;
                        else if(inserNum<n[mid]) max=mid-1;
                       
                        mid=(min+max)>>1;
                        break;
                }int x=n.length+1;
                if(n[mid]>inserNum) {for(int i=x;i>mid;i--) {n[i]=n[i-1];n[mid]=inserNum;}}
                else if(n[mid]<=inserNum) {for(int i=n.length;i>mid+2;i--){n[i]=n[i-1];n[mid+1]=inserNum;}}
        }*/
        public static void printArray(int[] n)
        {        System.out.print("[");
                for(int i=0;i<n.length;i++)
                {        if(i!=n.length-1)
                        System.out.print(n[i]+", ");
                        else System.out.print(n[i]);
                } System.out.println("]");
        }
        public static void main(String[] args)
        {
                int[] n={1,3,4,5,7,9,12,23,45,67,90,123};       
                System.out.println(halfSeach2(n,23));
                System.out.println(halfSeach2(n,231));
                inserNumber(n,10);
                printArray(n);
               
        }
}

可以考虑二分法～节省时间，效率也高

给数组排序你应该会吧，可以把他当做数组里面的元素进行排序啊，找到大于和小于他最接近的俩个值，取大于他那个数的索引值就可以了