请用java语言编写排序程序。

Question

请编写一个多线程的程序，先产生一个大于10的随机整数n，再产生n个随机数并存放于数组中，然后创建两个线程并发地对所产生的随机数分别进行排序，其中，一个线程要求采用冒泡排序法进行排序，另一个线程要求采用快速排序法进行排序，最后比较这两个线程排序的结果，并输出先完成排序的线程。

Answer 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) + "毫秒");
for (int i = 0; i < ary.length; i++) {
System.out.println(ary[i]+" ");
}
}
}
//快速排序
class KuaiSu implements Runnable {
int[] ary;
public KuaiSu(int[] ary) {
this.ary = ary;
}
@Override
public void run() {
long st = System.currentTimeMillis();
System.out.println(new Date() + "快速排序线程：开始执行排序");
quickSort(ary, 1, ary.length);
long et = System.currentTimeMillis();
System.out.println(new Date() + "快速排序线程排序完成,耗费时间" + (et - st) + "毫秒");
for (int i = 0; i < ary.length; i++) {
System.out.println(ary[i]+" ");
}
}

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);
}
}
}

Answer 2

import java.util.Random;

public class Nova {
private boolean flag = false;
private int randomNum;
private int[] randomArray;

public Nova() {
SortThread st1 = new SortThread();
st1.start();
SortThread st2 = new SortThread();
st2.start();
if(st1.getTimeCost()>st2.getTimeCost()){
System.out.println("先执行完成的是线程："+st2.getId());
}else{
System.out.println("先执行完成的是线程："+st1.getId());
}

}

public int generateRandom(){
int a = (int)(Math.random()*10)+10;
System.out.println(a);
return a;
}

public int[] generateArray(int len){
int[] shadow = new int[len];
for(int i = 0;i < len;i++){
shadow[i++] = (int)(Math.random()*100)+8;
}
/*for(int j=0;j<shadow.length;j++){
System.out.print(shadow[j]+" ");
}*/

return shadow;
}

class SortThread extends Thread{

private double timecost;
/*public SortThread(){
Thread t = new Thread();
t.start();
}*/

public double getTimeCost(){
return timecost;
}
@Override
public void run() {

randomNum = generateRandom();
//randomArray = new int[randomNum];
randomArray = generateArray(randomNum);
int[] result;
if(flag){
synchronized (this) {
double d1 = System.currentTimeMillis();
result = bubbleSort(randomArray);
double d2 = System.currentTimeMillis();
timecost = d2-d1;
}
flag = false;
}else{

synchronized (this) {
double d1 = System.currentTimeMillis();
result = pivotSort(0, randomArray.length-1);
double d2 = System.currentTimeMillis();
timecost = d2-d1;
}
flag = true;
}
display(result);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

public void display(int data[])
{
for(int i=0;i<data.length;i++)
{
System.out.print(data[i]);
System.out.print(" ");
}
System.out.println();
}

private int[] bubbleSort(int[] data){

for(int i=0;i<data.length;i++){
for(int j=0;j<data.length-1-i;j++){
if(data[j]>data[j+1]){ //如果后一个数小于前一个数交换
int tmp=data[j];
data[j]=data[j+1];
data[j+1]=tmp;
}
}
}
return data;
}

private int[] pivotSort(int low,int high){

if(low<high){
int result = partition(randomArray,low,high);
pivotSort(low,result-1);
pivotSort(result+1,high);
}
return randomArray;
}

private int partition(int sortArray[],int low,int hight){
int key = sortArray[low];

while(low<hight)
{
while(low<hight && sortArray[hight]>=key)
hight--;
sortArray[low] = sortArray[hight];
while(low<hight && sortArray[low]<=key)
low++;
sortArray[hight] = sortArray[low];
}
sortArray[low] = key;
return low;
}

public static void main(String[] args) {
Nova nova = new Nova();
}
}本回答被网友采纳

Answer 3

public class SortThread {
public static void main(String[] args) {
Array array = new Array();
quickSort cn = new quickSort(array);
new Thread(cn).start();
bubbleSort sn = new bubbleSort(array);
new Thread(sn).start();

}
}

class Array {

private int[] nums = new int[10];

public int[] getNums() {
return nums;
}

public void setNums(int[] nums) {
this.nums = nums;
}

public Array() {
int[] temp = new int[10];
for (int i = 0; i < nums.length; i++) {
temp[i] = (int)(Math.random() * 89 + 10);
}
this.setNums(temp);
}

public synchronized void quick() {
long startTime = System.currentTimeMillis();
_quickSort(0, this.getNums().length - 1);
long endTime = System.currentTimeMillis();
for (int i = 0; i < this.getNums().length; i++) {
System.out.print(this.getNums()[i]);
if (i < this.getNums().length - 1) {
System.out.print(" < ");
}
}
System.out.println("    快速排序使用的时间为：" + (endTime - startTime) + "ms");
}

private int partition(int[] nums,int low,int hight) {
        int key = nums[low];
        while(low < hight){
            while(low < hight && nums[hight] >= key)
                hight--;
            nums[low] = nums[hight];
          while(low < hight && nums[low] <= key)
              low++;
          nums[hight] = nums[low];
      }
      nums[low] = key;
      return low;
  }

  public void _quickSort(int low,int hight) {
      if (low < hight) {
          int result = partition(this.getNums(),low,hight);
          _quickSort(low,result - 1);
          _quickSort(result + 1,hight);
      }
  }

public synchronized void bubble() {
long startTime = System.currentTimeMillis();
for (int i = 0; i < this.getNums().length - 1; i++) {
for (int j = i + 1; j < this.getNums().length; j++) {
int temp = 0;
if (this.getNums()[i] > this.getNums()[j]) {
temp = this.getNums()[i];
this.getNums()[i] = this.getNums()[j];
this.getNums()[j] = temp;
}
}
}
long endTime = System.currentTimeMillis();
for (int i = 0; i < this.getNums().length; i++) {
System.out.print(this.getNums()[i]);
if (i < this.getNums().length - 1) {
System.out.print(" < ");
}
}
System.out.println("    冒泡排序使用的时间为：" + (endTime - startTime) + "ms");
}
}

class quickSort implements Runnable {

public Array array;

public quickSort(Array array) {
this.array = array;
}

public void run() {
array.quick();
}
}

class bubbleSort implements Runnable {

public Array array;

public bubbleSort(Array array) {
this.array = array;
}

public void run() {
array.bubble();
}
}