Ⅰ 关于冒泡排序法(java)
呵呵，冒泡排序的话，已经排好的元素不再参与比较，所以改成上面那位同学说的或者如果你想保持你的这种比较顺序的话，
for(int i=a.length-1; i>=0; i--){
for(int j=0; j<a.length; j++){
应该改成
for(int i=a.length-1; i>=0; i--){
for(int j=0; j<i; j++){
Ⅱ java 用冒泡排序法排序字符串数组
@org.junit.Test
publicvoidb(){
String[]strs={"avcd","bdce","avcdf","cced","bdce"};
for(inti=0;i<strs.length;i++){
//第一个字符的ascii码大，放前面
for(intj=i+1;j<strs.length;j++){
intnum=0;
compare(strs,i,j,num);
}
}
for(Stringstring:strs){
System.err.println(string);
}
}
/**
*@paramstrs
*@parami
*@paramnum
*/
privatevoidcompare(String[]strs,inti,intj,intnum){
//判断2个字符串谁的长度最小，则以当前长度作为num+1的最大标准
if(strs[i].length()>=strs[j].length()){
if(num+1<=strs[j].length()){
if(strs[j].charAt(num)>strs[i].charAt(num)){
Stringtemp=strs[i];
strs[i]=strs[j];
strs[j]=temp;
//若相等，则判断第二个
}elseif(strs[j].charAt(num)==strs[i].charAt(num)){
num++;
compare(strs,i,j,num);
}
}
}else{
if(num+1<=strs[i].length()){
if(strs[j].charAt(num)>strs[i].charAt(num)){
Stringtemp=strs[i];
strs[i]=strs[j];
strs[j]=temp;
//若相等，则判断第二个
}elseif(strs[j].charAt(num)==strs[i].charAt(num)){
num++;
compare(strs,i,j,num);
}
}else{
//表示当前字符串内容都一致，strs[j]的长度大。则放前面。
Stringtemp=strs[i];
strs[i]=strs[j];
strs[j]=temp;
}
}
}
Ⅲ 用JAVA语言编写一个冒泡排序法，要详细的
我n年前上学用的，你看看把，呵呵。希望对你有帮助
public class Test
{
public void Sx(int[] t)
{
for(int i = 0;i < t.length;i++)
{
if(t[i] < 10)
{
System.out.print("0"+t[i]+" ");
}
else
{
System.out.print(t[i]+" ");
}
if((i+1) % 6 == 0)
{
System.out.println();
}
}
}
public static void main(String[] args)
{
Test m = new Test();
int a[] = new int[36];
out1: for(int i = 0;i < 36;i++)
{
a[i] = (int)(Math.random() * 36 + 1);
for(int j = 0; j < 36 && j != i;j++)
{
if(a[j] == a[i])
{
i--;
continue out1;
}
}
}
m.Sx(a);
System.out.println();
//Arrays.sort(a);
//冒泡法
int temp;
for(int i=0;i<a.length;i++){
for(int j=0;j+1<a.length-i;j++){
if(a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
m.Sx(a);
}
}
Ⅳ 求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中的冒泡排序法
package pck;//打开pck数据包
public class Bubble {//建立一个名为Bubble的类
public static void main(String args[]){//建立main函数
int nums[]={99,-10,100123,18,-978,5623,463,-9,287,49};//建立名为nums的数组，包含10个数，并为这10个数初始化值
int a,b,t;建立3个整型变量
System.out.print("Original array is:");//屏幕输出Original array is:这段字符
for(int i=0;i<10;i++)//循环
System.out.print(" "+nums[i]);//屏幕上依次显示空格+nums[0]的数值空格+nums[1]……+nums[9]
System.out.println();
for(a=1;a<10;a++)
for(b=10-1;b>=a;b--){
if(nums[b-1]>nums[b]){//当后面的数大于前面的数是执行调换
t=nums[b-1];
nums[b-1]=nums[b];
nums[b]=t;
}
}//一段for语句循环，意思是把数组里大的数吊到前面，小的放到后面
System.out.print("Sroted array is:");屏幕上输出Sroted array is:这段字符
for(int i=0;i<10;i++)//循环语句为后面输出nums里的数作准备
System.out.print(" "+nums[i]);//在屏幕上输出空格+nums[0]空格+nums[1]……nums[9]
System.out.println();//这句不太清楚，可能是输出空白行
}
}
Ⅵ java冒泡排序法代码
冒泡排序是比较经典的排序算法。代码如下：
for(int i=1;i<arr.length;i++){
for(int j=1;j<arr.length-i;j++){
//交换位置
}
拓展资料：
原理：比较两个相邻的元素，将值大的元素交换至右端。
思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。
第一趟比较完成后，最后一个数一定是数组中最大的一个数，所以第二趟比较的时候最后一个数不参与比较；
第二趟比较完成后，倒数第二个数也一定是数组中第二大的数，所以第三趟比较的时候最后两个数不参与比较；
依次类推，每一趟比较次数-1；
……
举例说明：要排序数组：int[]arr={6,3,8,2,9,1};
for(int i=1;i<arr.length;i++){
for(int j=1;j<arr.length-i;j++){
//交换位置
}
Ⅶ java中的冒泡排序法
内层循环一次得到这个数组中最大的数并把它放在数组最后一个，同时把内层需要再循环的数组长度减1，即去掉数组中最后一个数（也就是最大的一个）。
外层循环控制内层循环执行几次。
Ⅷ 新手提问：java冒泡排序法
你这个冒泡排序有点错误
代码应如下
11. for (int i=0;i<num.length;i++) { // 执行冒泡排序法
12. for (int j=num.length-1;j>i;j--) {
// 两个相邻的数比较，若前一个数比后面的数大，则交换位置
13 if (array[j]<array[j-1]){
14 mid = array[j-1];
15 array[j-1] = array[j];
16 array[j] = array[j-1];
17 }
11，12行是确定你的排列顺序是沉（从array[0]开始比较）还是浮（从数组尾开始比较）
以上代码顺序是浮，从array[]末开始，比较相邻的两个元素，按照一定的顺序，这里是把比较小的数冒上来。每一次内循环都会有一个最小值冒出来，第一次是全数组中冒出一个最小的确定在array[0]位置中，然后第二次也是从末端开始比较，最后确定一个最值在array[1]中，以此类推。
冒泡排序是每次比较两个数据，按照大小顺序交换位置，每一次循环都把一个最值确定，下一次就可以少比较一个数，直到整个数组位置都确定。
Ⅸ java中最简单的方法冒泡排序
public void bubbleSort(int[] data, String sortType) {
if (sortType.equals("asc")) { //正排序，从小排到大
//比较的轮数
for (int i = 1; i < data.length; i++) {
//将相邻两个数进行比较，较大的数往后冒泡
for (int j = 0; j < data.length - i; j++) {
if (data[j] > data[j + 1]) {
//交换相邻两个数
swap(data, j, j + 1);
}
}
}
} else if (sortType.equals("desc")) { //倒排序，从大排到小
//比较的轮数
for (int i = 1; i < data.length; i++) {
//将相邻两个数进行比较，较大的数往后冒泡
for (int j = 0; j < data.length - i; j++) {
if (data[j] < data[j + 1]) {
//交换相邻两个数
swap(data, j, j + 1);
}
}
}
} else {
System.out.println("您输入的排序类型错误！");
}
printArray(data);//输出冒泡排序后的数组值
}
Ⅹ 关于冒泡排序的JAVA程序
冒泡算法，没冒一次泡，会将所有的数据比较一遍，同时将当前最大的数冒上去。
如果isSort 等于false ，表示所有比较中都没有发生需要交换的行为，那么数据已经按要求排序了。不必进行下一次冒泡。
这样可以减少重复计算量。