/** * 实现冒泡程序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("排序前的数组各个值:")
for(i=0i<leni++)
{
System.out.print(numb[i]+"\t")
}
System.out.println("\n")
for(i=1i<=leni++)
{
for(j=len-1j>=1j--)
{
if(numb[j]>numb[j-1])
{
temp=numb[j]
numb[j]=numb[j-1]
numb[j-1]=temp
}
}
}
System.out.println("排序后的清举姿数组各个值:")
for(i=0i<leni++)
{
System.out.print(numb[i]+"\t")
}
}
}
方法二: 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("排序前答亏的数组各个值:")
for(int i=0i<lengi++)
{
System.out.print(numb[i]+"\t")
}
System.out.println("\n")
swap(numb)
System.out.println("数组排序后:") for(int i=0i<lengi++)
{
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=1i<=leni++)
{
for(j=len-1j>=1j--)
{
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("排序前的数组各个值:")
for(int i=0i<lengi++)
{
System.out.print(numb[i]+"\t")
}
System.out.println("\n")
swap(numb)
System.out.println("数组排序后:") for(int i=0i<lengi++)
{
System.out.print(numb[i]+"\t")
} }
private static void swap(int[] numb) { int len=numb.length int i,j int temp for(i=1i<=leni++)
{
for(j=len-1j>=1j--)
{
if(numb[j]>numb[j-1])
{
temp=numb[j]
numb[j]=numb[j-1]
numb[j-1]=temp
}
}
} } }
你好！很高绝庆猜兴能帮到你。由于你刚学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 = 0i <intArray.lengthi++) {
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 = 0i <getNum()i++) {
System.out.print((i + 1) + ":")
acceptArray[i] = reader.nextInt()
}
return acceptArray
}
/**
* 打印原始输入数据
* @param intArray
*/
public void showAcceptAsIntArray(int[] intArray){
for (int i = 0i <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 = 0i <(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
}
}
public static void sortiere(int[] x) {boolean unsortiert = true// 这个是“未完成”默认值是true，表示未完成排序
int temp//交换值时，使用的临时变量
while (unsortiert) {//当未完成排序，就一直循环
unsortiert = false//*改变“未完成灶搜”为false，假设排序完成了。
for (int i = 0i <x.length - 1i++)//元素间比较大小，可能进行值交换
if (x[i] >x[i + 1]) {//你这里应该是从小到大排序的判断
temp = x[i]
x[i] = x[i + 1]
x[i + 1] = temp
unsortiert = true//产生了值的交换，把“未完成”改成true，让while循环继续，寻找下一个可能发生交换的情况。
}
}
}
综上：你这个程序，巧妙的是while循环和条件的假设（unsortiert true以及false的氏肆假设及判断），当所有的需要交换值的 *** 作完成后，循环中的unsortiert = false假设就成立，然后就会跳出while循环歼辩轿，结束整个排序过程。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）