JAVA 伪代码

提示输入一个大于2且11的数字

为鹤山等地区用户提供了全套网页设计制作服务，及鹤山网站建设行业解决方案。主营业务为做网站、成都网站设计、鹤山网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

输入一整型数值给Vertices,

if(Vertices 3 || Vertices 11){

提示重新输入且应输入

退出程序

}else{

生成一个Vertices * Vertices 大小的数组Graph，

填充数组 ：行号与列号相同填充0，其余填充10以内随机数

交换元素：以[i][j]位置的数值与[j][i]位置的数值互换

最后打印数组各元素

}

求冒泡排序的java代码

方法一: package basic.javastu; 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=numb.length;

int i,j;

int temp;

System.out.println("排序前的数组各个值:");

for(i=0;ilen;i++)

{

System.out.print(numb[i]+"\t");

}

System.out.println("\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;

}

}

}

System.out.println("排序后的数组各个值:");

for(i=0;ilen;i++)

{

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=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

}

System.out.println("\n");

swap(numb);

System.out.println("数组排序后:"); for(int i=0;ileng;i++)

{

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=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 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=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

}

System.out.println("\n");

swap(numb);

System.out.println("数组排序后:"); for(int i=0;ileng;i++)

{

System.out.print(numb[i]+"\t");

} }

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

}

}

} } }

求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;

}

}

求冒泡排序的全中文的伪代码 ？

伪代码啊，还真不好描述：

假设有N个数，可以想象成所有的数分成两部分：上部和下部，上部的是排好序的，下部的没有。

外层循环N-1次（i从0到N-2）{ //每循环一次就能让一个下部数中最大的冒到上部来

内层循环从0开始，循环到j（j=N-i）{ //保证下部的每个位置都进行一次冒泡判断

如果当前的数比它上面的一个数大，就互换位置（冒上来一次）。

/* 这是互换代码

if(array[j]array[j+1])

{

int tmp=array[j];

array[j]=array[j+1];

array[j+1]=tmp;

}

*/

//可以想象，如果足够大，该数会一直更新位置，一直往上冒，到达合适位置。

}

}

外层循环结束后就排好序了。

这个算法的特点就是如果一个数是下部中最大的，它就能一直往上冒，不管它当初在什么位置，内层一轮冒泡后它就能冒到上部去（成为上部里最小的）。N-1轮后就排好序了。

描述的不怎么好，还写不出来的话可以直接要代码（猜你是想自己写出来所以没贴代码）

java代码转成伪代码

1. 请把下面的java代码用伪代码写出来

伪代码(Pseudocode)是一种算法描述语言。

使用伪代码的目的是为了使被描述的算法可以容易地以任何一种编程语言(Pascal,C,Java,etc)实现。因此，伪代码必须结构清晰、代码简单、可读性好，并且类似自然语言。

介于自然语言与编程语言之间。以编程语言的书写形式指明算法职能。

使用伪代码， 不用拘泥于具体实现。相比程序语言(例如Java, C++,C, Dephi 等等)它更类似自然语言。

它是半角式化、不标准的语言。可以将整个算法运行过程的结构用接近自然语言的形式(可以使用任何一种你熟悉的文字，关键是把程序的意思表达出来)描述出来。

String path = "***"File f = new File(path);public void test (F f)File []fs = f遍历文件夹；for(。){ if(fs[i]是文件){ 输入 }else{ 递归test(fs[i]); }}。

2. JAVA 伪代码

提示输入一个大于2且11的数字

输入一整型数值给Vertices,

if(Vertices 3 || Vertices 11){

提示重新输入且应输入

退出程序

}else{

生成一个Vertices * Vertices 大小的数组Graph,

填充数组 ：行号与列号相同填充0，其余填充10以内随机数

交换元素：以[i][j]位置的数值与[j][i]位置的数值互换

最后打印数组各元素

}

3. 请把下列用java代码 用伪代码写出来

伪代码(Pseudocode)是一种算法描述语言。使用伪代码的目的是为了使被描述的算法可以容易地以任何一种编程语言(Pascal,C,Java,etc)实现。因此，伪代码必须结构清晰、代码简单、可读性好，并且类似自然语言。 介于自然语言与编程语言之间。以编程语言的书写形式指明算法职能。使用伪代码， 不用拘泥于具体实现。相比程序语言(例如Java, C++,C, Dephi 等等)它更类似自然语言。它是半角式化、不标准的语言。可以将整个算法运行过程的结构用接近自然语言的形式(可以使用任何一种你熟悉的文字，关键是把程序的意思表达出来)描述出来。

String path = "***"

File f = new File(path);

public void test (F f)

File []fs = f遍历文件夹；

for(。){

if(fs[i]是文件){

输入

}else{

递归test(fs[i]);

}

}

4. 伪代码怎么写

伪代码(Pseudocode)是一种算法描述语言。

使用伪代码的目的是为了使被描述的算法可以容易地以任何一种编程语言(Pascal,C,Java,etc)实现。因此，伪代码必须结构清晰、代码简单、可读性好，并且类似自然语言。

介于自然语言与编程语言之间。 它以编程语言的书写形式指明算法的职能。

相比于程序语言(例如Java, C++,C, Dephi 等等)它更类似自然语言。它是半角式化、不标准的语言。

我们可以将整个算法运行过程的结构用接近自然语言的形式(这里，你可以使用任何一种你熟悉的文字，中文，英文 等等，关键是你把你程序的意思表达出来)描述出来. 使用伪代码， 可以帮助我们更好的表述算法， 不用拘泥于具体的实现. 人们在用不同的编程语言实现同一个算法时意识到，他们的实现(注意：这里是实现，不是功能)很不同。尤其是对于那些熟练于不同编程语言的程序员要理解一个(用其他编程语言编写的程序的)功能时可能很难，因为程序语言的形式限制了程序员对程序关键部分的理解。

这样伪代码就应运而生了。 当考虑算法功能(而不是其语言实现)时，伪代码常常得到应用。

计算机科学在教学中通常使用虚拟码，以使得所有的程序员都能理解。 综上，简单的说，让人便于理解的代码。

不依赖于语言的，用来表示程序执行过程，而不一定能编译运行的代码。在数据结构讲算法的时候用的很多。

5. 伪代码的写法

类Pascal语言的伪代码的语法规则是： 在伪代码中，每一条指令占一行(else if，例外)。指令后不跟任何符号(Pascal和C中语句要以分号结尾)。

伪代码实例如下：

IF 九点以前 THEN

do 私人事务；

ELSE 9点到18点 THEN

工作；

ELSE

下班；

END IF

这样不但可以达到文档的效果，同时可以节约时间。更重要的是，使结构比较清晰，表达方式更加直观。

伪代码(Pseudocode)是一种算法描述语言。使用伪代码的目的是为了使被描述的算法可以容易地以任何一种编程语言(Pascal,C,Java,etc)实现。因此，伪代码必须结构清晰、代码简单、可读性好，并且类似自然语言。 介于自然语言与编程语言之间。

它以编程语言的书写形式指明算法的职能。相比于程序语言(例如Java, C++,C, Dephi 等等)它更类似自然语言。它是半角式化、不标准的语言。

我们可以将整个算法运行过程的结构用接近自然语言的形式(这里，你可以使用任何一种你熟悉的文字，中文，英文 等等，关键是你把你程序的意思表达出来)描述出来。使用伪代码， 可以帮助我们更好的表述算法，不用拘泥于具体的实现。

6. 伪代码的写法

最低0.27元开通文库会员，查看完整内容 原发布者：wangwenjxnu 伪代码伪代码是用介于自然语言和计算机语言之间的文字和符号来描述算法。

每一行(或几行)表示一个基本操作。它不用图形符号，因此书写方便、格式紧凑，也比较好懂，便于向程序过渡。

伪代码的7个主要部分：(1)算法名称(2)指令序列(3)输入/输出(4)分支选择(5)赋值(6)循环(7)算法结束1.算法名称两种表示算法的伪代码：过程(Procedure)函数(Function)过程和函数的区别是：过程是执行一系列的操作，不需要返回操作的结果，无返回数据；函数是执行一系列的操作后，要将操作的结果返回，有返回数据。算法伪代码的书写规则：Procedure([])Function([])如：ProcedureHanoi_Tower()FunctionFac(x)表示名为Fac的一个函数。

FunctionProg(n)表示名为Prog的一个函数。2.指令序列指令序列是算法的主体。

指令序列的书写规则：用Begin作为开始、用End作为结束；用“{”作为开始、用“/}”作为结束。例如：Begin指令序列；End或者：{指令序列；/}3.输出/输出输入：Input输出：Output或Return4.分支选择两种分支：IfThen{指令序列/}IfThen{。

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://azwzsj.com/article/hpcoog.html