java二分法查找案例与数组排序案例
java算法-二分法查找实现

java算法-⼆分法查找实现什么是⼆分法查找⾸先,使⽤⼆分法查找的前提是:被查找的数组已排好序具体实现:假如有⼀组数为3,12,24,36,55,68,75,88要查给定的值24.可设三个变量front,mid,end分别指向数据的上界,中间和下界,mid=(front+end)/2.1.开始令front=0(指向3),end=7(指向88),则mid=3(指向36)。
因为a[mid]>x,故应在前半段中查找。
2.令新的end=mid-1=2,⽽front=0不变,则新的mid=1。
此时x>a[mid],故确定应在后半段中查找。
3.令新的front=mid+1=2,⽽end=2不变,则新的mid=2,此时a[mid]=x,查找成功,返回查找元素的索引。
如果要查找的数不是数列中的数,例如x=25,当第三次判断时,x>a[mid],按以上规律,令front=mid+1,即front=3,出现front>end的情况,表⽰查找不成功,放回-1。
⼆分法查找使⽤场景⼆分法查找适⽤于数据量较⼤时,但是数据需要先排好顺序。
对于我们很多⼈来说,还是⽤于⾯试……代码实现package com.xzlf.binarySearch;import java.util.Arrays;public class TestBinarySearch {public static void main(String[] args) {int[ ] arr = { 30,20,50,10,80,9,7,12,100,40,8};int searchWord = 20; // 所要查找的数Arrays.sort(arr); //⼆分法查找之前,⼀定要对数组元素排序System.out.println(Arrays.toString(arr));System.out.println(searchWord+"元素的索引:"+binarySearch(arr,searchWord));System.out.println("========================");int errorWord = 66; // 查找不存在的数System.out.println(errorWord+"元素的索引:"+binarySearch(arr,errorWord));}public static int binarySearch(int[] arr, int value) {int low = 0; // 开始位置int high = arr.length - 1; // 结束位置while(low <= high) {int middle = (low + high) / 2;if (value == arr[middle]) {return middle; //返回查询到的索引位置}if (value > arr[middle]) {low = middle + 1;}if (value < arr[middle]) {high = middle - 1;}}//上⾯循环完毕,说明未找到,返回-1return -1;}}以上代码运⾏结果为:。
java中binarysearch的用法

Java中binarySearch的用法1.介绍`b in ar yS ea rc h`是J a va中用于在有序数组中查找元素的方法,它采用二分查找的算法。
本文将详细介绍`bin a ry Se ar ch`方法的用法及注意事项。
2.方法签名```j av ap u bl ic st at ic in tbi n ar yS ea rc h(in t[]a rr ay,i nt ke y)```-参数1:有序数组a r ra y-参数2:要查找的元素ke y-返回值:若找到ke y,则返回其索引;若未找到,则返回-(插入点+1),插入点为数组中第一个大于ke y的元素索引。
3.例子下面通过一个例子来演示`b in ar yS ea rch`方法的用法。
```j av ai n t[]a rr ay={2,4,6,8,10};i n tk ey=6;i n ti nd ex=A rr ay s.b i na ry Se ar ch(a rra y,k ey);S y st em.o ut.p ri ntl n("元素6的索引为:"+in de x);```输出结果为:```元素6的索引为:2```4.注意事项使用`b in ar yS ea rch`方法时需要注意以下几点:-有序数组:`b in ary S ea rc h`方法要求输入的数组必须是有序的。
如果数组无序,则结果是不确定的。
-返回值处理:根据返回值可以判断是否找到元素,如果返回值大于等于0,则表示找到;如果返回值小于0,则表示未找到。
-插入点处理:如果未找到元素,则返回插入点索引的相反数减1。
插入点是指数组中第一个大于要查找元素的位置。
5.应用场景`b in ar yS ea rc h`方法可以在许多场景中使用,例如:-查找元素:在有序数组中快速查找指定元素。
-数组排序:通过`bi n ar yS ea rc h`方法查找元素是否存在,可以对有序数组进行排序。
二分查找生活实例

二分查找生活实例二分查找是一种常用的搜索算法,它可以在有序数组中快速找到目标元素的位置。
虽然这个算法在计算机科学中被广泛应用,但其实它在我们日常生活中也有很多实际应用的例子。
假设你是一位书店的老板,你的书架上摆满了各式各样的图书。
为了方便顾客找到他们需要的书籍,你决定对图书按照字母顺序进行排序。
当然,这样一来,你在处理顾客的查询时就可以使用二分查找来提高效率。
有一天,一位顾客走进了你的书店,他想要购买一本名为《二分查找的艺术》的书籍。
你告诉他,这本书在书架的中间位置,他可以从中间开始搜索。
顾客遵循你的建议,迅速找到了目标书籍。
这就是二分查找在生活中的一个实例。
除了图书馆中的书籍,二分查找还可以应用于其他领域。
比如,你是一位爱好登山的人,你计划攀登一座高山。
在攀登之前,你会事先做好充分的准备,包括查看地图和了解山脉的地形。
当你开始攀登时,你会使用二分查找来确定自己的位置,以便更好地规划路线。
在你攀登的过程中,你会遇到许多路标,它们标志着你离目标越来越近。
你会根据这些路标来判断自己的位置,并根据地图上的信息来调整行进方向。
这个过程就类似于二分查找中不断缩小搜索范围的过程。
二分查找还可以应用于购物中。
假设你想买一台新的电视,你可以在网上浏览各种电商平台,然后根据价格和评价来筛选出几款心仪的电视。
接下来,你可以使用二分查找来比较这几款电视的价格,找到最适合自己预算的那一款。
当然,二分查找并不仅限于上述的例子。
在生活中,我们还可以将其应用于其他许多场景,比如查找歌曲、查找联系人、查找菜单中的美食等等。
无论是在哪个领域,二分查找都可以帮助我们快速找到目标,节省时间和精力。
总结起来,二分查找是一种在生活中实际应用广泛的算法。
无论是在图书馆、登山、购物还是其他场景中,我们都可以利用二分查找来快速找到目标。
通过理解和应用二分查找,我们可以提高生活的效率,使我们的日常活动更加便捷。
选择排序和冒泡排序、二分查找

给大家分享下:快速排序、冒泡排序、二分查找
快速排序:
如图:首先取出下标为0的数,然后依次与下标为1,2…比较,如果arr[0]>arr[x]时,我们就把这两个数互换下,依次类推一轮循环过后,可以arr[0]就选出为整个数组最小的数,第二轮我们重下标为1开始然后与下标为2,3…数相比,类似第一轮那样。
上面的算法优化:
冒泡排序:
步骤图形分解;
如图:从数组最后两位数开始比较,如果最后一个数小于倒数第二个数,我们就互换这个两个数,然后依次类图按照如上图步骤,第一轮下来后数组下标为0的就取到全数组最小的数;依次类推的方式,按照第二轮,第三轮步骤…
关键算法代码:
二分查找:
前提:给我们的数组是有序的
步骤图解:
说明:我们查找46,第一次定义start,end变量分别问0和数组长度,定义变量med=start+end/2;然后我们那46与arr[med]比较,如果46>arr[med]时,我们把start=med+1;如上图,如果大于的话,我们把end = med-1;依次类推:可以算出第三轮后start和med、end三根线重叠在一起;46=arr[med],这时候找到了,返回med
Java代码:。
java二分查找的简单例题

java二分查找的简单例题Java二分查找的简单例题二分查找,也称折半查找,是一种基于比较目标值和中间值的搜索算法。
它适用于已经排序的数组或者集合。
在实际开发中,我们经常需要使用二分查找,尤其是在大规模数据处理时,它的效率比遍历查找更快。
接下来,就让我们一起来学习Java中如何实现二分查找,并以一个简单例题为例进行分析。
二分查找算法的实现一、Java代码实现二分查找我们先看下面的Java代码实现二分查找:```Javapublic class BinarySearch {public static int binarySearch(int[] arr, int key) {int low = 0, high = arr.length - 1;while (low <= high) {int mid = (low + high) >>> 1;int midVal = arr[mid];if (midVal < key)low = mid + 1;else if (midVal > key)high = mid - 1;elsereturn mid;}return -1;}public static void main(String[] args) {int[] arr = {1, 3, 6, 8, 9, 12};System.out.println(binarySearch(arr, 6));}}```以上代码中:1. `low` 和 `high` 分别表示要被查找的数组的最小下标和最大下标,初始化分别为第一位和最后一位。
2. while 循环中,设置数组最小下标与最大下标的中间位置为mid,同时将其值赋给 midVal。
3. 如果 midVal 小于 key,则将 low 设置为 mid + 1,将查找范围缩小到右半部分数组中。
4. 如果 midVal 大于 key,则将 high 设置为 mid - 1,将查找范围缩小到左半部分数组中。
java三种排序法(二分、冒泡、选择)

二分查找法import java.io.*;class FindSearch{int binarySearch(int arr[],int searchValue){int low=0;int high=arr.length-l;int mid=(low+high)/2;while(low<=high&&arr[mid]!=searchValue){if(arr[mid]<searchValue)low=mid+1;elsehigh=mid-1;mid=(low+high)/2;}if(low>high)mid=-1;return mid;}}public class erfen{public static void main(String[]args)throws IOException{ BufferedReader keyin=new BufferedReader(new InputStreamReader(Syste m.in));int i,search,mid;String c1;int arr[]=(2,4,7,18,25,34,56,68,89);System.out.printn("打印原始数据");for(i=0;i<arr.length;i++)System.out.print(""+arr[i]);System.out.println("ln");Systemoutprintn("请输入要查找的整数");cl=keyin.readLine();search=Integer.parseInt(c1);FindSearch pl=new FindSearch();mid=pl.binarySearcharr,search);if(mid==-1)System.out.println("没找到!");else Systemoutpintln("所查整数在数组中的位置下标是:"+mid); }}冒泡排序法import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;class SortClass{void sort(int arr[]){int i,k,temp;int len=arr.length;for(i=0;i<len-1;i++)for(k=len-1;k>i;k--)if(arr[k]<arr[k-1]){ temp=arr[k-1];arr[k-1]=arr[k];arr[k]=temp;}}}public class maopao{public static void main(Sring[] args)throws IOException{BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in)); int i;String c1;int arr[]=new int[10];int len=arr.length;System.outprintln(请从键盘输入10个整数”);for(i=0;i<len;i++){c1=keyin.readLine();arr[i]=Integer.parseInt(c1);}System.out.print("原始数据:");for(i=0;i<len;i++)System.out.print(""+arr[i]);System.out.println("\n");SortClass p1=new SortClass( );p1.sort(arr);System.out.println("冒泡法排序的结果:");for(i=0;i<len;i++)System.out.print" "+arr[i]);System.out.println("\n");}}选择排序法import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;class SelectSort{static void sort(int arr1[]){int i.j,k,t;int len=arr1.length;for(i=0;i<len-1;i++){k=i;for(j=i+1;j<len;j++)if(arr1[j]<arr1[k]) k=j;if(k>i){ t=arr1[i];arr1[i]=arr1[k];arr1[k]=t;}}}}public class xuanze extends SelectSort{public static void main(String[ ] args){int arr[]={0,9,8,7,6,5,4,3,2,1};int len=arr.length;SelectSort.sort(arr);System.out.print("选择法排序的结果:"); System.out.println("length="+arr.length);for(int i=0;i<len;i++)System.out.print(" "+arr[i]);System.out.println("\n");} }。
java二分法查找案例与数组排序案例

一、一个int类型数组按升序排序案例public class ArrayTest {private static int[] arrayAesc;public static void main(String[] args) {ArrayTest a = new ArrayTest();arrayAesc = new int[]{5,2,1,4,6,3};arrayAesc = a.sortArrayAesc(arrayAesc);for (int i = 0; i < arrayAesc.length; i++) { System.out.println(arrayAesc[i]);}System.out.println("success");}public int[] sortArrayAesc(int[] temps){for (int i = 0; i < temps.length; i++) {for (int j = i+1; j < temps.length; j++) {if (temps[i] > temps[j]) {int temp;temp = temps[i];temps[i] = temps[j];temps[j] = temp;}}}return temps;}}二、一个int类型数组按降序排序案例public class ArrayTest {private static int[] arrayAesc;public static void main(String[] args) {ArrayTest a = new ArrayTest();arrayAesc = new int[]{5,2,1,4,6,3};arrayAesc = a.sortArrayDesc(arrayAesc);for (int i = 0; i < arrayAesc.length; i++) { System.out.println(arrayAesc[i]);}System.out.println("success");}public int[] sortArrayDesc(int[] temps){for (int i = 0; i < temps.length; i++) {for (int j = i+1; j < temps.length; j++) {if (temps[i] < temps[j]) {int temp;temp = temps[i];temps[i] = temps[j];temps[j] = temp;}}}return temps;}}三、二分法查找案例public class TestMiddle {private final static int target = 1;private static int findData(int dataset[]){int dataLength = dataset.length;//获取数组大小//判断是否存在于数组中if(dataset[0] > target || dataset[dataLength - 1] < target){System.out.println("不存在你想要找的数据");return -1;}//获取数组中间那个索引,不过这里要小心,就是数组大小奇数偶数的时候,想一下呵呵int midIndex = dataLength / 2;//定义一个中间数组,用来过渡数据int temp[];//把中间索引的那个数组值付给这个变量int midData = dataset[midIndex];//这就是找到了if(midData == target){System.out.println("呵呵,数据已经找到了!!" + midData);return midData;}//中间那个值比目标到的情况if(midData > target){//初始化中间数组的长度temp = new int [midIndex];for(int i=0;i<midIndex;i++){temp[i] = dataset[i];}return findData(temp);}//中间那个值比目标小的时候if(midData < target){//最绕的是这里,就是因为奇数偶数....还有向前向后....不再详述int afterIndex = midIndex;if(dataLength % 2 == 0){temp = new int [midIndex-1];for(int i=0;i<midIndex - 1;i++){afterIndex = afterIndex + 1;temp[i] = dataset[afterIndex];}}else{temp = new int [midIndex];for(int i=0;i<midIndex;i++){afterIndex = afterIndex + 1;temp[i] = dataset[afterIndex];}}return findData(temp);}else{System.out.println("不存在你想要找的数据");return -1;}}public static void main(String[] args) {int test[] = new int [] {1,2,3,4,5,6,7,8};TestMiddle.findData(test);}}。
java 二分查找法案例

Java二分查找法案例1. 什么是二分查找法二分查找法(Binary Search)是一种在有序数组中查找某一特定元素的搜索算法。
它将目标值与数组的中间元素进行比较,如果相等则返回该元素的索引,如果目标值小于中间元素,则在数组的左半部分继续查找,如果目标值大于中间元素,则在数组的右半部分继续查找。
通过每次将查找范围缩小一半,最终可以找到目标值。
2. 二分查找法的实现原理二分查找法的实现原理可以分为以下几个步骤:1.确定查找范围的起始和结束位置,一般为数组的第一个元素和最后一个元素。
2.计算查找范围的中间位置,即(start + end) / 2。
3.比较中间位置的元素与目标值的大小关系:–如果中间位置的元素等于目标值,则返回该位置。
–如果中间位置的元素大于目标值,则更新结束位置为中间位置的前一个位置。
–如果中间位置的元素小于目标值,则更新起始位置为中间位置的后一个位置。
4.重复以上步骤,直到找到目标值或者起始位置大于结束位置为止。
3. 二分查找法的代码实现下面是一个使用二分查找法在有序数组中查找目标值的示例代码:public class BinarySearch {public static int binarySearch(int[] nums, int target) {int start = 0;int end = nums.length - 1;while (start <= end) {int mid = (start + end) / 2;if (nums[mid] == target) {return mid;} else if (nums[mid] > target) {end = mid - 1;} else {start = mid + 1;}}return -1;}public static void main(String[] args) {int[] nums = {1, 3, 5, 7, 9};int target = 5;int result = binarySearch(nums, target);if (result == -1) {System.out.println("目标值不存在");} else {System.out.println("目标值的索引为:" + result);}}}4. 二分查找法的时间复杂度和空间复杂度二分查找法的时间复杂度为 O(log n),其中 n 是数组的长度。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
一、一个int类型数组按升序排序案例
public class ArrayTest {
private static int[] arrayAesc;
public static void main(String[] args) {
ArrayTest a = new ArrayTest();
arrayAesc = new int[]{5,2,1,4,6,3};
arrayAesc = a.sortArrayAesc(arrayAesc);
for (int i = 0; i < arrayAesc.length; i++) { System.out.println(arrayAesc[i]);
}
System.out.println("success");
}
public int[] sortArrayAesc(int[] temps){
for (int i = 0; i < temps.length; i++) {
for (int j = i+1; j < temps.length; j++) {
if (temps[i] > temps[j]) {
int temp;
temp = temps[i];
temps[i] = temps[j];
temps[j] = temp;
}
}
}
return temps;
}
}
二、一个int类型数组按降序排序案例
public class ArrayTest {
private static int[] arrayAesc;
public static void main(String[] args) {
ArrayTest a = new ArrayTest();
arrayAesc = new int[]{5,2,1,4,6,3};
arrayAesc = a.sortArrayDesc(arrayAesc);
for (int i = 0; i < arrayAesc.length; i++) { System.out.println(arrayAesc[i]);
}
System.out.println("success");
}
public int[] sortArrayDesc(int[] temps){
for (int i = 0; i < temps.length; i++) {
for (int j = i+1; j < temps.length; j++) {
if (temps[i] < temps[j]) {
int temp;
temp = temps[i];
temps[i] = temps[j];
temps[j] = temp;
}
}
}
return temps;
}
}
三、二分法查找案例
public class TestMiddle {
private final static int target = 1;
private static int findData(int dataset[]){
int dataLength = dataset.length;//获取数组大小
//判断是否存在于数组中
if(dataset[0] > target || dataset[dataLength - 1] < target){
System.out.println("不存在你想要找的数据");
return -1;
}
//获取数组中间那个索引,不过这里要小心,就是数组大小奇数偶数的时候,想一下呵呵
int midIndex = dataLength / 2;
//定义一个中间数组,用来过渡数据
int temp[];
//把中间索引的那个数组值付给这个变量
int midData = dataset[midIndex];
//这就是找到了
if(midData == target){
System.out.println("呵呵,数据已经找到了!!" + midData);
return midData;
}
//中间那个值比目标到的情况
if(midData > target){
//初始化中间数组的长度
temp = new int [midIndex];
for(int i=0;i<midIndex;i++){
temp[i] = dataset[i];
}
return findData(temp);
}
//中间那个值比目标小的时候
if(midData < target){
//最绕的是这里,就是因为奇数偶数....还有向前向后....不再详述
int afterIndex = midIndex;
if(dataLength % 2 == 0){
temp = new int [midIndex-1];
for(int i=0;i<midIndex - 1;i++){
afterIndex = afterIndex + 1;
temp[i] = dataset[afterIndex];
}
}else{
temp = new int [midIndex];
for(int i=0;i<midIndex;i++){
afterIndex = afterIndex + 1;
temp[i] = dataset[afterIndex];
}
}
return findData(temp);
}
else{
System.out.println("不存在你想要找的数据");
return -1;
}
}
public static void main(String[] args) {
int test[] = new int [] {1,2,3,4,5,6,7,8};
TestMiddle.findData(test);
}
}。