【详解】使用Java解决：将一个数按原有规律插入已排序数组

public class InsertIntoSortedArray {

    /**
     * 将一个数插入到已排序的数组中，并保持数组的有序性。
     * 
     * @param arr 已排序的数组
     * @param num 待插入的数
     * @return 插入后的数组
     */
    public static int[] insert(int[] arr, int num) {
        // 创建一个新的数组，长度比原数组多1
        int[] newArr = new int[arr.length + 1];
        
        // 找到插入位置
        int insertPos = 0;
        while (insertPos < arr.length && arr[insertPos] < num) {
            insertPos++;
        }
        
        // 将插入位置之前的元素复制到新数组
        System.arraycopy(arr, 0, newArr, 0, insertPos);
        
        // 插入新元素
        newArr[insertPos] = num;
        
        // 将插入位置之后的元素复制到新数组
        System.arraycopy(arr, insertPos, newArr, insertPos + 1, arr.length - insertPos);
        
        return newArr;
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9};
        int num = 4;
        
        int[] result = insert(arr, num);
        
        // 输出结果
        for (int i : result) {
            System.out.print(i + " ");
        }
    }
}

import java.util.Arrays;

public class SortedArrayInsertion {
    public static void main(String[] args) {
        // 已排序的数组
        int[] sortedArray = {1, 3, 4, 10, 12};
        
        // 要插入的数
        int numberToInsert = 7;
        
        // 插入后的数组
        int[] resultArray = insertIntoSortedArray(sortedArray, numberToInsert);
        
        // 输出结果
        System.out.println("原始数组: " + Arrays.toString(sortedArray));
        System.out.println("插入后数组: " + Arrays.toString(resultArray));
    }

    /**
     * 将一个数插入到已排序的数组中，并保持数组有序。
     * 
     * @param sortedArray 已排序的数组
     * @param numberToInsert 要插入的数
     * @return 插入后的数组
     */
    public static int[] insertIntoSortedArray(int[] sortedArray, int numberToInsert) {
        // 创建一个新的数组，长度比原数组多1
        int[] resultArray = new int[sortedArray.length + 1];
        
        // 遍历原数组，找到插入位置
        int i;
        for (i = 0; i < sortedArray.length; i++) {
            if (numberToInsert <= sortedArray[i]) {
                break;
            }
        }
        
        // 将原数组的前i个元素复制到新数组
        System.arraycopy(sortedArray, 0, resultArray, 0, i);
        
        // 插入新元素
        resultArray[i] = numberToInsert;
        
        // 将原数组剩余的元素复制到新数组
        System.arraycopy(sortedArray, i, resultArray, i + 1, sortedArray.length - i);
        
        return resultArray;
    }
}

int[] sortedArray = {1, 3, 4, 10, 12};
int numberToInsert = 7;

int[] resultArray = insertIntoSortedArray(sortedArray, numberToInsert);

System.out.println("原始数组: " + Arrays.toString(sortedArray));
System.out.println("插入后数组: " + Arrays.toString(resultArray));

原始数组: [1, 3, 4, 10, 12]
插入后数组: [1, 3, 4, 7, 10, 12]

public class InsertIntoSortedArray {
    public static void main(String[] args) {
        // 已经排序的数组
        int[] sortedArray = {1, 3, 4, 10, 15};
        // 要插入的元素
        int elementToInsert = 7;

        // 插入元素
        int[] resultArray = insertIntoSortedArray(sortedArray, elementToInsert);

        // 打印结果数组
        for (int num : resultArray) {
            System.out.print(num + " ");
        }
    }

    public static int[] insertIntoSortedArray(int[] array, int element) {
        // 创建一个新的数组，长度比原数组多1
        int[] newArray = new int[array.length + 1];

        // 遍历原数组，找到插入位置
        int i;
        for (i = 0; i < array.length; i++) {
            if (element < array[i]) {
                break;
            }
        }

        // 将新元素插入到找到的位置
        newArray[i] = element;

        // 将原数组的前i个元素复制到新数组
        System.arraycopy(array, 0, newArray, 0, i);

        // 将原数组的剩余部分复制到新数组
        System.arraycopy(array, i, newArray, i + 1, array.length - i);

        return newArray;
    }
}