java冒泡输入法代码 输入一个字符串,使用冒泡法
求JAVA冒泡排序法的代码
你好！很高兴能帮到你。
创新互联建站专注于企业营销型网站建设、网站重做改版、杏花岭网站定制设计、自适应品牌网站建设、HTML5建站、购物商城网站建设、集团公司官网建设、外贸营销网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为杏花岭等各大城市提供网站开发制作服务。
由于你刚学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程序用命令行带入参数的形式输入整数再用冒泡法排序
看这段代码吧，希望对你有帮助
java排序法
package com.cucu.test;
public class Sort {
public void swap(int a[], int i, int j) {
int tmp = a;
a = a[j];
a[j] = tmp;
}
public int partition(int a[], int low, int high) {
int pivot, p_pos, i;
p_pos = low;
pivot = a[p_pos];
for (i = low + 1; i = high; i++) {
if (a pivot) {
p_pos++;
swap(a, p_pos, i);
}
}
swap(a, low, p_pos);
return p_pos;
}
public void quicksort(int a[], int low, int high) {
int pivot;
if (low high) {
pivot = partition(a, low, high);
quicksort(a, low, pivot - 1);
quicksort(a, pivot + 1, high);
}
}
public static void main(String args[]) {
int vec[] = new int[] { 37, 47, 23, -5, 19, 56 };
int temp;
//选择排序法(Selection Sort)
long begin = System.currentTimeMillis();
for (int k = 0; k 1000000; k++) {
for (int i = 0; i vec.length; i++) {
for (int j = i; j vec.length; j++) {
if (vec[j] vec) {
temp = vec;
vec = vec[j];
vec[j] = temp;
}
}
}
}
long end = System.currentTimeMillis();
System.out.println("选择法用时为：" + (end - begin));
//打印排序好的结果
for (int i = 0; i vec.length; i++) {
System.out.println(vec);
}
// 冒泡排序法(Bubble Sort)
begin = System.currentTimeMillis();
for (int k = 0; k 1000000; k++) {
for (int i = 0; i vec.length; i++) {
for (int j = i; j vec.length - 1; j++) {
if (vec[j + 1] vec[j]) {
temp = vec[j + 1];
vec[j + 1] = vec[j];
vec[j] = temp;
}
}
}
}
end = System.currentTimeMillis();
System.out.println("冒泡法用时为：" + (end - begin));
//打印排序好的结果
for (int i = 0; i vec.length; i++) {
System.out.println(vec);
}
//插入排序法(Insertion Sort)
begin = System.currentTimeMillis();
for (int k = 0; k 1000000; k++) {
for (int i = 1; i vec.length; i++) {
int j = i;
while (vec[j - 1] vec) {
vec[j] = vec[j - 1];
j--;
if (j = 0) {
break;
}
}
vec[j] = vec;
}
}
end = System.currentTimeMillis();
System.out.println("插入法用时为：" + (end - begin));
//打印排序好的结果
for (int i = 0; i vec.length; i++) {
System.out.println(vec);
}
//快速排序法(Quick Sort)
Sort s = new Sort();
begin = System.currentTimeMillis();
for (int k = 0; k 1000000; k++) {
s.quicksort(vec, 0, 5);
}
end = System.currentTimeMillis();
System.out.println("快速法用时为：" + (end - begin));
//打印排序好的结果
for (int i = 0; i vec.length; i++) {
System.out.println(vec);
}
}
}
//------------------------------------
以下是运行结果：
选择法用时为：234
56
47
37
23
19
-5
冒泡法用时为：172
56
47
37
23
19
-5
插入法用时为：78
56
47
37
23
19
-5
快速法用时为：297
56
47
37
23
19
-5
Java冒泡排序法，代码编辑无报错提醒，一运行就出错==||。求大佬救救孩纸
你这是死记硬背的吧，错误太多了，逻辑都不同。百度一下冒泡排序法，看看怎么个原理吧，知道了原理就不会写错。
附上源代码：
ublic static void bubbleSort(int []arr) {
int[] arr = {12,23,34,56,56,56,78};
for(int i =0;iarr.length-1;i++) {
boolean bool = true;
for(int j=0;jarr.length-i-1;j++) {//-1为了防止溢出
if(arr[j]arr[j+1]) {
bool = false;
int temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
if(!bool)
break;
}
}
输入一组数组 如何用Java按冒泡排序和选择排序输出数组 求代码
/**
* 2015年5月28日下午9:52:57
*
* @author season TODO 测试已通过,获取财富值
*
*/
public class ArrayOperation {
/**
* 对数组 arr 进行冒泡排序升序排序
*
* @param arr
* 目标数组
*/
public static void bubbleToUp(int[] arr) {
if (null == arr)// 数组为空时,退出该方法
return;
for (int i = 0; i arr.length - 1; i++) {
for (int j = 0; j arr.length - i - 1; j++) {
if (arr[j] arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
/**
* 使用选择排序法对目标数组进行降序排序
*
* @param arr
* 目标数组
*/
public static void selectToDown(int[] arr) {
for (int i = 0; arr != null i arr.length; i++) {
int flag = i;
for (int j = i + 1; j arr.length; j++) {
if (arr[j] arr[flag])
flag = j;
}
if (flag != i) {
int temp = arr[i];
arr[i] = arr[flag];
arr[flag] = temp;
}
}
}
/**
* 遍历数组所有元素
*
* @param arr
* 目标数组
*/
public static void displayArray(int[] arr) {
System.out.println();
for (int num : arr)
System.out.print(" " + num);
}
public static void main(String[] args) {
// 初始化数组
int[] arr = { 20, -878, 90, 78, 89, -908 };
// 首先进行冒泡排序(升序)
bubbleToUp(arr);
displayArray(arr);
// 然后进行选择排序(降序)
selectToDown(arr);
displayArray(arr);
}
}
冒泡法排序，java代码 排序1 8 5 2 4 9
public class Test {
public static void main(String[] args) {
int[] a = {1, 8, 5, 2, 4, 9};
//冒泡排序
for (int k = 0; k a.length - 1; k++) {
for (int j = k + 1; j a.length; j++) { // 升序把改成
if (a[k] a[j]) {
int temp = a[k];
a[k] = a[j];
a[j] = temp;
}
}
}
System.out.println("排序后: ");
for(int i = 0; i a.length; i++){
System.out.print(a[i] + " ");
}
}
}
java冒泡排序法代码
冒泡排序是比较经典的排序算法。代码如下：
for(int i=1;iarr.length;i++){
for(int j=1;jarr.length-i;j++){
//交换位置
}
拓展资料：
原理：比较两个相邻的元素，将值大的元素交换至右端。
思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第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冒泡输入法代码 输入一个字符串,使用冒泡法
分享链接：http://myzitong.com/article/dosogip.html