按排序順序將元素插入數組

Question

我正在嘗試按排序順序將元素添加到數組中。

這是我的代碼：

public class SortedInsertion {

    public static void main(String[] args) {

        int[] arr=new int[6];
        arr[0]=5;
        arr[1]=6;
        arr[2]=9;
        arr[3]=11;
        System.out.println(Arrays.toString(arr));
        insert(7,arr);


    }

    public static void insert(int val,int[] arr){
        int i;
        for(i=0;i<arr.length-1;i++){

            if(arr[i]>val)
                break;
        }
        for(int k=i;k<arr.length-1;k++){
            arr[k+1]=arr[k];
            arr[i]=val;
        }
        System.out.println(Arrays.toString(arr));


    }

}

我得到的輸出為：[5, 6, 9, 11, 0, 0]

[5, 6, 7, 9, 9, 9]

但正確的輸出是

5,6,9,11,0,0

5,6,7,9,11,0

Answer 1

您的for循環中存在問題

for(i=0;i<arr.length-1;i++){}

它應該迭代到i<arr.length

for(i=0;i<arr.length;i++){}

Answer 2

這里

arr[k+1]=arr[k];

您正在使用先前的值覆蓋每個下一個數組元素。 您可能應該反轉循環並從數組的末尾移動，將所有元素向前移動，直到找到正確的位置，即：

public static void insert(int val, int[] arr) {
    for(int i = arr.length - 1; i > 0; i--) {
        if (arr[i] == 0) continue; // skip last elements to avoid array index out of bound
        arr[i + 1] = arr[i];       // shift elements forward
        if (arr[i] <= val) {       // if we found the right spot
            arr[i] = val;          // place the new element and
            break;                 // break out the loop
        }
    }
    System.out.println(Arrays.toString(arr));
}

Answer 3

像這樣更改insert方法：

    public static void insert(int val,int[] arr){
      int i;
      for(i=0;i<arr.length-1;i++){
        if(arr[i]>val)
          break;
      }
      for(int k=arr.length-2; k>=i; k--){
        arr[k+1]=arr[k];            
      }
      arr[i]=val;
      System.out.println(Arrays.toString(arr));

    }

Answer 4

public class InsertInSortedArray {
        public static void main(String[] args) {
            int arr[] = {5, 6, 9, 11};
            Arrays.sort(arr);
            int k = 7;
            int index = findIndexToBeInserted(arr, k, 0, arr.length - 1);
            ArrayList<Integer> al = new ArrayList<>();
            for (int i : arr)
                al.add(i);

            al.add(index, k);
            for (int i : al)
                System.out.println(i);
        }

    private static int findIndexToBeInserted(int[] arr, int k, int start, int end) {
            if (k == 0)
                return 0;

            int mid = (start + end) / 2;

            if (k > arr[mid] && k < arr[mid + 1])
                return mid + 1;

            if (arr[mid] < k)
                return findIndexToBeInserted(arr, k, mid + 1, end);

            return findIndexToBeInserted(arr, k, start, mid - 1);
        }
    }

Answer 5

另一種解決方法是使用 List 和 collections.sort 方法。

List<Integer> list = new ArrayList<Integer>(); 
  for (int i = 0; i < arr.length; i++) { 
  list.add(arr[i]); 
  } 
  list.add(val);

  Collections.sort(list);

 int[] result = list.stream().mapToInt(Integer::intValue).toArray();
 System.out.println(Arrays.toString(result));

希望這個解決方案有幫助。

Answer 6

Java代碼，

public static void insertElementInSortedArr(int a[], int val) {

        int n[] = new int[a.length + 1];
        int j = 0;
        boolean isAdded = false;
        for (int i = 0; i < a.length; i++) {
            if (a[i] < val) {
                n[j] = a[i];
                j++;
            } else {
                if (!isAdded) {
                    n[j] = val;
                    j = j + 1;
                    isAdded = true;
                }
                n[j] = a[i];
                j = j + 1;
            }
        }
    }

Answer 7

老實說，有問題的數組實際上並不是這樣排序的： [0, 0, 5, 6, 9, 11] 。
它是一個“零尾”數組： [5, 6, 9, 11, 0, 0] 。
因此，要將一個值插入到該數組中，它需要知道所占用的元素數量。 如果您將此值提供給一個方法，它將具有 O(log n) 復雜度。 否則，需要在插入方法內部實現計數。

/**
* @throws ArrayIndexOutOfBoundsException when the array is full and the value to be inserted is greater than the last element
*/
private static void insertToZeroTailedArray(int val, int[] arr) {
    // an O(n) operation to count occupied elements
    int elementsCount = 0;
    for (int i = arr.length - 1; i >= 0; i--) {
        if (arr[i] != 0) {
            elementsCount = i + 1;
            break;
        }
    }

    // binarySearch returns a negative position to insert if the value was not found
    int index = Arrays.binarySearch(arr, 0, elementsCount, val);
    if (index != 0) {
        int pos = index < 0
                ? -index - 1 // val not found, it is need to be inserted at (-index)-1 position
                : index;     // val found but we are going to insert it again

        // shift the array to right and drop last element because of the array bounds
        System.arraycopy(arr, pos, arr, pos + 1, arr.length - pos - 1);
        arr[pos] = val;
    } else {
        // the case when value is found at 0 position
        System.arraycopy(arr, 0, arr, 1, arr.length - 1);
        arr[0] = val;
    }
}

對於真正排序的數組，使用 O(log n) 復雜度執行所需操作的另一種方法：

private static void insertToReallySortedArray(int val, int[] arr) {
    int index = Arrays.binarySearch(arr, val);
    if (index != 0) {
        int pos = index < 0 ? -index - 1 : index;
        System.arraycopy(arr, pos, arr, pos + 1, arr.length - pos - 1);
        arr[pos] = val;
    } else {
        System.arraycopy(arr, 0, arr, 1, arr.length - 1);
        arr[0] = val;
    }
}

基於這個很好的答案。

Answer 8

在不知道已經占用的字段數的情況下，完全不清楚插入函數應該如何工作？

public static void insert( int n, int occupied, int[] array ) {
  if( n >= array[occupied - 1] )
    array[occupied] = n;
  else
    for( int i = 0; i < array.length; i++ ) {
      int n1 = array[i];
      int n2 = array[i + 1];
      if( n1 > n || n1 < n && n2 >= n ) {
        if( n1 > n ) i--;
        System.arraycopy( array, i + 1, array, i + 2, occupied - i - 1 );
        array[i + 1] = n;
        break;
      }
    }
}

從上面的示例中調用：

…
arr[3]=11;
int occupied = 4;
insert( 7, occupied, arr );  // [5, 6, 7, 9, 11, 0]

如果occupied >= array.length則使用ArrayIndexOutOfBoundsException未經檢查的胸圍

Answer 9

您可以使用 Arrays 或 Collections binarySearch 函數來獲取插入新值的位置，您需要將所有元素從此位置（如果有）向右移動

int position = Math.abs(Collections.binarySearch(sortedList, key)) - 1;

Answer 10

您可以使用 arrays.sort() 功能將值插入到新數組中，然后對其進行排序。 它以一種迂回的方式解決了這個問題。 例如

    int num = 10;
    int array[] = {6, 7, 8};
    int copy_array[] = new int[array.length + 1];
    for (int i = 0; i < array.length; i++) {
        copy_array[i] = array[i];
    }
    copy_array[copy_array.length - 1] = given_number;
    Arrays.sort(copy_array);