锐客网

  1. 首页 > 生活百科 > it技术 > >

数组冒泡排序java代码 数组的冒泡排序java

IT技术排序

用java写个冒泡排序？冒泡排序算法：
int类型的数组：3 1 6 2 5
第一次循环：
1 3 6 2 5
1 3 6 2 5
1 3 2 6 5
1 3 2 5 6
第二次循环：
1 3 2 5
1 2 3 5
1 2 3 5
第三次循环：
1 2 3
1 2 3
。。。
算法：取出最大的放在最后，下次就不用比较最后一个了 。*/
public class BubbleSort{
public static void main(String[] args){
int[] a = {3,1,6,2,5};
//开始排序
for(int i=a.length-1;i0;i--){
for(int j=0;ji;j){
if(a[j]a[j 1]){
//交换位置
int temp;
temp = a[j];
a[j] = a[j 1];
a[j 1] = temp;
}
}
}
//遍历
for(int i=0;ia.length;i){
System.out.println(a[i]);
}
}
}
java中冒泡排序算法的详细解答以及程序？实例说明
用冒泡排序方法对数组进行排序 。
实例解析
交换排序的基本思想是两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止 。
应用交换排序基本思想的主要排序方法有冒泡排序和快速排序 。
冒泡排序
将被排序的记录数组 R[1..n] 垂直排列 ， 每个记录 R[i] 看做是重量为 R[i].key 的气泡 。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组 R。凡扫描到违反本原则的轻气泡，就使其向上“漂浮” 。如此反复进行，直到最后任何两个气泡都是轻者在上 ， 重者在下为止 。
(1) 初始，R[1..n] 为无序区 。
(2) 第一趟扫描，从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置 。即依次比较 (R[n],R[n-1]) 、 (R[n-1],R[n-2]) 、 … 、 (R[2],R[1]); 对于每对气泡 (R[j 1],R[j]), 若 R[j 1].keyR[j].key, 则交换 R[j 1] 和 R[j] 的内容 。
第一趟扫描完毕时，“最轻”的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置 R[1] 上 。
(3) 第二趟扫描，扫描 R[2..n] 。扫描完毕时，“次轻”的气泡飘浮到 R[2] 的位置上 …… 最后 ， 经过 n-1 趟扫描可得到有序区 R[1..n] 。
注意：第 i 趟扫描时 ， R[1..i-1] 和 R[i..n] 分别为当前的有序区和无序区 。扫描仍是从无序区底部向上直至该区顶部 。扫描完毕时，该区中最轻气泡漂浮到顶部位置 R[i] 上，结果是 R[1..i] 变为新的有序区 。
冒泡排序算法
因为每一趟排序都使有序区增加了一个气泡，在经过 n-1 趟排序之后，有序区中就有 n-1 个气泡，而无序区中气泡的重量总是大于等于有序区中气泡的重量，所以整个冒泡排序过程至多需要进行 n-1 趟排序 。
若在某一趟排序中未发现气泡位置的交换，则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则，因此，冒泡排序过程可在此趟排序后终止 。为此，在下面给出的算法中，引入一个布尔量 exchange, 在每趟排序开始前，先将其置为 FALSE。若排序过程中发生了交换，则将其置为 TRUE。各趟排序结束时检查 exchange, 若未曾发生过交换则终止算法，不再进行下趟排序 。
具体算法如下：
void BubbleSort(SeqList R){
//R(1..n) 是待排序的文件 ， 采用自下向上扫描，对 R 做冒泡排序
int i,j;
Boolean exchange; // 交换标志
for(i=1;in;i){ // 最多做 n-1 趟排序
exchange=FALSE; // 本趟排序开始前，交换标志应为假
for(j=n-1;j=i;j--) // 对当前无序区 R[i..n] 自下向上扫描
if(R[j 1].keyR[j].key){ // 交换记录
R[0]=R[j 1]; //R[0] 不是哨兵，仅做暂存单元
R[j 1]=R[j];
R[j]=R[0];
exchange=TRUE; // 发生了交换，故将交换标志置为真
}
if(!exchange) // 本趟排序未发生交换，提前终止算法
return;
} //endfor( 外循环 )
}//BubbleSort
public class BubbleSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
ListInteger lstInteger = new ArrayListInteger();
lstInteger.add(1);
lstInteger.add(1);
lstInteger.add(3);
lstInteger.add(2);
lstInteger.add(1);
for(int i = 0; ilstInteger.size(); i){
System.out.println(lstInteger.get(i));
}
System.out.println("排序之后-----------------");
lstInteger = sortList(lstInteger);
for(int i = 0; ilstInteger.size(); i){
System.out.println(lstInteger.get(i));
}
}
public static ListInteger sortList(ListInteger lstInteger){
int i,j,m;
boolean blChange;
int n = lstInteger.size();
for(i=0;in;i){
blChange = false;
for(j = n-1; ji ; j-- ){
if(lstInteger.get(j)lstInteger.get(j-1)){
m = lstInteger.get(j-1);
lstInteger.set(j-1, lstInteger.get(j));
lstInteger.set(j, m);
blChange = true;
}
}
if(!blChange){
return lstInteger;
}
}
return lstInteger;
}
}
归纳注释
算法的最好时间复杂度: 若文件的初始状态是正序的, 一趟扫描即可完成排序 。所需的关键字比较次数 C 和记录移动次数 M 均达到最小值，即 C(min)=n-1, M(min)= 0。冒泡排序最好的时间复杂度为 O(n) 。
算法的最坏时间复杂度: 若初始文件是反序的，需要进行 n-1 趟排序 。每趟排序要进行 n-1 次关键字的比较 (1=i=n-1), 且每次比较都必须移动记录 3 次 。在这种情况下，比较和移动次数均达到最大值，即 C(max)=n(n-1)/2=O(n ^2 )，M(max)=3n(n-1)/2=O(n ^2 ) 。冒泡排序的最坏时间复杂度为 O(n^2 ) 。
算法的平均时间复杂度为 O(n^2 ) 。虽然冒泡排序不一定要进行 n-1 趟 ， 但由于它的记录移动次数较多，故平均时间性能比直接插入排序要差得多 。
算法稳定性：冒泡排序是就地排序，且它是稳定的 。
算法改进：上述的冒泡排序还可做如下的改进，① 记住最后一次交换发生位置 lastExchange 的冒泡排序( 该位置之前的相邻记录均已有序 ) 。下一趟排序开始时，R[1..lastExchange-1] 是有序区， R[lastExchange..n] 是无序区 。这样 ， 一趟排序可能使当前有序区扩充多个记录 ， 从而减少排序的趟数 。② 改变扫描方向的冒泡排序 。冒泡排序具有不对称性 。能一趟扫描完成排序的情况，只有最轻的气泡位于 R[n] 的位置，其余的气泡均已排好序，那么也只需一趟扫描就可以完成排序 。如对初始关键字序列 12、18、42、44、45、67、94、10 就仅需一趟扫描 。需要 n-1 趟扫描完成排序情况，当只有最重的气泡位于 R[1] 的位置，其余的气泡均已排好序时 ， 则仍需做 n-1 趟扫描才能完成排序 。比如对初始关键字序列：94、10、12、18、42、44、45、67 就需 7 趟扫描 。造成不对称性的原因是每趟扫描仅能使最重气泡“下沉”一个位置，因此使位于顶端的最重气泡下沉到底部时，需做 n-1 趟扫描 。在排序过程中交替改变扫描方向，可改进不对称性
java 冒泡排序怎么写？方法一:package basic.javastu;public class NumberTest {
/*** 实现冒泡程序1*/public static void main(String[] args) {// TODO Auto-generated method stub
int[] numb=new int[]{3,42,57,1,32,24};
int len=numb.length;
int i,j;
int temp;
System.out.println("排序前数组冒泡排序java代码的数组各个值:");
for(i=0;ilen;i)
{
System.out.print(numb[i] "\t");
}
System.out.println("\n");
for(i=1;i=len;i)
{
for(j=len-1;j=1;j--)
{
if(numb[j]numb[j-1])
{
temp=numb[j];
numb[j]=numb[j-1];
numb[j-1]=temp;
}
}
}
System.out.println("排序后数组冒泡排序java代码的数组各个值:");
for(i=0;ilen;i)
{
System.out.print(numb[i] "\t");
}
}
【数组冒泡排序java代码 数组的冒泡排序java】 }
方法二:package basic.javastu;public class NumberTest2 {
/*** 实现冒泡程序2*/public static void main(String[] args){// TODO Auto-generated method stub
int[] numb=new int[]{3,42,57,1,32,24};
int leng=numb.length;
System.out.println("排序前数组冒泡排序java代码的数组各个值:");
for(int i=0;ileng;i)
{
System.out.print(numb[i] "\t");
}
System.out.println("\n");
swap(numb);
System.out.println("数组排序后:");for(int i=0;ileng;i)
{
System.out.print(numb[i] "\t");
}}
private static int[] swap(int[] numb){int n2[]=numb;int len=n2.length;int i,j;int temp;for(i=1;i=len;i)
{
for(j=len-1;j=1;j--)
{
if(n2[j]n2[j-1])
{
temp=n2[j];
n2[j]=n2[j-1];
n2[j-1]=temp;
}
}
}return n2;}}
方法三:package basic.javastu;public class NumberTest3 {
/*** 实现冒泡程序2*/public static void main(String[] args){// TODO Auto-generated method stub
int[] numb=new int[]{3,42,57,1,32,24};
int leng=numb.length;
System.out.println("排序前数组冒泡排序java代码的数组各个值:");
for(int i=0;ileng;i)
{
System.out.print(numb[i] "\t");
}
System.out.println("\n");
swap(numb);
System.out.println("数组排序后:");for(int i=0;ileng;i)
{
System.out.print(numb[i] "\t");
}}
private static void swap(int[] numb){int len=numb.length;int i,j;int temp;for(i=1;i=len;i)
{
for(j=len-1;j=1;j--)
{
if(numb[j]numb[j-1])
{
temp=numb[j];
numb[j]=numb[j-1];
numb[j-1]=temp;
}
}
}}}
Java中的ArrayList怎么进行冒泡排序java中的ArrayList进行冒泡排序数组冒泡排序java代码 ， 主要是循环遍历取出数据数组冒泡排序java代码，然后进行比较排序数组冒泡排序java代码，如下代码数组冒泡排序java代码：
package com.qiu.lin.he;
import java.util.ArrayList;
public class Ceshi {
public static void main(String[] args) {
ArrayListInteger list = new ArrayListInteger();
list.add(76);
list.add(4);
list.add(786);
list.add(43);
list.add(21);
list.add(432);
list.add(10);
for (int i = 0; ilist.size() - 1; i) {
for (int j = 1; jlist.size() - i; j) {
Integer a;
if (list.get(j - 1).compareTo(list.get(j))0) { // 比较两个整数的大小
a = list.get(j - 1);
list.set((j - 1), list.get(j));
list.set(j, a);//交换数据
}
}
}
for (Integer s : list) {
System.out.println(s.intValue());//输出arraylist的数据
}
}
}
运行结果如下：
java冒泡排序法代码冒泡排序是比较经典数组冒泡排序java代码的排序算法 。代码如下数组冒泡排序java代码：
for(int i=1;iarr.length;i){
for(int j=1;jarr.length-i;j){
//交换位置
}
拓展资料数组冒泡排序java代码：
原理：比较两个相邻的元素数组冒泡排序java代码，将值大的元素交换至右端 。
思路：依次比较相邻的两个数数组冒泡排序java代码，将小数放在前面，大数放在后面 。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后 。然后比较第2个数和第3个数 ， 将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后 。重复第一趟步骤，直至全部排序完成 。
第一趟比较完成后，最后一个数一定是数组中最大的一个数，所以第二趟比较的时候最后一个数不参与比较；
第二趟比较完成后，倒数第二个数也一定是数组中第二大的数，所以第三趟比较的时候最后两个数不参与比较；
依次类推，每一趟比较次数-1；
??
举例说明：要排序数组：int[] arr={6,3,8,2,9,1};
for(int i=1;iarr.length;i){
for(int j=1;jarr.length-i;j){
//交换位置
}
参考资料：冒泡排序原理
求JAVA冒泡排序法的代码你好数组冒泡排序java代码！很高兴能帮到你 。
由于你刚学Java，所以一些编程规范是需要注意的，而我提供给你的答案看起来虽然有点复杂，不过采用数组冒泡排序java代码了面向对象的编程思想，尽量做到低耦合高内聚，同时冒泡算法也做了升级，为冒泡的高级快速排序算法，不过为了对比 ， 也保存了传统的冒泡算法 。
需要讲解一下，算法本身不难，难在如何做到编程规范、以及方便修改、易于修改、使得程序灵活、低耦合高内聚 。
算法部分请看Bubble类 ， 里面有两种算法，有注释 。
主类为TestBubble ， 主要用于调用Bubble对象运行算法、StuInfo对象提供学生作者信息、Info对象提供运行过程中提示信息 。
运行结果如下（Bubble类为核心算法类）数组冒泡排序java代码：
************************************
run数组冒泡排序java代码：
请输入您将要输入整数的个数：
10
请输入一串数字进行冒泡排序，注意：每次只输入一个，输完则回车
1:10
2:23
3:11
4:56
5:45
6:26
7:59
8:28
9:84
10:79
初始序列的数组为：
10 23 11 56 45 26 59 28 84 79
学号：200815009* 班级:08软件3班 姓名：叶科良
排序好的数组为：
10 11 23 26 28 45 56 59 79 84
源代码如下：
***************************************************
package testBubble;
import java.io.Reader;
import java.util.Scanner;
/**
*
* @author yekeliang
*/
public class TestBubble {
private CommandLineBubbleRunner commandLineBubbleRunner;
private int arraySize;
private int[] intArray;
private StuInfo stuInfo;
private Info info;
/**
* 测试方法
* @param args
*/
public static void main(String[] args) {
TestBubble test = new TestBubble();
}
/**
* 构造方法
* 调用初始化学生数据、接收命令行整数、展示结果3个成员方法
*/
public TestBubble() {
initMemb();
initData();
runBubble();
showResult(this.getIntArray());
}
/**
* 初始化学生数据
*/
private void initData() {
stuInfo.setStuNum("200815009*");
stuInfo.setStuClass("08软件3班");
stuInfo.setStuName("叶科良");
info.setInputIntNumInfo("请输入您将要输入整数的个数：");
info.setInputIntInfo("请输入一串数字进行冒泡排序，注意：每次只输入一个，输完则回车");
info.setShowInputInfo("初始序列的数组为：");
info.setShowResultInfo("排序好的数组为：");
info.setInputErrorInfo("对不起 ， 输入有误！请输入整数.");
}
/**
* 接收命令行整数，使用冒泡算法
*/
private void runBubble() {
try{
System.out.println(info.getInputIntNumInfo());
setArraySize(getCommandLineBubbleRunner().getArraySize());
System.out.println(info.getInputIntInfo());
setIntArray(getCommandLineBubbleRunner().getAcceptAsIntArray(getArraySize()));
System.out.println(info.getShowInputInfo());
getCommandLineBubbleRunner().showAcceptAsIntArray(getIntArray());
Bubble.quick(getIntArray());
} catch(java.util.InputMismatchException e) {
System.out.println(info.getInputErrorInfo());
}
}
/**
* 展示结果
*/
private void showResult(int intArray[]) {
System.out.println("\n"stuInfo.toString());
System.out.println(info.getShowResultInfo());
for (int i = 0; iintArray.length; i) {
System.out.print(intArray[i]" ");
}
}
private void initMemb() {
stuInfo = new StuInfo();
info = new Info();
commandLineBubbleRunner = new CommandLineBubbleRunner();
}
public CommandLineBubbleRunner getCommandLineBubbleRunner() {
return commandLineBubbleRunner;
}
public void setCommandLineBubbleRunner(CommandLineBubbleRunner commandLineBubbleRunner) {
this.commandLineBubbleRunner = commandLineBubbleRunner;
}
public int getArraySize() {
return arraySize;
}
public void setArraySize(int arraySize) {
this.arraySize = arraySize;
}
public int[] getIntArray() {
return intArray;
}
public void setIntArray(int[] intArray) {
this.intArray = intArray;
}
private void getStuInfo() {}
}
/**
*
* @author 叶科良
*/
class CommandLineBubbleRunner {
public int num;//输入整数个数
/**
* 从命令行中读取需要输入的整数个数
* @return 需要输入的整数个数
*/
public int getArraySize() {
Scanner reader1 = new Scanner(System.in);
num = reader1.nextInt();
return num;
}
/**
* 指定数组大?。?从命令行接收整数
* @param arraySize 数组大小
* @return 原始整数数组
*/
public int[] getAcceptAsIntArray(int arraySize) {
int[] acceptArray = new int[arraySize];
Scanner reader = new Scanner(System.in);
for (int i = 0; igetNum(); i) {
System.out.print((i1)":");
acceptArray[i] = reader.nextInt();
}
return acceptArray;
}
/**
* 打印原始输入数据
* @param intArray
*/
public void showAcceptAsIntArray(int[] intArray){
for (int i = 0; igetNum(); i) {
System.out.print(intArray[i]" ");
}
}
/**
* 取得数组大小
* @return
*/
public int getNum() {
return num;
}
}
class Bubble {
/**
* 给定一个数组 ， 使用冒泡算法进行排序
* @param acceptArray 给定的一个数组
* @return 排序好的数组
*/
public static int[] getResultAsIntArray(int[] acceptArray) {
int i, temp;
for (i = 0; i(acceptArray.length - 1); i) {//两两进行比较 ， 符合条件的进行交换
if (acceptArray[i]acceptArray[i1]) {
temp = acceptArray[i];
acceptArray[i] = acceptArray[i1];
acceptArray[i1] = temp;
}
}
return acceptArray;
}
/**
* 快速冒泡排序算法
* @param r 输入的整数数组
* @param first 数组第一个下标
* @param end 数组最后一个下标
* @return 排好序的整数数组
*/
public static int partition(int[] r, int first, int end) {
int i, j;
i = first;
j = end;
while (ij) {
while (ijr[i] = r[j]) {
j--;
}
if (ij) {
int temp;
temp = r[i];
r[i] = r[j];
r[j] = temp;
}
}
return i;
}
public static void quick(int[] r, int first, int end) {//利用递归反复划分
if (firstend) {
int pivot = partition(r, first, end);//调用划分函数
quick(r, first, pivot - 1);
quick(r, pivot1, end);
}
}
public static int[] quick(int[] r){
quick(r,0,r.length-1);
return r;
}
}
class Info {
private String inputIntNumInfo;//提示用户输入整数个数的消息语句
private String inputIntInfo;//提示用户输入整数的消息语句
private String showInputInfo;//提示显示用户输入整数的消息语句
private String inputErrorInfo;//提示用户输入有误消息语句
private String showResultInfo;//提示显示排序结果
public String getInputIntNumInfo() {
return inputIntNumInfo;
}
public void setInputIntNumInfo(String inputIntNumInfo) {
this.inputIntNumInfo = inputIntNumInfo;
}
public String getInputIntInfo() {
return inputIntInfo;
}
public void setInputIntInfo(String inputIntInfo) {
this.inputIntInfo = inputIntInfo;
}
public String getShowInputInfo() {
return showInputInfo;
}
public void setShowInputInfo(String showInputInfo) {
this.showInputInfo = showInputInfo;
}
public String getInputErrorInfo() {
return inputErrorInfo;
}
public void setInputErrorInfo(String inputErrorInfo) {
this.inputErrorInfo = inputErrorInfo;
}
public String getShowResultInfo() {
return showResultInfo;
}
public void setShowResultInfo(String showResultInfo) {
this.showResultInfo = showResultInfo;
}
}
class StuInfo {
private String stuNum;//学生学号
private String stuName;//学生姓名
private String stuClass;//学生班级
@Override
public String toString() {
return "学号："getStuNum()" 班级:"getStuClass()" 姓名："getStuName();
}
public String getStuNum() {
return stuNum;
}
public void setStuNum(String stuNum) {
this.stuNum = stuNum;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public String getStuClass() {
return stuClass;
}
public void setStuClass(String stuClass) {
this.stuClass = stuClass;
}
}
关于数组冒泡排序java代码和数组的冒泡排序java的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：Google为什么支持python，谷歌为什么开源

    下一篇：快手直播卖货伴侣下载什么，快手直播卖货助手