求一个冒泡查找算法的Java实现

原始数组:int[] arr = {8, 2, 3, 1, 4, 4, 9};

例如要查找的值是4,那么排好序后数组:arr = {4,4,1,2,3,8,9}

public void static void bubbleFindSort(int[] arr, int value){
//todo 算法实现部分
}

3个回答

public static int[] bubbleFindSort3(int[] arr, int value) {
int times = 0;
int index = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = index; j < arr.length - 1 - i; j++) {
if (arr[j] == value) {
arr[index] = arr[j] + 0 * (arr[j] = arr[index]);
index++;
} else {
if (arr[j] > arr[j + 1]) {
arr[j] = arr[j + 1] + 0 * (arr[j + 1] = arr[j]);
}
}
times++;
}
}
System.out.println("计算了" + times + "次。");
return arr;
}

package com.founder.bg.activity.action;
public class Test{
public void bubbleFindSort(int[] arr){
int tmp;
for(int i =0;i for(int j =i+1;j if(arr[j]==4){
tmp =arr[i];
arr[i] =arr[j];
arr[j] = tmp;
}else{
if(arr[i] >= arr[j]){
tmp =arr[i];
arr[i] =arr[j];
arr[j] = tmp;

}

}
}
}
//打印数组
for(int z =0;z<arr.length;z++){
System.out.println(arr[z]);
}
}
public static void main(String[] args) {
int[] arr = new int[]{8,2,3,1,4,4,9};
new Test().bubbleFindSort(arr);
}
}

public class Test{
public void bubbleFindSort(int[] arr){
int tmp;
for(int i =0;i for(int j =i+1;j if(arr[j]==4){
tmp =arr[i];
arr[i] =arr[j];
arr[j] = tmp;
}else{
if(arr[i] >= arr[j]){
tmp =arr[i];
arr[i] =arr[j];
arr[j] = tmp;

}

}
}
}
//打印数组
for(int z =0;z<arr.length;z++){
System.out.println(arr[z]);
}
}
public static void main(String[] args) {
int[] arr = new int[]{8,2,3,1,4,4,9};
new Test().bubbleFindSort(arr);
}
}

shouzhongabs
csdn-liang for(int i =0;i for(int j =i+1;j if(arr[j]==4){ 这些地方不全,谢谢
3 年多之前 回复
shouzhongabs
csdn-liang 能不能把代码贴全一些呢?
3 年多之前 回复
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
Java算法求最大最小值,冒泡排序,斐波纳契数列,日历一些经典算法
经典的算法总结
java面试题算法篇之折半查找
package althorgrim; /** * 1、必须采用顺序存储结果 * 2、关键字必须有序 * @author hanrk-2734 * */ public class TestBinarySearch { public static int binarySearch(int a[],int goal){ int high=a.length-1; int l...
[排序算法]--冒泡排序的三种实现(Java)
冒泡排序是非常好理解的,以从小到大排序为例,每一轮排序就找出未排序序列中最大值放在最后。 设数组的长度为N: (1)比较前后相邻的二个数据,如果前面数据大于后面的数据,就将这二个数据交换。(2)这样对数组的第0个数据到N-1个数据进行一次遍历后,最大的一个数据就“沉”到数组第N-1个位置。(3)N=N-1,如果N不为0就重复前面二步,否则排序完成。以上就是冒泡排序的基本思想,按照这个定义很快就能写
java编程题:用Java实现一个冒泡排序算法
/** * java编程题:用Java实现一个冒泡排序算法 */ public class Test { public static void main(String[] args) { int[] sortNum = {12,33,28,86,15,62,9,38}; //定义数组 bubbleSort3(sortNum); //开始排序 System.out
java查找算法(一)--顺序查找
对给定数组(字符串)顺序进行查找元素是否存在。public class SeqSearch { public static void main(String args[]){ int [] array={32,5,67,6,1,7}; int data=6; Sy
java 冒泡排序找最大值
public class BubbleSort { public static void main(String[] args) { System.out.println(System.currentTimeMillis()); int[] arr={3,2,1,4,5,6,22,17,13,29,14,15,12,123,13,133,1334,133,34,14}; int t
【算法之常用排序算法(一)】八大常用内部排序算法(快排、冒泡、希尔、堆排序等)
概述 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。          当n较大,则应采用时间复杂度为O(nlog2n)的排序方法:快速排序、堆排序或归并排序序。    快速排序:是目前基于比较的内部排序中被认为是最好的方法,
顺序表的冒泡排序算法及二分法查找代码实现
本文主要实现了比较经典的冒泡排序算法(对已经有序或者基本有序的顺序表复杂度大大降低),和二分法查找,各位看官看代码吧//冒泡排序算法及二分法查找 #include "stdio.h" typedef struct { int key; }SSTable_Elem_Type; typedef struct { SSTable_Elem_Type*elem; int length
请用Java语言编写一个冒泡排序算法
import java.util.Random; import java.util.Arrays; public class BubbleSort{ public static void main(String[] args){ int[] arr = new int[10]; for(int i = 0;i &amp;lt; arr.length;i++){ Random ran = ...
常见查找算法(Java实现)
查找的性能分析: 对于查找算法而言,常用“其关键字和给定值进行过比较的记录个数的平均值”作为衡量查找算法的依据。 定义:为了确定记录在查找表中的位置,需要和给定的值进行比较的关键字个数的期望值称为查找算法在查找成功时的平均查找长度。 对于含有n个记录的表。查找成功时的平均查找长度为ASL=∑i=1nPiCiASL= \sum _{i=1}^nP_iC_i 其中PiP_i为查找表中第ii个记录
java实现常见查找算法
  查找   查找(Searching)就是根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素(或记录)。 在互联网上查找信息是我们的家常便饭。所有这些需要被查的数据所在的集合,我们给它一个统称叫查找表。 查找表(Search Table)是由同一类型的数据元素(或记录)构成的集合。关键字(Key)是数据元素中某个数据项的值,又称为键值,用它可以标识一个数据元素。也可以标识...
折半查找算法 和 分块查找算法
折半查找算法算法思想: 将数列按有序化(递增或递减)排列,查找过程中采用跳跃式方式查找,即先以有序数列的中点位置为比较对象,如果要找的元素值小于该中点元素,则将待查序列缩小为左半部分,否则为右半部分。通过一次比较,将查找区间缩小一半。 折半查找是一种高效的查找方法。它可以明显减少比较次数,提高查找效率。但是,折半查找的先决条件是查找表中的数据元素必须有序。 算法步骤描述: st
【排序算法】冒泡排序原理及Java实现
冒泡排序顾名思义就是整个过程像气泡一样往上升,单向冒泡排序的基本思想是(假设由小到大排序):对于给定n个记录,从第一个记录开始依次对相邻的两个记录进行比较,当前面的记录大于后面的记录时,交换位置,进行一轮比较和换位后,n个记录的最大记录将位于第n位,然后对前(n-1)个记录进行第二轮比较;重复该过程,直到记录剩下一个为止。
区间树查找算法
一、题目 rnrn  题目:区间树查找算法rn  实验目的:实现有效的区间树查找算法rn二、算法思想rn1、基本概念:rnrn区间:一个事件占用的时间rn闭区间:实数的有序对[t1,t2],使t1≤t2rn区间的对象表示:[t1,t2]可以用对象i表示,有两个属性:rnlow[i]=t1//起点或低点rnhigh[i]=t2//终点或高点rn区间的重叠:i∩i’≠Ø ⇔(low[i]≤high[i
java实现查找算法——折半查找(二分查找)
折半查找算法折半查找(Binary Search)又称为二分查找,其要求数据序列呈线性结构,也就是经过排序的。对于没有经过排序的,可以查阅我之前的排序算法文章进行预排序,然后进行折半查找操作。譬如数组{1,2, 3, 4, 5, 6, 7, 8, 9},查找元素6,用二分查找的算法执行的话,其顺序为: 1.第一步查找中间元素,即5,由于5<6,则6必然在5之后的数组元素中,那么就在{6, 7, 8,
Java冒泡排序(升序和降序)
冒泡排序是简单排序方式中的一种,其排序思想为:第一个数和第二个数进行比较,如果第一个数大于第二个数,则交换位置,否则位置不变。以新的数据位置继续比较第二个数和第三个的大小,以此类推,则最终最大的数会排在最后一位,此时为升序排序;反之为降序排序。 /** 冒泡升序排序 **/ public static int[] ascSort(int[] param) { int
数据结构Java版的查找算法实现
import java.util.Arrays;nimport java.util.HashMap;nimport java.util.Iterator;nimport java.util.Set;nn/**n * 查找的基本算法:n * - 顺下查找n * -基于线性表的查找(静态查找)- 折半
java语言编写的数组冒泡排序法
好久不用这些基本的算法了,都有点忘记了,今天复习一下。冒泡排序法是通过循环替换的方式,将数组中的值按照升序或者降序进行排列,这里的示例是按照降序的顺序进行排列。 public class BubbleSort {   public static void main(String[] args) {     int[] arr={6,3,8,2,9,1};     System.out
分块查找算法实现
分块查找,是对顺序查找的一种改进。 将查找表分成若干子表(块),并对子表建立索引表。 索引表包括:关键字段、起始位置和块表长度。
Java查找算法
1:线性查找算法 (这个就是典型的线性查找,从头到尾) //查找数据     //我们是根据什么来查找呢?我们是根据值来查找,返回她的所有值     public int search(long value){         int i;//i在外面进行一个判断,然后在循环里面赋值 //        比如说我查找这个15,arry.insert(15);,那么她的索引是2
Java中常见的查找算法
对于查找算法而言,常用“其关键字和给定值进行过比较的记录个数的平均值”作为衡量查找算法的依据。 静态标的查找: 顺序查找:从表的第一个或者是最后一个记录开始查找,逐个将表记录的关键字和给定值进行比较,相等则查找成功,不相等则失败。 折半查找:(针对有序序列) 折半查找的前提条件是在一个有序的序列中。首先确定待查记录所在的区间,然后逐步的缩小范围区间直到找到或者找不到该记录为止。与数学中
Java 常用查找算法
面试中经常会问一些查找算法,今天来总结一下常用的查找算法一、顺序查找描述:从表中的第一个或者是最后一个记录开始,将表中记录的关键字和给定的值进行逐个比较,若某个记录的关键字和给定值相             等,则查找成功,若表中所记录的关键字和给定值都不相等,则查找失败。算法实现: /** * 顺序查找 * * @param searchKey 要查找的值 ...
Java实现常见的查找算法--二叉树
参考:https://blog.csdn.net/smile_from_2015/article/details/72190562?utm_source=gold_browser_extension 二叉排序树 目标是插入和查找同样高效 假设我们的数据集开始只有一个数{62}, 然后现在需要将88插入数据集,于是数据集成了{62,88},还保持着从小到大有序。再查找有没有58,没有则插入,...
java简单实现冒泡 快速 选择排序
package com.排序;public class 冒泡排序 {/* * 冒泡排序,就是将第一个记录的值和第二个记录的值进行比较 * 如果,前面的值比后面的值大,则交换位置 * 反之,则不交换位置 * 这样经过这样的一趟后,最大的值排在了最后面。所以下次循环的时候,可以少循环一次。 * */private static void maopao(Integer [] a){
Java-十种内部排序实现(选择,冒泡,插入,希尔,堆,归并,快速,基数,计数,桶)及代码下载
选择排序 冒泡排序 插入排序 希尔排序 堆排序 归并排序 快速排序 基数排序 计数排序 桶排序 1. 选择排序这个排序方法最简单,废话不多说,直接上代码:public class SelectSort { /** * 选择排序 * 思路:每次循环得到最小值的下标,然后交换数据。 * 如果交换的位置不等于原来的位置,则不交换。 */ public
三种常用排序算法(冒泡、选择、快速)的Java实现
学习Java有一阵子了,现在还处于比较初级的水平,能够把简单的程序写对就不错了,更不用谈现在能够拿Java做什么了。        学完了两段网络视频课程,接下来找本书简单看看。只要有了一个初步的认识,接下来的东西应该可以更加顺利一些。学习编程最好的方法就是练手了,现在还不知道有什么比较好的东西可以尝试,不过跑不出一般教程的排序算法还是可以尝试一下的。 1,冒泡排序算法 packagebub
七大查找算法(附C语言代码实现)
转自:http://www.cnblogs.com/leezx/p/5719012.html 阅读目录 1、顺序查找 2、二分查找 3、插值查找 4、斐波那契查找 5、树表查找 6、分块查找 7、哈希查找 查找是在大量的信息中寻找一个特定的信息元素,在计算机应用中,查找是常用的基本运算,例如编译程序中符号表的查找。本文简单概括性的介绍了常见的七种查找算法,说是
Java 查找算法
二分查找 Hash表 二叉树 B Tree
Java中的冒泡排序原理及实现方法
冒泡排序 1、原理:每一次循环都两两比较,直到最后,如下图就是两次循环的比较方式 (以上图片网络借用) 2、代码: public class BubbleSortTest { //冒泡排序法 public static void bubbleSort(int[] a) { for(int i = 0; i { for(int j = 0; j { if(a[j] >
JAVA数组——冒泡排序法(升序)
public class App {  public static void main(String[] args) {  int data[] = new int[]{9,7,5,4,6,8,1,};  sort(data);  print(data);   } public static void sort(int arr[]){  for(int x=0;x&amp;lt;arr.length;x+...
javascript 实现冒泡算法对数组进行排序
原理:(升序)1. 从第一位开始循环比较相邻的两个值,如果左边的比右边的大就将两个值交换,一次循环之后最右边的值就是最大了2. 反复重复第一步的操作,已经“冒泡”到元素右边的元素不用比较,直到排序完成。代码: var examplearr=[8,94,15,88,55,76,21,39]; function sortArr(orginArr) { var arr = ...
js冒泡排序及二分法查找
JavaScript冒泡排序: var arr = [5,0,-56,90,12]; var flag = false;//标志位进行优化,数组本来就是有序序列的话,无需再排序 //先进行大的排序 for(var i=0;i<arr.length-1;i++){ //小的排序 for(var j=0;j<arr.
JAVA-快速查找算法
快速查找算法,可以根据想要找的是第几个大的数,每次循环都能固定下来一个数在数组完整排完序之后的位置,每次循环都能定一个数的位置,如果当前固定的数的位置和用户要找的第几个数匹配,则就直接返回。例如我要找第二大的数,如果循环一次固定的数的下标是1,那就是当前需要找的数。代码如下: // 快速查找算法 public static int quickSelect(int[] arr, int
java最优有序查找——红黑树(RBT)算法
在大量数据中常用的查找数据的做法有四类:顺序查找,二分查找,二叉树查找(BST),红黑树查找(RBT)。 这四类查找方法分别对应着四种基本思想原理: 顺序查找 —— 无序简单查找 二分查找 —— 有序查找,每次折半搜索,插入数据费时 二叉树查找(BST) —— 不平衡二叉树有序查找,插入与搜索综合性能较优 红黑树查找(RBT) —— 平衡二叉树有序查找,插入与搜索
使用冒泡倒序排序
/// rn        /// 使用冒泡倒序排序rn        /// rn        /// rn        static void Main(string[] args)rn        {rn            int[] num = new int[
Java代码 写一个冒泡排序
第一次使用这个编辑器好好用醉了。。。刚写了一篇,结果不小心给关了,还要重新写。。。 冒泡排序 放空了这么就,终于知道自己该干什么,找到实习之后这又是一个新的开始,不要羡慕别人,因为你在别人眼里也是独一无二的言归正传,我是用Java写的冒泡排序,虽然冒泡排序是排序算法里面比较简单的,但是自己写出来之后还是很有成就感的。 在写的过程中遇到的问题就是swap方法的调用问题,一定要类型相同才能调用 冒泡
Java查找算法(四): 二叉排序树
[ 为什么使用二叉排序树 ] rnrn如果查找的数据集是有序线性表,并且是顺序存储的,查找可以用折半、插值等查找算法来实现,但是因为有序,在插入和删除操作上,需要耗费大量的时间。rnrn因为二叉排序树使用链接的方式存储,在执行插入或删除操作时不用移动元素,所以插入删除的时间性能比较好rnrnrnrnrnrnrn[ 二叉排序树的特点 ] rnrn二叉排序树又称为二叉查找树,它或者是一颗空树,或者是具
【手写排序算法及优化】冒泡排序
c++代码 #include void Print(int A[],int len) { for(int i=0;i { cout } cout } void BubbleSort(int A[], int len) { int i,j,temp; int flag; for(i=0;i { flag =0; for(j=0;j { if(A[
iOS编程——Swift实现冒泡排序算法 以及优化
冒泡排序大家都很了解了,我的理解:其实就是倒序两两比较,把小的数依次往前放。执行完以后,再遍历剩下的n-1个数。其最坏情况的时间维度为O(n²)rn代码如下:rn func swap(inout array: [T], index1: Int, index2: Int){n var temp = array[index1]n array[index1] = arr
顺序表创建以及查找排序算法(含有顺序查找算法、带哨兵站顺序查找、折半查找算法、冒泡排序)的C++实现在vs2013环境下实现
查找排序算法的C++实现在vs2013环境下实现 折半查找算法带哨兵站顺序查找算法冒泡排序含有顺序查找算法、带哨兵站顺序查找、折半查找算法、冒泡排序 #include #include #define MAX 100 #define MaxSize 100 typedef int DataType; typedef int KeyType; using name
冒泡排序算法 Java 实现过程及详解
冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。   冒泡排序算法的运作如下:  比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素作同样
java基础面试题:冒泡排序
java基础面试题:冒泡排序
冒泡,去重,快速排序选择排序几种算法
arr =[‘9’,’8’,’7’,’6’,’5’,’4’,’3’,’2’,’1’,’0’]冒泡排序有两个循环外循环循环一次能把乱序数组里的最大值找出来放在相应的位置,内循环循环一次是执行外循环找到这个数的过程的过程 function maopao(){ console.log(arr); for(var i=0;i<arr.length-1;i++){ for(va
用Java写一个冒泡排序。
import java.util.Comparator;   /**  * 排序器接口(策略模式: 将算法封装到具有共同接口的独立的类中使得它们可以相互替换)  * @author骆昊  *  */ public interface Sorter {      /**     * 排序     * @param list 待排序的数组     */    publ
排序算法之冒泡排序的思想以及Java实现
1 基本思想 n设排序表长为n,从后向前或者从前向后两两比较相邻元素的值,如果两者的相对次序不对(A[i-1] > A[i]),则交换它们,其结果是将最小的元素交换到待排序序列的第一个位置,我们称它为一趟冒泡。下一趟冒泡时,前一趟确定的最小元素不再参与比较,待排序序列减少一个元素,每趟冒泡的结果把序列中最小的元素放到了序列的”最前面”。2,算法的实现(Java)package Algorithm;
java用递归实现折半查找法
 
Java之常见的几种排序算法-插入、选择、冒泡、快排、堆排等
本文转载自http://blog.csdn.net/zhangerqing/article/details/8831542   Java面试宝典系列之基础排序算法 作者:egg 邮箱:xtfggef@gmail.com 微博:http://weibo.com/xtfggef 博客:http://blog.csdn.net/zhangerqing(转载请说明出
【算法分析】查找算法:二分查找、顺序查找
08年9月入学,12年7月毕业,结束了我在软件学院愉快丰富的大学生活。此系列是对四年专业课程学习的回顾,索引参见:http://blog.csdn.net/xiaowei_cqu/article/details/7747205 查找算法 查找算法是在存在的序列(list) 中查找特定的目标(target),要求序列中每个记录必须与一个关键词(key)关联才能进行查找。
请编程实现一个冒泡排序算法?
int [] array = new int ; int temp = 0 ; for (int i = 0 ; i { for (int j = i + 1 ; j { if (array[j] { temp = array[i] ; array[i] = array[j] ; array[j] = temp ; } } }
Java中的冒泡排序算法-简单实例
冒泡算法的原理实现:(从小到大排序)   1:比较相邻的两个元素,如果第一个比第二个大就交换位置。   2:对每一对相邻的元素进行比较,从开始第一队到结尾的最后一对,这样最后的元素就是最大的了。   3:每一次这样循环一次之后都会有一个最大的数在后面,每确定一个最大的数,那个数在最后面不动它,这是内循环。   4:每次循环确定最大得数沉到最底下,一共要循环数组的长度减一次,这是外循环。
相关热词 c#框架设计 c# 删除数据库 c# 中文文字 图片转 c# 成员属性 接口 c#如何将程序封装 16进制负数转换 c# c#练手项目 c#字段在哪加入 c# 的asp网页倒计时 c# 模拟 鼠标
立即提问