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 是数组的长度。
Java实现查找算法的示例代码(二分查找、插值查找、斐波那契查找)
Java实现查找算法的⽰例代码(⼆分查找、插值查找、斐波那契查找)⽬录1.查找概述2.顺序查找3.⼆分查找3.1 ⼆分查找概述3.2 ⼆分查找实现4.插值查找4.1 插值查找概述4.2 插值查找实现5.斐波那契查找5.1 斐波那契查找概述5.2 斐波那契查找实现5.3 总结1.查找概述查找表:所有需要被查的数据所在的集合,我们给它⼀个统称叫查找表。
查找表(Search Table)是由同⼀类型的数据元素(或记录)构成的集合。
查找(Searching):根据给定的某个值,在查找表中确定⼀个其关键字等于给定值的数据元素(或记录)。
若表中存在这样的⼀个记录,则称查找是成功的,此时查找的结果给出整个记录的信息,或指⽰该记录在查找表中的位置;若表中不存在关键字等于给定值的记录,则称查找不成功,此时查找的结果可给出⼀个“空”记录或“空”指针。
查找表分类:查找表按照操作⽅式来分有两⼤种:静态查找表和动态查找表。
静态查找表(Static Search Table),只作查找操作的查找表。
它的主要操作有:1. 查询某个“特定的”数据元素是否在查找表中。
2. 检索某个“特定的”数据元素和各种属性。
动态查找表(Dynamic Search Table),在查找过程中同时插⼊查找表中不存在的数据元素,或者从查找表中删除已经存在的某个数据元素。
显然动态查找表的操作就是两个:1. 查找时插⼊数据元素。
2. 查找时删除数据元素。
查找结构:为了提⾼查找的效率,我们需要专门为查找操作设置数据结构,这种⾯向查找操作的数据结构称为查找结构。
从逻辑上来说,查找所基于的数据结构是集合,集合中的记录之间没有本质关系。
可是要想获得较⾼的查找性能,我们就不能不改变数据元素之间的关系,在存储时可以将查找集合组织成表、树等结构。
例如,对于静态查找表来说,我们不妨应⽤线性表结构来组织数据,这样可以使⽤顺序查找算法,如果再对主关键字排序,则可以应⽤⼆分查找等技术进⾏⾼效的查找。
二分法解决实际问题的例子
二分法解决实际问题的例子
二分法是一种常用的搜索算法,它可以在有序列表中快速找到目标值。
以下是一些二分法解决实际问题的例子:
1. 查找有序数组中的特定元素:假设有一个有序整数数组,我们想要在其中查找特定的数字。
使用二分法,我们可以比较要查找的数字与数组的中间元素,然后根据比较结果决定是在左半边还是右半边继续二分查找,直到找到目标值或者确定目标值不存在。
2. 搜索旋转排序数组中的目标值:假设有一个已排序的数组,但该数组经过了未知次数的旋转。
我们需要在这个旋转排序数组中搜索特定的值。
使用二分法,我们可以先找到旋转点,然后根据目标值与旋转点的比较结果,在两个有序的子数组中继续进行二分查找。
3. 寻找平方根:给定一个非负整数,我们需要计算它的平方根。
可以使用二分法来逼近平方根的值。
我们可以将问题转化为在某个范围内寻找特定的数字,然后使用二分法在这个范围内逼近平方根。
4. 查找旋转排序数组中的最小值:给定一个已排序的旋转数组,我们需要找到其中的最小值。
使用二分法,我们可以比较中间元素与两端元素的大小关系,根据比较结果更新搜索范围,直到找到最小值。
这些例子展示了二分法在实际问题中的应用,它可以通过不断
缩小搜索范围,快速准确地找到目标值或者解决问题。
二分法的时间复杂度为O(log n),所以它是一种高效的搜索算法。
算法-二分法查找(Java实现)
算法-⼆分法查找(Java实现)什么是⼆分法查找⼆分查找也称折半查找(BinarySearch),它是⼀种采⽤分治策略的算法,他将问题分解为规模更⼩的的⼦问题,分⽽治之,逐⼀解决。
采⽤⼆分法查找的前提条件是:要求线性表必须采⽤顺序存储结构,⽽且表中元素按关键字有序排列。
⼆分法查找使⽤场景⼆分法查找适⽤于数据量较⼤时,但是数据需要先排好顺序。
对于我们很多⼈来说,还是⽤于⾯试……⼆分法查找算法设计设排序元素序列(升序)存储在 arrs 数组,begin、end 指定查找范围,keyword 是指定查找的值。
每次从⼦序列中间 mid 开始⽐较 mid = (begin + end) / 2,如果 keyword 与 arrs[mid] 元素相等,则查找成功;否则根据根据 keyword ⼤⼩缩⼩查找范围,若keyword 较⼩,则继续在⼦序列前半段 begin ~ (mid - 1) 查找;反之在后半段 (mid - 1) ~ end查找。
重复 1,直到查找成功,当 begin、end 表⽰范围失效时,返回 -1 表⽰查找失败。
时间复杂度最快:O(1)最坏:O(logn)平均时间复杂度:O(logn)Java 实现循环实现/*** ⼆分查找* @param arr* @param value* @return -1 则查找失败*/public static int binarySearch(int[] arr, int value) {int begin = 0;int end = arr.length - 1;int mid;while (begin <= end) { // 边界有效mid = (begin + end) / 2; // 计算中界if (arr[mid] == value) { // 如果两个值相等return mid;} else if (value > arr[mid]) { // value 较⼩begin = mid + 1; //} else { // value 较⼤end = mid - 1;}}return -1;}递归实现/*** 递归实现⼆分法查找* @param arr [排序完成的线性表]* @param value [查找的元素]* @param begin [从第⼏个元素开始]* @param end [数组长度 - 1]* @return -1 则查找失败*/public static int binarySearch(int[] arr, int value, int begin, int end) {int mid = (begin + end) / 2;// ⽆效边界if (begin > end) {return -1;}if (arr[mid] == value) {return mid;} else if (value > arr[mid]) { // value 较⼩begin = mid + 1;} else {end = mid - 1;}return binarySearch(arr, value, begin, end);}。
JAVA数组的最大最小值二分法查找
for (int i = 1; i < array.length; i++) {
if (array[i] > array[maxIndex]) {
maxIndex = i;
}
}
return array[maxIndex];
}
/**
* 最大值查找2
*
* @param array
* @return
*/
public static int getMax_2(int[] array) {
int maxElement = array[0]; // 通过数组中的元素进行比较
for (int i = 0; i < array.length; i++) {
int max1 = getMax_1(arr);
System.out.println("通过角标比较最大值:" + max1);
int max2 = getMax_2(arr);
System.out.println("通过数组中的元素进行比较:" + max2);
Arrays.sort(arr);
int min = 0; // 最小角标
int max = arr.length - 1;// 最大角标
int mid = (min + max) / 2; // 中间角标
while (min <= max) {
mid = (max + min) >> 1; // >>代表右移一位相当于除以2速度快
二分法的应用实例
二分法的应用实例
二分法的应用实例:查找旋转排序数组中的最小值
二分法是一种高效的算法,在查找、排序等领域有着广泛的应用。
其中,在查找旋转排序数组中的最小值问题中,二分法的应用尤为突出。
旋转排序数组是指一个原本递增的有序数组,在经过旋转后,有可能变成了一个部分递增、部分递减的有序数组。
例如,[4,5,6,7,0,1,2]就是一个旋转排序数组,其中最小值为0。
如何通过二分法来查找旋转排序数组中的最小值呢?以下是一种基于二分法的解决方案:
1. 首先,我们需要明确一个性质:旋转排序数组中最小的元素,一定是在“旋转点”处。
2. 我们采用二分法的思想,设定两个指针left和right,分别指向数组的首位元素。
计算出它们的中间位置mid,并将其与right元素进行比较。
3. 如果mid位置的元素小于right位置的元素,说明最小值可能在mid左边,因此我们将right指针移动到mid位置。
反之,如果mid位置的元素大于right位置的元素,说明最小值可能在mid右边,因此我们将left指针移动到mid+1位置。
4. 接着,我们重复步骤2和3,直到left和right指针相遇。
此时,它们指向的元素即为旋转数组中最小的元素。
这种基于二分法的解决方案具有时间复杂度O(logn),比暴力搜索的时间复杂度O(n)要快得多。
而且,这种解决方案还具有一定的通用性,可以用于查找旋转排序数组中的最大值、查找某个元素是否存在等问题。
二分法是一种非常有用的算法,可以在许多领域发挥重要作用。
在实际应用中,我们需要根据具体问题来选择合适的解决方案,以达到最优的效果。
二分法来解决问题的实例
二分法来解决问题的实例在计算机科学和数学领域,二分法是一种常用的算法,用于解决各种问题。
二分法的基本思想是将问题划分为两个子问题,逐步缩小范围直至找到问题的解。
本文将通过两个实例,详细介绍二分法在查找和排序问题中的应用。
实例一:二分查找二分查找是二分法最常见的应用之一。
该算法用于在有序数列中查找给定值的位置。
假设我们有一个已排序的整型数组arr和一个目标值target,我们要找到目标值在数组中的位置。
算法步骤如下:1. 初始化左指针left为数组的第一个元素的索引,右指针right为数组最后一个元素的索引。
2. 当左指针小于等于右指针时,执行以下步骤:a. 计算中间元素的索引mid,mid = (left + right) / 2。
b. 如果中间元素等于目标值,返回mid。
c. 如果中间元素小于目标值,更新左指针left = mid + 1。
d. 如果中间元素大于目标值,更新右指针right = mid - 1。
3. 如果循环结束仍未找到目标值,返回-1。
通过以上算法,我们可以在O(logN)的时间复杂度内找到目标值的位置,其中N为数组的长度。
二分查找广泛应用于各个领域,例如在大规模数据查找和游戏开发中。
实例二:二分排序二分排序是二分法在排序问题中的应用。
该算法通过递归地将序列划分为两个子序列,并对子序列进行排序,最后合并子序列以得到有序的序列。
算法步骤如下:1. 如果序列的长度小于等于1,无需排序,返回序列。
2. 将序列平均分成两个子序列,递归调用二分排序算法对两个子序列进行排序。
3. 合并两个排好序的子序列,得到完整的有序序列。
通过以上算法,我们可以在O(NlogN)的时间复杂度内对序列进行排序,其中N为序列的长度。
二分排序是一种高效的排序算法,被广泛应用于各种排序问题。
总结二分法是一种常用的算法,通过将问题划分为两个子问题,逐步缩小范围来解决问题。
本文介绍了二分查找和二分排序两个实例,展示了二分法在查找和排序问题中的应用。
Java中常用的查找方法——顺序查找和二分查找
Java中常用的查找算法——顺序查找和二分查找一、顺序查找:a)原理:顺序查找就是按顺序从头到尾依次往下查找,找到数据,则提前结束查找,找不到便一直查找下去,直到数据最后一位。
b)图例说明:原始数据:int[] a={4,6,2,8,1,9,0,3};要查找数字:8代码演示:import java.util.Scanner;/** 顺序查找*/public class SequelSearch {public static void main(String[] arg) {int[] a={4,6,2,8,1,9,0,3};Scanner input=new Scanner(System.in);System.out.println("请输入你要查找的数:");//存放控制台输入的语句int num=input.nextInt();//调用searc()方法,将返回值保存在result中int result=search(a, num);if(result==-1){System.out.println("你输入的数不存在与数组中。
");}elseSystem.out.println("你输入的数字存在,在数组中的位置是第:"+(result+1)+"个");}public static int search(int[] a, int num) {for(int i = 0; i < a.length; i++) {if(a[i] == num){//如果数据存在return i;//返回数据所在的下标,也就是位置}}return -1;//不存在的话返回-1}}运行截图:二、二分查找a)前提条件:已排序的数组中查找b)二分查找的基本思想是:首先确定该查找区间的中间点位置:int mid = (low+upper)/ 2;然后将待查找的值与中间点位置的值比较:若相等,则查找成功并返回此位置。
二分法解决问题实例并描述处理的过程
二分法解决问题实例并描述处理的过程
二分法是一种常用的查找算法,它可以高效地在有序数组中查找特定的元素。
以下是一个使用二分法解决问题的实例,并描述了处理的过程:
问题:在有序整数数组中查找特定元素的索引。
输入:一个有序的整数数组 `arr` 和一个目标元素 `target`。
输出:如果目标元素 `target` 存在于数组 `arr` 中,则返回其索引值;否则,返回 -1。
1. 首先,初始化两个指针 `left` 和 `right`,分别指向数组的起始位置和结束位置。
2. 开始循环处理。
当 `left` 小于等于 `right` 时,执行以下步骤:
1. 计算指针 `mid`,它指向数组的中间位置,即 `mid = (left + right) / 2`。
2. 如果目标元素 `target` 等于数组中间位置的元素 `arr[mid]`,则返回 `mid`。
3. 如果 `target` 小于 `arr[mid]`,则将指针 `right` 更新为 `mid - 1`,缩小搜索范围。
4. 如果 `target` 大于 `arr[mid]`,则将指针 `left` 更新为 `mid + 1`,缩小搜索范围。
3. 如果循环结束条件为 `left > right`,说明目标元素不在数组中,返回 -1。
这个二分法的处理过程基于每次都将搜索范围缩小一半的原理,因此其时间复杂度为O(logN),其中 N 是数组的长度。
这种算法适用于已排序的数组和列表,可以高效地进行搜索操作。
二分法解决问题的实例
二分法解决问题的实例二分法是一种常用的问题解决方法,特别适用于在有序列表或区间中查找目标值的情况。
下面我将举几个实例来说明二分法的应用。
1. 查找有序数组中的目标值,假设有一个升序排列的数组,我们想要在其中查找某个特定的值。
首先,我们取数组的中间值,与目标值进行比较。
如果中间值等于目标值,则找到了目标值;如果中间值大于目标值,则说明目标值可能在数组的左半部分,我们将在左半部分继续进行二分查找;如果中间值小于目标值,则说明目标值可能在数组的右半部分,我们将在右半部分继续进行二分查找。
通过不断缩小查找范围,最终可以找到目标值或确定目标值不存在。
2. 寻找旋转有序数组中的最小值,假设有一个旋转有序数组,即原本是升序排列的数组被旋转了一定的次数。
我们的目标是找到旋转后数组中的最小值。
同样地,我们可以通过二分法来解决这个问题。
首先,我们取数组的中间值与最右边的值进行比较。
如果中间值小于最右边的值,则说明最小值可能在数组的左半部分,我们将在左半部分继续进行二分查找;如果中间值大于最右边的值,则说明最小值可能在数组的右半部分,我们将在右半部分继续进行二分查找。
通过不断缩小查找范围,最终可以找到旋转有序数组中的最小值。
3. 求解方程的根,假设有一个单调递增的函数,我们想要求解方程 f(x) = 0 的根。
通过二分法,我们可以选择一个合适的区间,在区间的两个端点分别计算函数值。
根据函数值的正负性,我们可以确定根可能存在的位置。
然后,我们将区间一分为二,选择新的区间进行计算,重复上述步骤,直到找到满足要求的根。
总结来说,二分法通过不断缩小查找范围,将问题规模减半,从而高效地解决问题。
它在查找有序列表中的目标值、寻找旋转有序数组中的最小值以及求解方程的根等问题中都有广泛的应用。
关于冒泡排序、快速排序和二分法查找的分析(Java版)
数放前,小数放后,一直比较到最小数前的一对相邻数,
将大数放前,小数放后,第二趟结束,在倒数第二个数中得
到一个新的最小数。如此下去,直至最终完成排序。
*/
public class MaoPao {
public void BubbleSort(int a[]) {
5)重复第3、4步,直到 I=J;
例如:待排序的数组A的值分别是:(初始关键数据:X=49)
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]:
49 38 65 97 76 13 27
进行第一次交换后: 27 38 65 97 76 13 49
( 按照算法的第三步从后面开始找)
进行第二次交换后: 27 38 49 97 76 13 65
( 按照算法的第四步从前面开始找>X的值,65>49,两者交换,此时:I=3 )
进行第三次交换后: 27 38 13 97 76 49 65
} else {
System.out.println(b + "不在数组a中");
}
}
public static void main(String[] args){
Search s=new Search();
int[] a={11,41,17,18,14,16,20,45};
int high = a.length - 1;
int mid = (low + high) / 2;
while ((mid != low) && (mid != high)) {
算法整理-二分查找和排序
算法整理-⼆分查找和排序1. ⼆分查找(1) 有序数组查找插⼊位置:主要是终⽌条件的判断,如果查找不到需要被范围的插⼊位置为begin public:int searchInsert(vector<int>& nums, int target) {int len = nums.size();return binarySearch(nums, target, 0, len-1);}private:int binarySearch(vector<int>& nums, int target, int begin, int end) {if (begin > end) {return begin;}int mid = (begin + end) / 2;if (target == nums[mid]) return mid;else if (target < nums[mid]){return binarySearch(nums, target, begin, mid - 1);}else{return binarySearch(nums, target, mid+1, end);}}(2) rotated array 寻找最⼩值第⼀种情况:不包含重复数字,class Solution {public:int findMin(vector<int>& nums) {int len = nums.size();return bsearch(nums, 0, len-1);}private:int bsearch(const vector<int> nums, int s, int e){if (s >= e) return nums[s];int mid = (s + e) / 2;// 在左侧数组上if (nums[mid] > nums[e]) return bsearch(nums, mid+1, e);// 在右侧数组上else return bsearch(nums, s, mid);}};(3) rotated array 寻找某个值,允许重复:分成三种情况,(1)是递增数组(2) num[s] == num[mid] = nums[e] ⽤O(n)的时间顺序查找(3)两段数组的类型,⼆分查找,先判断mid是在哪⼀段数组上class Solution {public:bool search(vector<int>& nums, int target) {int len = nums.size();if(len == 0) return false;return bsearch(nums, target, 0, len - 1);}private:bool bsearch(const vector<int>& nums, int target, int s, int e){if ( s > e) {return false;}if (cornercase(nums, s, e)){return asearch(nums, target, s, e);}if (nums[s] >= nums[e]){int mid = (s + e) / 2;if (nums[mid] == target) return true;if (nums[mid] >= nums[s]) { // mid在左边序列// target⽐mid⼤⼀定在右边序列if (target > nums[mid]) return bsearch(nums, target, mid+1, e);// t⽐mid⼩,当t⼤于end则⼀定在左侧else if (target > nums[e]) return bsearch(nums, target, s, mid-1);else if (target < nums[e]) return bsearch(nums, target, mid+1, e);else return true;}if (nums[mid] < nums[s]) {// mid在右边序列if (target < nums[mid]) return bsearch(nums, target, s, mid-1); else if(target > nums[e]) return bsearch(nums, target, s, mid-1); else if(target < nums[e]) return bsearch(nums, target, mid+1, e); else return true;}}return false;}bool cornercase(const vector<int>& nums, int s, int e){int mid = (s + e) / 2;if (nums[s] == nums[e] && nums[mid] == nums[s]){return true;}if (nums[s] <= nums[e] && nums[mid] >= nums[s]){return true;}return false;}bool asearch(const vector<int>& nums, int target, int s, int e){for (int i = s; i <=e; i++){if (nums[i] == target) return true;}return false;}};。
- 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);
}
}。