用二分法查找（折半查找）java

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。

创新互联主营尼泸西网站建设的网络公司,主营网站建设方案,手机APP定制开发,尼泸西h5成都微信小程序搭建,尼泸西网站营销推广欢迎尼泸西等地区企业咨询

二分查找优缺点

优点是比较次数少，查找速度快，平均性能好；

其缺点是要求待查表为有序表，且插入删除困难。

因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

使用条件：查找序列是顺序结构，有序。

过程

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

利用循环的方式实现二分法查找

public class BinarySearch {

public static void main(String[] args) {

// 生成一个随机数组        int[] array = suiji();

// 对随机数组排序        Arrays.sort(array);

System.out.println("产生的随机数组为： " + Arrays.toString(array));

System.out.println("要进行查找的值： ");

Scanner input = new Scanner(System.in);

// 进行查找的目标值        int aim = input.nextInt();

// 使用二分法查找        int index = binarySearch(array, aim);

System.out.println("查找的值的索引位置： " + index);

}

/**     * 生成一个随机数组     *

* @return 返回值，返回一个随机数组     */

private static int[] suiji() {

// random.nextInt(n)+m  返回m到m+n-1之间的随机数        int n = new Random().nextInt(6) + 5;

int[] array = new int[n];

// 循环遍历为数组赋值        for (int i = 0; i array.length; i++) {

array[i] = new Random().nextInt(100);

}

return array;

}

/**     * 二分法查找  ---循环的方式实现     *

* @param array 要查找的数组     * @param aim 要查找的值     * @return 返回值，成功返回索引，失败返回-1     */

private static int binarySearch(int[] array, int aim) {

// 数组最小索引值        int left = 0;

// 数组最大索引值        int right = array.length - 1;

int mid;

while (left = right) {

mid = (left + right) / 2;

// 若查找数值比中间值小，则以整个查找范围的前半部分作为新的查找范围            if (aim array[mid]) {

right = mid - 1;

// 若查找数值比中间值大，则以整个查找范围的后半部分作为新的查找范围            } else if (aim array[mid]) {

left = mid + 1;

// 若查找数据与中间元素值正好相等，则放回中间元素值的索引   } else {

return mid;

}

}

return -1;

}}

运行结果演示：

由以上运行结果我们得知，如果要查找的数据在数组中存在，则输出该数据在数组中的索引；如果不存在则输出 -1 ，也就是打印 -1 则该数在数组中不存在，反之则存在。

四、利用递归的方式实现二分法查找

public class BinarySearch2 {

public static void main(String[] args) {

// 生成一个随机数组        int[] array = suiji();

// 对随机数组排序        Arrays.sort(array);

System.out.println("产生的随机数组为： " + Arrays.toString(array));

System.out.println("要进行查找的值： ");

Scanner input = new Scanner(System.in);

// 进行查找的目标值        int aim = input.nextInt();

// 使用二分法查找        int index = binarySearch(array, aim, 0, array.length - 1);

System.out.println("查找的值的索引位置： " + index);

}

/**     * 生成一个随机数组     *     * @return 返回值，返回一个随机数组     */

private static int[] suiji() {

// Random.nextInt(n)+m  返回m到m+n-1之间的随机数        int n = new Random().nextInt(6) + 5;

int[] array = new int[n];

// 循环遍历为数组赋值        for (int i = 0; i array.length; i++) {

array[i] = new Random().nextInt(100);

}

return array;

}

/**     * 二分法查找 ---递归的方式     *     * @param array 要查找的数组     * @param aim   要查找的值     * @param left  左边最小值     * @param right 右边最大值     * @return 返回值，成功返回索引，失败返回-1     */

private static int binarySearch(int[] array, int aim, int left, int right) {

if (aim array[left] || aim array[right]) {

return -1;

}

// 找中间值        int mid = (left + right) / 2;

if (array[mid] == aim) {

return mid;

} else if (array[mid] aim) {

//如果中间值大于要找的值则从左边一半继续递归            return binarySearch(array, aim, left, mid - 1);

} else {

//如果中间值小于要找的值则从右边一半继续递归            return binarySearch(array, aim, mid + 1, array.length-1);

}

}}

运行结果演示：

总结：

递归相较于循环，代码比较简洁，但是时间和空间消耗比较大，效率低。在实际的学习与工作中，根据情况选择使用。通常我们如果使用循环实现代码只要不是太繁琐都选择循环的方式实现~

Java几种简单的排序源代码

给你介绍4种排序方法及源码，供参考

1.冒泡排序

主要思路： 从前往后依次交换两个相邻的元素，大的交换到后面，这样每次大的数据就到后面，每一次遍历，最大的数据到达最后面，时间复杂度是O(n^2)。

public static void bubbleSort(int[] arr){

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

for(int j=0; j  arr.length-1; j++){

if(arr[j]  arr[j+1]){

arr[j] = arr[j]^arr[j+1];

arr[j+1] = arr[j]^arr[j+1];

arr[j] = arr[j]^arr[j+1];

}

}

}

}

2.选择排序

主要思路：每次遍历序列，从中选取最小的元素放到最前面，n次选择后，前面就都是最小元素的排列了，时间复杂度是O(n^2）。

public static void selectSort(int[] arr){

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

for(int j = i+1; j  arr.length; j++){

if(arr[j]  arr[i]){

arr[j] = arr[j]^arr[i];

arr[i] = arr[j]^arr[i];

arr[j] = arr[j]^arr[i];

}

}

}

}

3.插入排序

主要思路：使用了两层嵌套循环，逐个处理待排序的记录。每个记录与前面已经排好序的记录序列进行比较，并将其插入到合适的位置，时间复杂度是O(n^2）。

public static void insertionSort(int[] arr){

int j;

for(int p = 1; p  arr.length; p++){

int temp = arr[p];   //保存要插入的数据

//将无序中的数和前面有序的数据相比，将比它大的数，向后移动

for(j=p; j0  temp arr[j-1]; j--){

arr[j] = arr[j-1];

}

//正确的位置设置成保存的数据

arr[j] = temp;

}

}

4.希尔排序

主要思路：用步长分组，每个分组进行插入排序，再慢慢减小步长，当步长为1的时候完成一次插入排序，  希尔排序的时间复杂度是：O（nlogn）～O（n2），平均时间复杂度大致是O(n^1.5)

public static void shellSort(int[] arr){

int j ;

for(int gap = arr.length/2; gap  0 ; gap/=2){

for(int i = gap; i  arr.length; i++){

int temp = arr[i];

for(j = i; j=gap  temparr[j-gap]; j-=gap){

arr[j] = arr[j-gap];

}

arr[j] = temp;

}

}

}

请给出java几种排序方法

java常见的排序分为：

1 插入类排序

主要就是对于一个已经有序的序列中，插入一个新的记录。它包括：直接插入排序，折半插入排序和希尔排序

2 交换类排序

这类排序的核心就是每次比较都要“交换”，在每一趟排序都会两两发生一系列的“交换”排序，但是每一趟排序都会让一个记录排序到它的最终位置上。它包括：起泡排序，快速排序

3 选择类排序

每一趟排序都从一系列数据中选择一个最大或最小的记录，将它放置到第一个或最后一个为位置交换，只有在选择后才交换，比起交换类排序，减少了交换记录的时间。属于它的排序：简单选择排序，堆排序

4 归并类排序

将两个或两个以上的有序序列合并成一个新的序列

5 基数排序

主要基于多个关键字排序的。

下面针对上面所述的算法，讲解一些常用的java代码写的算法

二 插入类排序之直接插入排序

直接插入排序,一般对于已经有序的队列排序效果好。

基本思想：每趟将一个待排序的关键字按照大小插入到已经排序好的位置上。

算法思路，从后往前先找到要插入的位置，如果小于则就交换，将元素向后移动，将要插入数据插入该位置即可。时间复杂度为O(n2),空间复杂度为O(1)

package sort.algorithm;

public class DirectInsertSort {

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };

int temp, j;

for (int i = 1; i data.length; i++) {

temp = data[i];

j = i - 1;

// 每次比较都是对于已经有序的

while (j = 0 data[j] temp) {

data[j + 1] = data[j];

j--;

}

data[j + 1] = temp;

}

// 输出排序好的数据

for (int k = 0; k data.length; k++) {

System.out.print(data[k] + " ");

}

}

}

三 插入类排序之折半插入排序(二分法排序)

条件：在一个已经有序的队列中，插入一个新的元素

折半插入排序记录的比较次数与初始序列无关

思想：折半插入就是首先将队列中取最小位置low和最大位置high，然后算出中间位置mid

将中间位置mid与待插入的数据data进行比较，

如果mid大于data，则就表示插入的数据在mid的左边，high=mid-1;

如果mid小于data，则就表示插入的数据在mid的右边,low=mid+1

最后整体进行右移操作。

时间复杂度O(n2),空间复杂度O(1)

package sort.algorithm;

//折半插入排序

public class HalfInsertSort {

public static void main(String[] args) {

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };

// 存放临时要插入的元素数据

int temp;

int low, mid, high;

for (int i = 1; i data.length; i++) {

temp = data[i];

// 在待插入排序的序号之前进行折半插入

low = 0;

high = i - 1;

while (low = high) {

mid = (low + high) / 2;

if (temp data[mid])

high = mid - 1;

else

// low=high的时候也就是找到了要插入的位置，

// 此时进入循环中，将low加1，则就是要插入的位置了

low = mid + 1;

}

// 找到了要插入的位置，从该位置一直到插入数据的位置之间数据向后移动

for (int j = i; j = low + 1; j--)

data[j] = data[j - 1];

// low已经代表了要插入的位置了

data[low] = temp;

}

for (int k = 0; k data.length; k++) {

System.out.print(data[k] + " ");

}

}

}

四 插入类排序之希尔排序

希尔排序，也叫缩小增量排序，目的就是尽可能的减少交换次数，每一个组内最后都是有序的。

将待续按照某一种规则分为几个子序列，不断缩小规则，最后用一个直接插入排序合成

空间复杂度为O(1)，时间复杂度为O(nlog2n)

算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

package sort.algorithm;

public class ShellSort {

public static void main(String[] args) {

int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 };

double d1 = a.length;

int temp = 0;

while (true)

{

//利用这个在将组内倍数减小

//这里依次为5,3,2,1

d1 = Math.ceil(d1 / 2);

//d为增量每个分组之间索引的增量

int d = (int) d1;

//每个分组内部排序

for (int x = 0; x d; x++)

{

//组内利用直接插入排序

for (int i = x + d; i a.length; i += d) {

int j = i - d;

temp = a[i];

for (; j = 0 temp a[j]; j -= d) {

a[j + d] = a[j];

}

a[j + d] = temp;

}

}

if (d == 1)

break;

}

for (int i = 0; i a.length; i++)

System.out.print(a[i]+" ");

}

}

五 交换类排序之冒泡排序

交换类排序核心就是每次比较都要进行交换

冒泡排序：是一种交换排序

每一趟比较相邻的元素，较若大小不同则就会发生交换，每一趟排序都能将一个元素放到它最终的位置！每一趟就进行比较。

时间复杂度O(n2)，空间复杂度O(1)

package sort.algorithm;

//冒泡排序：是一种交换排序

public class BubbleSort {

// 按照递增顺序排序

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 };

int temp = 0;

// 排序的比较趟数,每一趟都会将剩余最大数放在最后面

for (int i = 0; i data.length - 1; i++) {

// 每一趟从开始进行比较，将该元素与其余的元素进行比较

for (int j = 0; j data.length - 1; j++) {

if (data[j] data[j + 1]) {

temp = data[j];

data[j] = data[j + 1];

data[j + 1] = temp;

}

}

}

for (int i = 0; i data.length; i++)

System.out.print(data[i] + " ");

}

}

用JAVA实现折半插入排序的题目

别忘记给分哦

package com.adtech.interf.test;

public class Test{

public Test(Record a[]) {

int i, j, m, low, high;

Record temp;

for (i = 0; i a.length; i++) {

temp = a[i];

low = 0;

high = i;

while (low = high) {

m = (low + high) / 2;

if (temp.getStudentID() a[m].getStudentID()) {

high = m - 1;

} else {

low = m + 1;

}

}

for (j = i; j high + 1 j 0; j--) { // 如果jhigh 就会少遍历一个元素 || jlow

a[j] = a[j - 1];

}

a[j] = temp;

}

for (int t = 0; t a.length; t++) {

System.out.println(a[t].getStudentID());

}

}

public static void main(String args[]) {

Record record1 = new Record(2,"张三1",81.0,18);

Record record2 = new Record(4,"张三2",82.0,11);

Record record3 = new Record(5,"张三3",83.0,12);

Record record4 = new Record(43,"张三4",84.0,13);

Record record5 = new Record(21,"张三5",85.0,14);

Record record6 = new Record(54,"张三6",86.0,15);

Record record7 = new Record(22,"张三7",87.0,16);

Record record8 = new Record(6,"张三4",88.0,17);

Record record9 = new Record(223,"张三9",89.0,18);

Record record10 = new Record(545,"张三10",80.0,19);

Record [] record = new Record[]{record1,record2,record3,record4,

record5,record6,record7,record8,record9,record10};

new Test(record);

}

}

当前文章：Java折半排序代码 java实现各种排序算法
网站路径：http://hbruida.cn/article/doposge.html