冒泡排序是比较经典的排序算法.代码如下：
for(int i=1;iarr.length;i++){
for(int j=1;jarr.length-i;j++){
//交换位置
} ? ?
拓展资料：
原理：比较两个相邻的元素,将值大的元素交换至右端.
第一趟比较完成后,最后一个数一定是数组中最大的一个数,所以第二趟比较的时候最后一个数不参与比较；
第二趟比较完成后,倒数第二个数也一定是数组中第二大的数,所以第三趟比较的时候最后两个数不参与比较；
依次类推,每一趟比较次数-1；
......
参考资料：冒泡排序原理
参考代码如下,可以按需求自己修改
import?java.util.Date;
public?class?SortThread?{
public?static?void?main(String[]?args)?{
//产生一个随机数组
int[]?ary?=?getArray();
//启动冒泡排序线程
new?Thread(new?MaoPao(ary)).start();
//启动快速排序线程
new?Thread(new?KuaiSu(ary)).start();
}
private?static?int[]?getArray()?{
//建议数字n不要超过1百万,十万左右就好了
int?n?=?(int)?(Math.random()*1000000)+11;
int[]?ary=?new?int[n];
System.out.println("n的值是"?+?n);
for?(int?i?=?0;?i?ary.length;?i++)?{
ary[i]?=?(int)?(Math.random()*100000);
return?ary;
//冒泡排序
class?MaoPao?implements?Runnable?{
int[]?ary;
public?MaoPao(int[]?ary)?{
this.ary?=?ary;
@Override
public?void?run()?{
long?st?=?System.currentTimeMillis();
System.out.println(new?Date()?+?"冒泡排序线程：开始执行排序");
for?(int?i?=?0;?i?ary.length?-?1;?i++)?{
for?(int?j?=?0;?j?ary.length?-?i?-?1;?j++)?{
if?(ary[j]?ary[j?+?1])?{
int?temp?=?ary[j];
ary[j]?=?ary[j?+?1];
ary[j?+?1]?=?temp;
long?et?=?System.currentTimeMillis();
System.out.println(new?Date()?+?"冒泡排序线程完成排序,耗费时间"?+?(et?-?st)?+?"毫秒");
System.out.println(ary[i]+"?");
//快速排序
class?KuaiSu?implements?Runnable?{
public?KuaiSu(int[]?ary)?{
System.out.println(new?Date()?+?"快速排序线程：开始执行排序");
quickSort(ary,?1,?ary.length);
System.out.println(new?Date()?+?"快速排序线程排序完成,耗费时间"?+?(et?-?st)?+?"毫秒");
public?static?int?Partition(int?a[],?int?p,?int?r)?{
int?x?=?a[r?-?1];
int?i?=?p?-?1;
int?temp;
for?(int?j?=?p;?j?=?r?-?1;?j++)?{
if?(a[j?-?1]?=?x)?{
i++;
temp?=?a[j?-?1];
a[j?-?1]?=?a[i?-?1];
a[i?-?1]?=?temp;
temp?=?a[r?-?1];
a[r?-?1]?=?a[i?+?1?-?1];
a[i?+?1?-?1]?=?temp;
return?i?+?1;
public?static?void?quickSort(int?a[],?int?p,?int?r)?{
if?(p?r)?{
int?q?=?Partition(a,?p,?r);
quickSort(a,?p,?q?-?1);
quickSort(a,?q?+?1,?r);
java变成对数组进行排序可以使用ArraySort方法,保存源数组下标值可以存入map中,如下代码：
import?java.util.ArrayList;
import?java.util.Arrays;
import?java.util.HashMap;
import?java.util.List;
public?class?ceshi?{
HashMap?map?=?new?HashMap();
for?(int?i?=?0;?i?a.length;?i++)?{
map.put(a[i],?i);?//?将值和下标存入Map
//?排列
List?list?=?new?ArrayList();
Arrays.sort(a);?//?升序排列
list.add(a[i]);
for?(Object?object?:?list)?{
System.out.print(object?+?",");
System.out.println();
//?查找原始下标
for?(int?i?=?0;?i?n;?i++)?{
System.out.print(map.get(a[i])?+?",");
运行结果如下：
package temp;
import sun.misc.Sort;
/**
* @author zengjl
* @version 1.0
* @Des java几种基本排序方法
*/
* SortUtil:排序方法
* 关于对排序方法的选择：这告诉我们,什么时候用什么排序最好.当人们渴望先知道排在前面的是谁时,
* 我们用选择排序；当我们不断拿到新的数并想保持已有的数始终有序时,我们用插入排序；当给出的数
* 列已经比较有序,只需要小幅度的调整一下时,我们用冒泡排序.
public class SortUtil extends Sort {
* 插入排序法
* @param data
* @Des 插入排序(Insertion Sort)是,每次从数列中取一个还没有取出过的数,并按照大小关系插入到已经取出的数中使得已经取出的数仍然有序.
public int[] insertSort(int[] data) {
①./11页
int temp;
for (int i = 1; i data.length; i++) {
for (int j = i; (j 0) (data[j] data[j - 1]); j--) {
swap(data, j, j - 1);
return data;
* 冒泡排序法
* @return
* @Des 冒泡排序(Bubble Sort)分为若干趟进行,每一趟排序从前往后比较每两个相邻的元素的大小（所以呢一趟排序要比较n-1对位置相邻的数）并在
* 每次发现前面的那个数比紧接它后的数大时交换位置；进行足够多趟直到某一趟跑完后发现这一趟没有进行任何交换操作（最坏情况下要跑n-1趟,
* 这种情况在最小的数位于给定数列的最后面时发生）.事实上,在第一趟冒泡结束后,最后面那个数肯定是最大的了,于是第二次只需要对前面n-1
* 个数排序,这又将把这n-1个数中最小的数放到整个数列的倒数第二个位置.这样下去,冒泡排序第i趟结束后后面i个数都已经到位了,第i+1趟实
* 际上只考虑前n-i个数（需要的比较次数比前面所说的n-1要小）.这相当于用数学归纳法证明了冒泡排序的正确性
java编程实现随机数组的快速排序步骤如下：
①.、打开Eclipse,新建一个Java工程,在此工程里新建一个Java类；
具体代码如下：
import?java.util.Random;
public?class?Demo?{
int?count?=?0;
Random?random?=?new?Random();
int?a[]?=?new?int[10];
while(count?10){
count++;
for?(int?i?=?0;?i?a.length?-?1;?i++)?{
int?min?=?i;
for?(int?j?=?i?+?1;?j?a.length;?j++)?{
if?(a[j]?a[min])?{
min?=?j;
if?(min?!=?i)?{
int?b?=?a[min];
a[min]?=?a[i];
a[i]?=?b;
for?(int?c?=?0;?c?a.length;?c++)?{
System.out.print(a[c]?+?"?");
以上就是土嘎嘎小编为大家整理的java实现排序代码相关主题介绍,如果您觉得小编更新的文章只要能对粉丝们有用,就是我们最大的鼓励和动力,不要忘记讲本站分享给您身边的朋友哦！！