java循环排序

❶ java数组:输入班级人数,然后循环输入学生的名字和该学生的成绩,然后进行排序.

importjava.util.Scanner;

publicclassStudent{
	Stringname;
	doublescore;
	publicstaticvoidmain(String[]args){
		System.out.println("请输入班级学生人数");
		Scannersc=newScanner(System.in);
		inttotalStudent=sc.nextInt();
		Student[]stus=newStudent[totalStudent];
		for(inti=0;i<totalStudent;i++){
			Students=newStudent();
			stus[i]=s;
			System.out.println("请输入第"+(i+1)+"个学生的名字");
			s.name=sc.next();
			System.out.println("请输入第"+(i+1)+"个学生的分数");
			s.score=sc.nextDouble();
		}
		bubbleSort(stus);
		printStudents(stus);
		sc.close();
	}

	publicstaticvoidbubbleSort(Student[]s){
		for(inti=0;i<s.length-1;i++){
			for(intj=i;j<s.length;j++){
				if(s[i].score<s[j].score){
					Studenttemp=s[i];
					s[i]=s[j];
					s[j]=temp;
				}
			}
		}
	}
	publicstaticvoidprintStudents(Student[]s){
		System.out.println("名次	名字	成绩");
		for(inti=0;i<s.length;i++){
			System.out.println(i+1+"	"+s[i].name+"	"+s[i].score);
		}
	}
}

❷ JAVA排序循环代码

import java.util.*;
public class Test {
public static void main(String[] args) {

int [] aa={8,9,6,3,4,6,7};
Arrays.sort(aa);
for(int i=0;i<aa.length;i++){
System.out.print(aa[i] + " ");}
}
}

❸ java排序算法for循环语句怎么理解请帮忙讲解下，

class Sortint_1 {
int i,j,k,temp;
void Sortint(int a1,inta2[]) { //传递参数 数组长度，数组对象{1，5，2，0}
for(i=0;i<a1-1;i++) { //从第一个元素开始遍历数组
k = i; //k和i同步
for(j=i+1;j<a1;j++) // j定位为第二个元素，开始内循环找到未排序中最小值
if(a2[j]<a2[k]) k=j; //如果在未排序中的元素有比当前K值小的，则将k置为较小元素的下标，始终保持k最小
if(k!=i) {
temp = a2[i];a2[i]=a2[k];a2[k]=temp; //遇到小值则i，k交换
}
}
}

总结：内层循环是为了寻找未排序中的元素的最小值；找到后在外层循环将值赋给i。具体怎么回事，你找一个数组自己走一遍就能理解了，这样印象也能更深刻

❹ 请给出java几种排序方法

java常见的排序分为：
1 插入类排序
主要就是对于一个已经有序的序列中，插入一个新的记录。它包括：直接插入排序，折半插入排序和希尔排序
2 交换类排序
这类排序的核心就是每次比较都要“交换”，在每一趟排序都会两两发生一系列的“交换”排序，但是每一趟排序都会让一个记录排序到它的最终位置上。它包括：起泡排序，快速排序
3 选择类排序
每一趟排序都从一系列数据中选择一个最大或最小的记录，将它放置到第一个或最后一个为位置交换，只有在选择后才交换，比起交换类排序，减少了交换记录的时间。属于它的排序：简单选择排序，堆排序
4 归并类排序
将两个或两个以上的有序序列合并成一个新的序列
5 基数排序
主要基于多个关键字排序的。
下面针对上面所述的算法，讲解一些常用的java代码写的算法
二 插入类排序之直接插入排序
直接插入排序,一般对于已经有序的队列排序效果好。
基本思想：每趟将一个待排序的关键字按照大小插入到已经排序好的位置上。
算法思路，从后往前先找到要插入的位置，如果小于则就交换，将元素向后移动，将要插入数据插入该位置即可。时间复杂度为O(n2),空间复杂度为O(1)
package sort.algorithm;
public class DirectInsertSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };
int temp, j;
for (int i = 1; i < data.length; i++) {
temp = data[i];
j = i - 1;
// 每次比较都是对于已经有序的
while (j >= 0 && data[j] > temp) {
data[j + 1] = data[j];
j--;
}
data[j + 1] = temp;
}
// 输出排序好的数据
for (int k = 0; k < data.length; k++) {
System.out.print(data[k] + " ");
}
}
}
三 插入类排序之折半插入排序(二分法排序)
条件：在一个已经有序的队列中，插入一个新的元素
折半插入排序记录的比较次数与初始序列无关
思想：折半插入就是首先将队列中取最小位置low和最大位置high，然后算出中间位置mid
将中间位置mid与待插入的数据data进行比较，
如果mid大于data，则就表示插入的数据在mid的左边，high=mid-1;
如果mid小于data，则就表示插入的数据在mid的右边,low=mid+1
最后整体进行右移操作。
时间复杂度O(n2),空间复杂度O(1)

package sort.algorithm;
//折半插入排序
public class HalfInsertSort {
public static void main(String[] args) {
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };
// 存放临时要插入的元素数据
int temp;
int low, mid, high;
for (int i = 1; i < data.length; i++) {
temp = data[i];
// 在待插入排序的序号之前进行折半插入
low = 0;
high = i - 1;
while (low <= high) {
mid = (low + high) / 2;
if (temp < data[mid])
high = mid - 1;
else
// low=high的时候也就是找到了要插入的位置，
// 此时进入循环中，将low加1，则就是要插入的位置了
low = mid + 1;
}
// 找到了要插入的位置，从该位置一直到插入数据的位置之间数据向后移动
for (int j = i; j >= low + 1; j--)
data[j] = data[j - 1];
// low已经代表了要插入的位置了
data[low] = temp;
}
for (int k = 0; k < data.length; k++) {
System.out.print(data[k] + " ");
}
}
}

四 插入类排序之希尔排序
希尔排序，也叫缩小增量排序，目的就是尽可能的减少交换次数，每一个组内最后都是有序的。
将待续按照某一种规则分为几个子序列，不断缩小规则，最后用一个直接插入排序合成
空间复杂度为O(1)，时间复杂度为O(nlog2n)
算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

package sort.algorithm;
public class ShellSort {
public static void main(String[] args) {
int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 };
double d1 = a.length;
int temp = 0;
while (true)
{
//利用这个在将组内倍数减小
//这里依次为5,3,2,1
d1 = Math.ceil(d1 / 2);
//d为增量每个分组之间索引的增量
int d = (int) d1;
//每个分组内部排序
for (int x = 0; x < d; x++)
{
//组内利用直接插入排序
for (int i = x + d; i < a.length; i += d) {
int j = i - d;
temp = a[i];
for (; j >= 0 && temp < a[j]; j -= d) {
a[j + d] = a[j];
}
a[j + d] = temp;
}
}

if (d == 1)
break;
}
for (int i = 0; i < a.length; i++)
System.out.print(a[i]+" ");
}
}

五 交换类排序之冒泡排序
交换类排序核心就是每次比较都要进行交换
冒泡排序：是一种交换排序
每一趟比较相邻的元素，较若大小不同则就会发生交换，每一趟排序都能将一个元素放到它最终的位置！每一趟就进行比较。
时间复杂度O(n2)，空间复杂度O(1)

package sort.algorithm;
//冒泡排序：是一种交换排序
public class BubbleSort {
// 按照递增顺序排序
public static void main(String[] args) {
// TODO Auto-generated method stub
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 };
int temp = 0;
// 排序的比较趟数,每一趟都会将剩余最大数放在最后面
for (int i = 0; i < data.length - 1; i++) {
// 每一趟从开始进行比较，将该元素与其余的元素进行比较
for (int j = 0; j < data.length - 1; j++) {
if (data[j] > data[j + 1]) {
temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
for (int i = 0; i < data.length; i++)
System.out.print(data[i] + " ");
}
}

❺ java选择排序的两个for循环是什么意思

这么理解----把内层的for循环 循环外层for循环定义的次数
for1（5次）｛
for2（10次）

｝
for1--循环5次
for2--循环50次

❻ 关于java for 循环排序的问题

for(int i=6;i>0;i--){ for(int j=1;j<i;j++){ System.out.print(j); } System.out.println(); }

满意请采纳

❼ java怎么让数组的数字从大到小排序

将数字从大到小排序的方法：

例如简一点的冒泡排序，将第一个数字和后面的数字逐个比较大小，如果小于，则互换位置，大于则不动。此时，第一个数为数组中的最大数。然后再将第二个数与后面的数逐个比较，以次类推。

示例代码如下：
publicclassTest{

publicstaticvoidmain(String[]args){
int[]array={12,3,1254,235,435,236,25,34,23};
inttemp;
for(inti=0;i<array.length;i++){
for(intj=i+1;j<array.length;j++){
if(array[i]<array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp; //两个数交换位置
}
}
}
for(inti=0;i<array.length;i++){
System.out.print(array[i]+"");
}
}
}

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99

(7)java循环排序扩展阅读

Java中利用数组进行数字排序一般有4种方法：

1、选择排序是先将数组中的第一个数作为最大或最小数，然后通过循环比较交换最大数或最小数与一轮比较中第一个数位置进行排序。

2、冒泡排序也是先将数组中的第一个数作为最大或最小数，循环比较相邻两个数的大小，满足条件就互换位置，将最大数或最小数沉底。

3、快速排序法主要是运用Arrays类中的Arrays.sort方法（）实现。

4、插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。

❽ java编程问题。用两个for循环来把输入的整数从小到大排序。

我用 3，1，5，4，2做了一下测试，把每次内循环后（外循环的一次）的数组打出来如下：
5 1 3 4 2
1 5 3 4 2
1 3 5 4 2
1 3 4 5 2
1 2 3 4 5
这个排序看起来有点反人类，好像第一次循环的时候把大的往前面放，其实意思综合起来就一句话：外循环的下标i到哪个数，就保证前i个数是有序的。
解释一下吧：
i=0的时候把最大的数放在z[0]
i=1的时候，z[0]肯定比z[1]大，互换；后面的数都比不上换过的z[1]，所以前2个是有序的。
在i=k时，前k个数是有序的，即z[0...k-1]有序，那么对于z[k]来排序（此时i=k），n从0开始（即从前面开始），如果n下标的元素大，则互换；如果小，则不换。此时n在i之前，所以保证了大的数一定扔到了后面；那么内循环中n自增时，前n个数一定是排好序的，直到n=i（即k），那么前k+1个数也就是有序的。而由于n超过i之后，a[i]变成了原来的a[k-1]，一定是数组中最大的数，因此后面的数都比不过它，也就不会再进行交换了。所以在这次外循环中，前k+1个数变成了有序的。
由数学归纳法，最后一定会把所有的数进行排序。
不懂请追问。喜欢就请采纳吧～

❾ java选择排序中外循环控制的什么，内循环控制什么

内循环 是进行比较，找到最小的数或者最小的数组下标
外循环控制的是整个循环遍历，保证每个数都能通过遍历比较到