java冒泡排序代码

❶ 冒泡排序如何使用java语言完成

冒泡排序的原理：

从第一个元素开始，将相邻的两个元素依次进行比较，直到最后两个元素完成比较。如果前一个元素比后一个元素大，则交换它们的位置。整个过程完成后最后一个元素就是最大值，完成第一轮比较，后边通过for循环依次完成后续比较。

运行代码如下：

package day01;

public class 冒泡 {

public static void main(String[] args) {

int []arr=new int[] {12,45,33,46,3};

System.out.println("排序之前的元素顺序:");

for(int i=0;i<arr.length;i++)

{

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

}

int t;

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

{

for(int x=0;x<arr.length-1;x++)

{

if(arr[x]>arr[x+1])

{

t=arr[x];

arr[x]=arr[x+1];

arr[x+1]=t;

}

}

}

System.out.println();

System.out.println("排序之后的元素顺序:");

for(int k=0;k<arr.length;k++)

{

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

}

}

}

运行结果截图：

(1)java冒泡排序代码扩展阅读：

（1）冒泡排序每一轮把一个最大的元素放在数组的最后

（2）如果想要实现倒叙比较输出可以把代码判断大小的部分改为下边代码即可。

if(arr[x]>arr[x+1])

{

t=arr[x];

arr[x]=arr[x+1];

arr[x+1]=t;

}

（3）使用知识点：数组length的使用，数组的定义，for循环的嵌套。

❷ 求JAVA冒泡排序法的代码

你好！很高兴能帮到你。
由于你刚学Java，所以一些编程规范是需要注意的，而我提供给你的答案看起来虽然有点复杂，不过采用了面向对象的编程思想，尽量做到低耦合高内聚，同时冒泡算法也做了升级，为冒泡的高级快速排序算法，不过为了对比，也保存了传统的冒泡算法。
需要讲解一下，算法本身不难，难在如何做到编程规范、以及方便修改、易于修改、使得程序灵活、低耦合高内聚。
算法部分请看Bubble类，里面有两种算法，有注释。
主类为TestBubble，主要用于调用Bubble对象运行算法、StuInfo对象提供学生作者信息、Info对象提供运行过程中提示信息。
运行结果如下（Bubble类为核心算法类）：
************************************
run：
请输入您将要输入整数的个数：
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; i < intArray.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; i < getNum(); i++) {
System.out.print((i + 1) + ":");
acceptArray[i] = reader.nextInt();
}
return acceptArray;
}

/**
* 打印原始输入数据
* @param intArray
*/
public void showAcceptAsIntArray(int[] intArray){
for (int i = 0; i < getNum(); 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[i + 1]) {
temp = acceptArray[i];
acceptArray[i] = acceptArray[i + 1];
acceptArray[i + 1] = 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 (i < j) {
while (i < j && r[i] <= r[j]) {
j--;
}
if (i < j) {
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 (first < end) {
int pivot = partition(r, first, end); //调用划分函数
quick(r, first, pivot - 1);
quick(r, pivot + 1, 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中编写冒泡排序算法 bubbleSort(int[]arr)

/**
*des:冒泡排序算法的一般性策略：搜索整个值列，比较相邻元素，如果两者的相对次序不对，
*则交换它们，其结果是最大值“想水泡一样”移动到值列的最后一个位置上，
*这也是它在最终完成排序的值列中合适的位置。
*然后再次搜索值列，将第二大的值移动至倒数第二个位置上，重复该过程，直至将所有元素移动到正确的位置上。
*2014-4-9-zbl
**/
publicclassBubbleSort{

/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Comparable[]a={4,9,23,1,45,27,5,2};
bubbleSort1(a);

Comparable[]b={4,9,23,1,45,27,5,2};
bubbleSort2(b);

int[]c={4,9,23,1,45,27,5,2};
bubbleSort3(c);
}

publicstaticvoidbubbleSort3(int[]data)
{
inttemp;
for(inti=0;i<data.length;i++){
intflag=0;
for(intj=0;j<data.length-i-1;j++){
if(data[j]<data[j+1]){
temp=data[j];
data[j]=data[j+1];
data[j+1]=temp;
flag=1;
}
}
if(flag==0)break;
System.out.print("第"+i+"遍:{");
for(intk=0;k<data.length;k++){
System.out.print(data[k]+",");
}
System.out.println("}");
}
}

publicstaticvoidbubbleSort1(Comparable[]data)
{
Comparabletemp;
for(intposition=data.length-1;position>=0;position--){
intflag=0;
for(intscan=0;scan<position;scan++){
if(data[scan].compareTo(data[scan+1])<0){
temp=data[scan];
data[scan]=data[scan+1];
data[scan+1]=temp;
flag=1;
}
}
if(flag==0){
break;
}
System.out.print("第"+position+"遍:{");
for(inti=0;i<data.length;i++){
System.out.print(data[i]+",");
}
System.out.println("}");
}
}

publicstaticvoidbubbleSort2(Comparable[]data)
{
Comparabletemp;
for(intposition=0;position<data.length-1;position++){
intflag=0;
for(intscan=0;scan<data.length-1-position;scan++){
if(data[scan].compareTo(data[scan+1])<0){
temp=data[scan];
data[scan]=data[scan+1];
data[scan+1]=temp;
flag=1;
}
}
if(flag==0){
break;
}
System.out.print("第"+position+"遍:{");
for(inti=0;i<data.length;i++){
System.out.print(data[i]+",");
}
System.out.println("}");
}
}

}

❹ 冒泡法排序，java代码 排序1 8 5 2 4 9

publicclassTest{
	publicstaticvoidmain(String[]args){
		int[]a={1,8,5,2,4,9};
		//冒泡排序
		for(intk=0;k<a.length-1;k++){
			for(intj=k+1;j<a.length;j++){//升序把<改成>
				if(a[k]>a[j]){
					inttemp=a[k];
					a[k]=a[j];
					a[j]=temp;
				}
			}
		}
		System.out.println("排序后:");
		for(inti=0;i<a.length;i++){
			System.out.print(a[i]+"");
		}
	}
}

❺ 用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

。。。

算法：取出最大的放在最后，下次就不用比较最后一个了。*/
publicclassBubbleSort{
publicstaticvoidmain(String[]args){
int[]a={3,1,6,2,5};
//开始排序
for(inti=a.length-1;i>0;i--){
for(intj=0;j<i;j++){
if(a[j]>a[j+1]){
//交换位置
inttemp;
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
//遍历
for(inti=0;i<a.length;i++){
System.out.println(a[i]);
}
}
}

❻ 用java语言用冒泡排序如何写代码啊，求大神，求仔细代码。

纯手工，随意写的，希望对你有帮助！！
public class MaoPao{
//定义一个整形数组
int[] a = new int[10];
//中间数
int flag = 0;
//g给数组赋值
a = {14,12,21,52,36,78,45,31,33,98};
//判断
for(int i=0;i<a.length;i++){
for(int j=i+1;i<a.length;i++){
//交换位置，最大的放第一个
if(a[i]<a[j]){
flag = a[i];
a[i] = a[j];
a[j] = a[i];
}
}
}
//输出数组
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}

❼ java实现冒泡排序

你这样写，相当于只冒了一次泡，把最大的一个数，也就是最后一个数，找出来了，冒泡排序是要for循环里在嵌套一个for循环才能做出来的，外面的for循环控制冒泡多少次，里面的循环找出每次的最大值。你这样写少了外面的那个for循环，相当于只找了一次最大值。

❽ java冒泡排序

.example-btn{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.example-btn:hover{color:#fff;background-color:#47a447;border-color:#398439}.example-btn:active{background-image:none}div.example{width:98%;color:#000;background-color:#f6f4f0;background-color:#d0e69c;background-color:#dcecb5;background-color:#e5eecc;margin:0 0 5px 0;padding:5px;border:1px solid #d4d4d4;background-image:-webkit-linear-gradient(#fff,#e5eecc 100px);background-image:linear-gradient(#fff,#e5eecc 100px)}div.example_code{line-height:1.4em;width:98%;background-color:#fff;padding:5px;border:1px solid #d4d4d4;font-size:110%;font-family:Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;word-break:break-all;word-wrap:break-word}div.example_result{background-color:#fff;padding:4px;border:1px solid #d4d4d4;width:98%}div.code{width:98%;border:1px solid #d4d4d4;background-color:#f6f4f0;color:#444;padding:5px;margin:0}div.code div{font-size:110%}div.code div,div.code p,div.example_code p{font-family:"courier new"}pre{margin:15px auto;font:12px/20px Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;white-space:pre-wrap;word-break:break-all;word-wrap:break-word;border:1px solid #ddd;border-left-width:4px;padding:10px 15px} 排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。以下是冒泡排序算法：

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来
说并没有什么太大作用。 1. 算法步骤
比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
2. 动图演示

3. 什么时候最快
当输入的数据已经是正序时（都已经是正序了，我还要你冒泡排序有何用啊）。
4. 什么时候最慢
当输入的数据是反序时（写一个 for 循环反序输出数据不就行了，干嘛要用你冒泡排序呢，我是闲的吗）。 5. JavaScript 代码实现 实例 function bubbleSort ( arr ) {
    var len = arr. length ;
    for ( var i = 0 ; i arr [ j+ 1 ] :
                arr [ j ] , arr [ j + 1 ] = arr [ j + 1 ] , arr [ j ]
    return arr
7. Go 代码实现 实例 func bubbleSort ( arr [] int ) [] int {
        length := len ( arr )
        for i := 0 ; i < length ; i ++ {
                for j := 0 ; j < length - 1 - i ; j ++ {
                        if arr [ j ] > arr [ j + 1 ] {
                                arr [ j ], arr [ j + 1 ] = arr [ j + 1 ], arr [ j ]
                        }
                }
        }
        return arr
}
8. Java 代码实现 实例 public class BubbleSort implements IArraySort {

    @Override
    public int [ ] sort ( int [ ] sourceArray ) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int [ ] arr = Arrays . Of ( sourceArray, sourceArray. length ) ;

        for ( int i = 1 ; i

❾ Java冒泡排序

package net.sunyixin.acggo.test;
public class Main{

public static void outputArray(int[] arr){
String arrStr = "";
for(int i : arr){
arrStr += i + " ";
}
System.out.println(arrStr);
}

public static void swap(int[] arr, int i, int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}

/**
* 冒泡排序方法
* @param nums 排序对象
*/
public static void bubbleSort(int[] nums){
for(int i=0;i<nums.length;i++){
for(int j=0;j<nums.length-1-i;j++){
if(nums[j] > nums[j+1]){
swap(nums, j, j+1);
}
}
}
}

public static void main(String[] args){
int[] arr = new int[8];
for(int i=0;i<arr.length;i++){
arr[i] = (int)(Math.random()*100);
}
bubbleSort(arr);
outputArray(arr);
}
}