用Java写一个二分排序

二分排序是一种高效的排序算法，可以在较短的时间内对大量数据进行排序。以下是用 Java 实现二分排序的代码：

public static void binarySort(int[] arr) {
    int len = arr.length;
    for (int i = 1; i < len; i++) {
        int left = ;
        int right = i - 1;
        int temp = arr[i];
        int j = i - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (arr[mid] > temp) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        while (j >= left) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[left] = temp;
    }
}

这个算法的时间复杂度为 O(nlogn)，可以在大部分情况下快速排序。

相关问题

用Java写一个二分排序法

以下是Java实现二分排序法的示例代码：

public class BinarySort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 3, 1, 6, 9, 4, 7};
        binarySort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void binarySort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int left = 0;
            int right = i - 1;
            while (left <= right) {
                int mid = (left + right) / 2;
                if (temp < arr[mid]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            }
            for (int j = i - 1; j >= left; j--) {
                arr[j + 1] = arr[j];
            }
            arr[left] = temp;
        }
    }
}

在此示例中，我们通过调用`binarySort()`方法来对数组进行排序。该方法使用了二分查找算法，首先使用`for`循环遍历数组中的每个元素（除去第一个元素），并将该元素存储在`temp`变量中。然后，使用`while`循环执行二分查找，查找到应该插入`temp`的位置，并将该位置存储在`left`变量中。最后，使用`for`循环将`temp`插入到正确的位置。

用java写一个二分查找排序代码

### 回答1：
下面是一个Java的二分查找排序代码实现：

public class BinarySearch {

    public static int binarySearch(int[] arr, int key) {
        int low = 0;
        int high = arr.length - 1;

        while (low <= high) {
            int mid = (low + high) / 2;

            if (arr[mid] == key) {
                return mid;
            } else if (arr[mid] < key) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }

        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {2, 5, 7, 8, 10, 12};
        int key = 8;

        int index = binarySearch(arr, key);

        if (index == -1) {
            System.out.println("元素未找到！");
        } else {
            System.out.println("元素在数组中的位置为：" + index);
        }
    }
}

这里 `binarySearch` 方法实现了二分查找算法，它接受一个已经排好序的数组 `arr` 和要查找的关键字 `key` 作为参数。函数返回关键字在数组中的索引位置，如果未找到则返回 -1。

在 `main` 函数中，我们定义了一个数组 `arr` 和一个要查找的关键字 `key`，然后调用 `binarySearch` 方法来查找关键字在数组中的位置。如果找到了，就输出它在数组中的位置，否则输出 "元素未找到！"。

### 回答2：
二分查找（Binary Search）也叫折半查找，是一种高效的查找算法。它的前提是待查找的集合必须是有序的。下面是用Java写一个二分查找排序的代码示例：

public class BinarySearch {
    // 二分查找算法
    public static int binarySearch(int[] array, int target) {
        int low = 0;
        int high = array.length - 1;

        while (low <= high) {
            int mid = (low + high) / 2;
            if (array[mid] == target) {
                return mid; // 找到目标元素，返回索引
            } else if (array[mid] < target) {
                low = mid + 1; // 目标元素在右半部分，更新low
            } else {
                high = mid - 1; // 目标元素在左半部分，更新high
            }
        }

        return -1; // 未找到目标元素，返回-1
    }

    public static void main(String[] args) {
        int[] array = { 1, 3, 5, 7, 9, 11 }; // 有序数组

        int target = 7; // 目标元素
        int index = binarySearch(array, target);
        if (index != -1) {
            System.out.println("目标元素" + target + "在数组中的索引为" + index);
        } else {
            System.out.println("目标元素" + target + "未在数组中找到");
        }
    }
}

以上代码定义了一个名为`BinarySearch`的类，其中包含了一个静态方法`binarySearch`来实现二分查找算法。在`main`方法中，创建了一个有序数组`array`，并指定要查找的目标元素为7。通过调用`binarySearch`方法，返回目标元素在数组中的索引。最后根据返回的索引结果输出查找结果。

以上就是一个用Java实现二分查找算法的例子，通过该算法可以高效地查找有序数组中的元素。

### 回答3：
二分查找（Binary Search）是一种查找算法，思路是将有序数组分成两部分，通过每次查找中间元素与目标值比较的方式来不断缩小查找范围，最终找到目标值或确定其不存在。

以下是用Java编写的二分查找排序代码：

public class BinarySearch {
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        
        while (left <= right) {
            int mid = (left + right) / 2;
            
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        return -1;
    }
    
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        int target = 4;
        
        int index = binarySearch(arr, target);
        
        if (index != -1) {
            System.out.println("目标值 " + target + " 的索引为 " + index);
        } else {
            System.out.println("目标值 " + target + " 不存在于数组中");
        }
    }
}

在上述代码中，binarySearch方法使用了迭代的方式来实现二分查找。初始时，left指向数组的第一个元素，right指向数组的最后一个元素。通过计算中间元素的索引mid，将查找范围不断缩小。如果中间元素等于目标值，则返回该元素的索引；如果中间元素小于目标值，则在右侧继续查找；如果中间元素大于目标值，则在左侧继续查找。重复这个过程直到找到目标值或确定其不存在。

在主方法中，创建了一个有序数组arr和目标值target，并调用binarySearch方法来查找目标值在数组中的索引。如果返回的索引不为-1，则表示目标值存在于数组中，打印输出目标值和其对应的索引；否则，表示目标值不存在于数组中，打印输出该信息。

以上就是用Java实现二分查找排序的代码。该算法的时间复杂度为O(log n)，其中n为数组的长度。