求java的冒泡排序程序！！！急急

我的是冒泡算法的演示：

public class MaoPao {

public void text(int[] listNumber){

int n_length = listNumberlength;

Systemoutprintln("冒泡算法演示");

Systemoutprint("未排序的序列：");

print(listNumber);

paixu(listNumber);

}

/

打印输出数组

/

public void print(int[] listNumber){

for(int i=0;i<listNumberlength;i++){

if(i==0){

Systemoutprint(listNumber[i]);

}else{

Systemoutprint(","+listNumber[i]);

}

}

Systemoutprintln();

}

/

排序

/

public void paixu(int[] listNumber){

int n=0;

int k=0;

boolean flag = false;

int number = 0;

//第一次找左边大于右边的两个数

for(int i=0;i<listNumberlength-1;i++){

if(listNumber[i]>listNumber[i+1]){

flag = true;

k = i;

break;

}

}

while(flag == true){

//如果找到就从第一个左边大于右边的两个数开始调换位置

for(int i=k;i<listNumberlength-1;i++){

if(listNumber[i]>listNumber[i+1]){

n = listNumber[i];

listNumber[i] = listNumber[i+1];

listNumber[i+1] = n;

}else{

break;

}

}

number++;

Systemoutprint("第"+number+"次排序后： ");

print(listNumber);

flag = false;

//一次排序后再判断一次

for(int i= 0;i<listNumberlength-1;i++){

if(listNumber[i]>listNumber[i+1]){

flag = true;

k=i;

break;

}

}

}

}

public static void main(String[] args){

int[] l_number = new int[]{3,6,5,8,4,7,3};

MaoPao mp = new MaoPao();

mptext(l_number);

}

}

感觉还有错的地方，请赐教

原理：比较两个相邻的元素，将值大的元素交换至右端。

思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第

1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大

数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至

全部排序完成。

publicclass BubbleSort {

publicstaticvoid main(String[] args) { int[] arr={12,45,23,67,56,34,99,123}; Systemoutprintln("排序前数组为：");

for(int n:arr){

Systemoutprint(n+"");

}

for(int i=0;i<arrlength-1;i++){//外层循环控制排序趟数

for(int j=0;j<arrlength-1-i;j++){//内层循环控制每一趟排序多少次 if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp;

}

}

冒泡排序法思路

1：外层循环：控制它要走几次。

假设你有5个数，那就要走4次，最后一次不用走，最后那个数已经在它位置了所以就要length-1次。

2：内层循环：控制逐一比较，如果发现前一个数比后一个数大，则交换。

注意！因为越比较长度就越小了，所以长度要length-1-i。

Java程序：

import javautilScanner;

public class TesLinkList {

public static void main(String[] args) {

LinkList list = new LinkList();

Scanner scan = new Scanner(Systemin);

int i, size;

Systemoutprint("请输入链表的大小：");

size = scannextInt();

for(i=0; i<size; i++){

listaddAt(i, scannextInt());

}

Systemoutprintln("链表结点一览：");

listlistAll();

listbubbleSort();

Systemoutprintln("排序后的链表结点一览：");

listlistAll();

}

}

/

链表结点类

/

class Node{

private int data;

private Node next; //链表结点的指针域，指向直接后继结点

public Node(){

next = null;

}

public Node(int data, Node next){

thisdata = data;

thisnext = next;

}

public int getData(){

return thisdata;

}

public void setData(int data){

thisdata = data;

}

public Node getNext(){

return thisnext;

}

public void setNext(Node next){

thisnext = next;

}

}

/

链表类

/

class LinkList{

private Node head = null; //头结点指针

private int size = 0;

public LinkList(){

head = new Node();

size = 0;

}

//在i位置插入元素elem

public boolean addAt(int i, int elem) {

if(i < 0 || i > size){

return false;

}

Node pre,curr;

int pos;

for(pre=head; i>0 && pregetNext()!=null; i--,pre=pregetNext());

curr = new Node(elem, pregetNext());

presetNext(curr);

size++;

return true;

}

public Node getHead(){

return thishead;

}

public void setHead(Node head){

thishead = head;

}

public int getSize(){

return thissize;

}

public boolean isEmpty(){

return (size==0);

}

public void listAll(){

for(Node curr=headgetNext(); curr!=null; curr=currgetNext()){

Systemoutprint(currgetData() + "\t");

}

Systemoutprintln();

}

public void bubbleSort(){

Node p, q;

int temp;

for(p=headgetNext(); pgetNext()!=null; p=pgetNext()){

for(q=headgetNext(); qgetNext()!=null; q=qgetNext()){

if(qgetData() > qgetNext()getData()){

temp = qgetData();

qsetData(qgetNext()getData());

qgetNext()setData(temp);

}

}

}

}

}

运行测试：

请输入链表的大小：4

1

2

4

3

链表结点一览：

1 2 4 3

排序后的链表结点一览：

1 2 3 4

依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。

for(int

j=0;j<=len-i-1;j++),冒泡排序比较相邻的值，也就是a[j]和a[j+1]相比较

所以这段代码从a[0]开始与后面的a[1]比较，如果a[1]小于

a[0]就换。不小于j++，a[1]和[a2]比较，以此类推，直到比到a[len-i-1]时，也就比到了最后一个数组了。上层循环就是控制数组比较的长度。

方法一: package basicjavastu; 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=numblength;

int i,j;

int temp;

Systemoutprintln("排序前的数组各个值:");

for(i=0;i<len;i++)

{

Systemoutprint(numb[i]+"\t");

}

Systemoutprintln("\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;

}

}

}

Systemoutprintln("排序后的数组各个值:");

for(i=0;i<len;i++)

{

Systemoutprint(numb[i]+"\t");

}

}

}

方法二: package basicjavastu; 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=numblength;

Systemoutprintln("排序前的数组各个值:");

for(int i=0;i<leng;i++)

{

Systemoutprint(numb[i]+"\t");

}

Systemoutprintln("\n");

swap(numb);

Systemoutprintln("数组排序后:"); for(int i=0;i<leng;i++)

{

Systemoutprint(numb[i]+"\t");

} }

private static int[] swap(int[] numb) { int n2[]=numb; int len=n2length; 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 basicjavastu; 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=numblength;

Systemoutprintln("排序前的数组各个值:");

for(int i=0;i<leng;i++)

{

Systemoutprint(numb[i]+"\t");

}

Systemoutprintln("\n");

swap(numb);

Systemoutprintln("数组排序后:"); for(int i=0;i<leng;i++)

{

Systemoutprint(numb[i]+"\t");

} }

private static void swap(int[] numb) { int len=numblength; 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;

}

}

} } }

/

  Date:June 04 2015

  @author 12052010 TODO 测试以通过，获取财富值

 /

public class BubbleOfArray {

/

  对目标数组进行冒泡排序（升序）

  @param arr

             目标数组

 /

public static void bubbleToUp(int[] arr) {

if (arr == null)

return;

Systemoutprintln("\n--------过程----------\n");

for (int i = 0; i < arrlength; i++) {

Systemoutprintln("\n----------第"+i+" 次循环------\n");

for (int j = 0; j < arrlength - i - 1; j++) {

if (arr[j] > arr[j + 1]) {

Systemoutprint("\n"+arr[j]+","+arr[j+1]);

int temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

}

}

}

}

/

  遍历数组

  @param arr

             数组

 /

public static void display(int[] arr) {

Systemoutprintln();

for (int i = 0; arr != null && i < arrlength; i++)

Systemoutprint("  " + arr[i]);

}

public static void main(String[] args) {

int[] arr = new int[10];

for (int i = 0; i < arrlength; i++)

arr[i] = arrlength - i;

Systemoutprintln("Before sort: ");

display(arr);

bubbleToUp(arr);

Systemoutprintln("\n\nAfter sort: ");

display(arr);

}

}

以上就是关于求java的冒泡排序程序！！！急急全部的内容，包括:求java的冒泡排序程序！！！急急、冒泡排序算法，java、JAVA冒泡排序法等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！