今天送分活动，小程序题 - 黑马程序员技术交流社区

public class SortTime {
/**
* 模拟运动员赛跑计时器。
* 定义一个数组{90,34,65,2,1,4,67,32,54,23,11,43,33,41,35} .以三名运动员对这个数组排序为例，
* 三名运动员分别代表的是选择排序，冒泡排序，快速排序。设计计时器，记录他们所用的时间。
* 为了达到三名运动员同时跑，可以设定前一个要等后一个0.5毫秒
*/
public static void main(String[] args) {
//选择排序线程
new Thread(new Runnable(){
@Override
public synchronized void run() {
int arr[] = {90,34,65,2,1,4,67,32,54,23,11,43,33,41,35};
System.out.println("选择排序");
long begintime = System.nanoTime();
selectionSort(arr, 0, arr.length-1);
long endtime = System.nanoTime();
printArr(arr);
System.out.println();
System.out.println("选排序时间: "+(endtime-begintime));
}}).start();
new Thread(new Runnable(){
@Override
public synchronized void run() {
int arr[] = {90,34,65,2,1,4,67,32,54,23,11,43,33,41,35};
System.out.println("冒泡排序");
long begintime = System.nanoTime();
bubble(arr, 0, arr.length-1);
long endtime = System.nanoTime();
printArr(arr);
System.out.println();
System.out.println("冒泡排序: "+(endtime-begintime));
}}).start();
//快速排序线程
new Thread(new Runnable(){
@Override
public synchronized void run() {
int arr[] = {90,34,65,2,1,4,67,32,54,23,11,43,33,41,35};
System.out.println("快速排序");
long begintime = System.nanoTime();
quickSort(arr, 0, arr.length-1);
long endtime = System.nanoTime();
printArr(arr);
System.out.println();
System.out.println("快速排序时间："+(endtime-begintime));
}}).start();
}
//打印数组
public static void printArr(int[]arr){
for(int key:arr){
System.out.print(key+"\t");
}
}
//快速排序
public static void quickSort(int[]arr,int begin,int end){
if(begin>end){
return ;
}
int i = onceQuickSort(arr,begin, end);
quickSort(arr,begin,i-1);
quickSort(arr,i+1,end);
}
//一次快速排序
private static int onceQuickSort(int[] arr, int begin, int end) {
int i = begin;
int j = end;
int key = arr[i];
while(j>i){
while(arr[j]>key&&j>i){
j--;
}
if(j>i){
arr[i] = arr[j];
arr[j] = key;
}
while(arr[i]<key&&j>i){
i++;
}
if(j>i){
arr[j] = arr[i];
arr[i] = key;
}
}
return i;
}
//选择排序
public static void selectionSort(int[]arr,int begin,int end){
if(begin>end){
return ;
}
for(int i=0;i<end-1;i++){
int min = i;
for(int j = i+1;j<end;j++){
if(arr[min]>arr[j]&&min!=j){
int temp = arr[min];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
//冒泡排序
public static synchronized void bubble(int[]arr,int begin,int end){
for(int i =0;i<end-1;i++){
for(int j=i+1;j<end;j++){
if(arr[i]>arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
}

复制代码

package staticImport.cn.itcast.day4_test;
import java.util.concurrent.CyclicBarrier;
/**模拟运动员赛跑计时器。
定义一个数组{90,34,65,2,1,4,67,32,54,23,11,43,33,41,35} .以三名运动员对这个数组排序为例，
三名运动员分别代表的是选择排序，冒泡排序，快速排序。设计计时器，记录他们所用的时间。
为了达到三名运动员同时跑，可以设定前一个要等后一个0.5毫秒*/
//CyclicBarrier的作用：允许一组线程互相等待，直到到达某个公共屏障点。然后所有线程开始运行。
/**
* @author zhangzhongbao
*
*/
public class RaceTimerTest {
/**
* @param args
*/
public static void main(String[] args) {
// 这儿得创建三个线程，因为如果一个线程对数据改变了，其他线程用的还是改变了的数组。如果想要使用同步，应该不符合要求
final int data[] = { 90, 34, 65, 2, 1, 4, 67, 32, 54, 23, 11, 43, 33,
41, 35 };// 初始化一个数组
final int data2[] = { 90, 34, 65, 2, 1, 4, 67, 32, 54, 23, 11, 43, 33,
41, 35 };// 初始化一个数组
final int data3[] = { 90, 34, 65, 2, 1, 4, 67, 32, 54, 23, 11, 43, 33,
41, 35 };// 初始化一个数组
// 定义一个循环屏障
final CyclicBarrier barrier = new CyclicBarrier(3);
// 创建一个线程，并启动
new Thread(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + "已经做好准备");
try {
barrier.await();// 等其他人一块准备好
} catch (Exception e) {// 此处两个异常，不做处理
}
System.out.println(Thread.currentThread().getName() + "开始运行了");
// printArray(data);
long time1 = System.nanoTime() ;
selectSort(data);// 选择派讯
long time2 = System.nanoTime();
System.out.println(Thread.currentThread().getName()
+ "已经运行完毕,运行了" + (time2 - time1) + "s");
// printArray(data);
}
}, "哥们是选择排序").start();
// 创建一个线程，并启动
new Thread(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + "已经做好准备");
try {
barrier.await();// 等其他人一块准备好
} catch (Exception e) {// 此处两个异常，不做处理
}
System.out.println(Thread.currentThread().getName() + "开始运行了");
// printArray(data2);
long time1 = System.nanoTime();
bubbleSort(data2);// 冒泡排序你
long time2 = System.nanoTime();
System.out.println(Thread.currentThread().getName()
+ "已经运行完毕,运行了" + (time2 - time1) + "s");
// printArray(data2);
}
}, "哥们是冒泡排序").start();
// 创建一个线程，并启动
new Thread(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + "已经做好准备");
try {
barrier.await();// 等其他人一块准备好
} catch (Exception e) {// 此处两个异常，不做处理
}
System.out.println(Thread.currentThread().getName() + "开始运行了");
// printArray(data3);
long time1 = System.nanoTime();
quickSort(data3, 0, data3.length - 1);// 快速排序
long time2 = System.nanoTime();
// printArray(data3);
System.out.println(Thread.currentThread().getName()
+ "已经运行完毕,运行了" + (time2 - time1) + "s");
}
}, "哥们是快速排序").start();
}
/**
* 选择排序
*
* @param arr
*/
public static void selectSort(int arr[]) {
// 外层循环
for (int x = 0; x < arr.length - 1; x++) {
// 内层循环，每次减少一次
for (int y = x + 1; y < arr.length; y++) {
// 交换数据
if (arr[x] > arr[y]) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
/**
* 冒泡排序
*
* @param arr
*/
public static void bubbleSort(int arr[]) {
// 外层循环次数
for (int x = 0; x < arr.length - 1; x++) {
// 内层循环次数，每次都会减少一次
for (int y = 0; y < arr.length - x - 1; y++) {
// 交换数据
if (arr[y] > arr[y + 1]) {
int temp = arr[y];
arr[y] = arr[y + 1];
arr[y + 1] = temp;
}
}
}
}
public static void quickSort(int[] data, int low, int height) {
// 程序的出口，当low>=height的时候，程序自动退出本次递归调用
if (low < height) {
int middle = departion(data, low, height);
quickSort(data, low, middle - 1);
quickSort(data, middle + 1, height);
}
}
/**
* @param data
* @param low
* @param height
* @return 为data数组分区，以当前的data[low]作为比较的起始值，找出这个起始值的位置，
* 并返回起始值的位置，为sort的递归调用做准备
*/
private static int departion(int[] data, int low, int height) {
// 分区的起始值
int middle = data[low];
while (low < height) {
// 从数组的右边向左边逼近，如果右边的值小于起始值，停止该循环，并且将右边的元素的值赋给左边循环停止在low处元素
while (low < height && data[height] >= middle) {
height--;
}
// 将右边下标为height的元素的值赋给左边下标为low的元素
data[low] = data[height];
// 从数组的左边向右边逼近，如果左边元素的值大于起始值，停止循环，并且将左边元素的值赋给上次右边循环停止在height处元素
while (low < height && data[low] <= middle) {
low++;
}
// 将左边下标为low的元素的值赋给右边下标为height的元素
data[height] = data[low];
}
// 循环结束，找到最适合middle的位置，然后赋值
data[low] = middle;
return low;
}
public static void printArray(int data[]) {
for (int i = 0; i < data.length; i++) {
if (i < data.length - 1)
System.out.print(data[i] + ",");
else {
System.out.println(data[i]);
}
}
}
}

复制代码

/**
* 1、三个运动员需要定义为作为三个线程。这里将需要排序的数组定义为对象的属性，各自独立。
* 2、因为不涉及共享数据，所以没有必要进行同步操作。如果同步，反而无法模拟真实过程。
* 3、三个线程中的run()方法需要各不相同（需要执行不同的排序算法），只能分别实现。
* 4、由于争夺CPU资源的不确定性，比赛结果偶然性很大。但只能做到这一步了。
*
*/
public class RunTest {
public static void main(String[] args) {
//创建第一个线程。
new Thread(new Runnable(){
int[] arr = {58,56,3,8,22,59,10,60,4,40,52,14,37,26,53,
15,43,38,18,49,33,21,5,23,41,45,13,27,55,29,
30,7,50,32,20,47,35,48,12,17,39,9,24,42,16,
44,25,46,34,36,19,31,51,6,11,54,28,2,57,1};
public void run() {
try {
Thread.sleep(0, 2);
} catch (InterruptedException e) {
e.printStackTrace();
}
long startTime = System.nanoTime();
bubbleSort(arr);
long endTime = System.nanoTime();
System.out.println("冒泡排序用了" + (endTime-startTime) + "纳秒。");
}
}).start();
//创建第二个线程。
new Thread(new Runnable(){
int[] arr = {58,56,3,8,22,59,10,60,4,40,52,14,37,26,53,
15,43,38,18,49,33,21,5,23,41,45,13,27,55,29,
30,7,50,32,20,47,35,48,12,17,39,9,24,42,16,
44,25,46,34,36,19,31,51,6,11,54,28,2,57,1};
public void run() {
try {
Thread.sleep(0, 1);
} catch (InterruptedException e) {
e.printStackTrace();
}
long startTime = System.nanoTime();
selectSort(arr);
long endTime = System.nanoTime();
System.out.println("选择排序用了" + (endTime-startTime) + "纳秒。");
}
}).start();
//创建第三个线程。
new Thread(new Runnable(){
int[] arr = {58,56,3,8,22,59,10,60,4,40,52,14,37,26,53,
15,43,38,18,49,33,21,5,23,41,45,13,27,55,29,
30,7,50,32,20,47,35,48,12,17,39,9,24,42,16,
44,25,46,34,36,19,31,51,6,11,54,28,2,57,1};
public void run() {
long startTime = System.nanoTime();
quickSort(arr,0,arr.length-1);
long endTime = System.nanoTime();
System.out.println("快速排序用了" + (endTime-startTime) + "纳秒。");
}
}).start();
}
//冒泡排序。
public static void bubbleSort(int[] arr) {
//外围循环只需要arr.length-1次即可。这里从1开始。
for(int i=1; i<arr.length; i++) {
//完成i次循环后，后面i位不再需要参与排序。
for(int j=0; j<arr.length-i; j++) {
if(arr[j]>arr[j+1]) {
swap(arr,j,j+1);
}
}
}
}
//选择排序。
public static void selectSort(int[] arr) {
//选择排序的原理是每次循环拿最前面一个未排序的数依次与后面的数比较，因此外围循环下标从0开始。
for(int i=0; i<arr.length-1; i++) {
//此处定义一个变量，用于记录遍历过程中最小值的下标。
int index = i;
for(int j=i+1; j<arr.length; j++) {
if(arr[index]>arr[j]) {
index = j;
}
}
swap(arr,i,index);
}
}
//快速排序。
private static void quickSort(int[] arr, int start, int end) {
//定义本轮排序最左侧的下标。
int left = start;
//定义本轮排序最右侧的下标。
int right = end - 1;
//定义中间数，默认是最后一位。
int pivot = arr[end];
while (left < right) {
//自左至右查找大于中间数的数。
if (arr[left] <= pivot) {
left++;
continue;
}
//自右至左查找小于中间数的数。
if (arr[right] > pivot) {
right--;
continue;
}
//将大于中间数的数与小于中间数的数进行互换。
swap(arr, left++, right);
}
//这里再做一次确认，以保证小于中间数的数位于其左边，大的数位于其右边。
if (arr[left] < pivot) {
left++;
}
swap(arr, left, end);
//递归排序中间数左侧的数。
if(left - 1 > start) {
quickSort(arr, start, left - 1);
}
//递归排序中间数右侧的数。
if(left + 1 < end) {
quickSort(arr, left + 1, end);
}
}
//交换数组元素。
public static void swap(int[] arr, int m, int n) {
int temp = arr[m];
arr[m] = arr[n];
arr[n] = temp;
}
//打印int数组，用于测试。
public static void print(int[] arr){
for(int i=0; i<arr.length; i++) {
System.out.print(arr[i] + ",");
}
}
}

复制代码

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
今天的题目：模拟运动员赛跑计时器。
定义一个数组
{58,56,3,8,22,59,10,60,4,40,52,14,37,26,53,15,43,38,18,49,33,21,5,23,41,45,13,27,55,
29,30,7,50,32,20,47,35,48,12,17,39,9,24,42,16,44,25,46,34,36,19,31,51,6,11,54,28,2,57,1} .
以三名运动员对这个数组排序为例，
三名运动员分别代表的是选择排序，冒泡排序，快速排序。设计计时器，记录他们所用的时间。
为了达到三名运动员同时跑，可以设定前一个要等后一个1纳秒
注：该加注释的地方要加注释请附带结果图
* @author Lian
*
*/
public class MyTimerCounter {
public static void main(String[] args) {
int[] data = {58,56,3,8,22,59,10,60,4,40,52,14,37,26,53,15,43,38,18,49,33,21,5,23,
41,45,13,27,55,29,30,7,50,32,20,47,35,48,12,17,39,9,24,42,16,44,25,
46,34,36,19,31,51,6,11,54,28,2,57,1};
System.out.println("原始排序: ");
SortUtil.printArray(data);//打印一开始的数据
Runnable command = null;
ExecutorService pool = Executors.newCachedThreadPool();
final CountDownLatch order = new CountDownLatch(1);
int counter = 3;//要创建的运动员数目
for(int i=0; i<counter; i++){//这里分配了3个线程，0-冒泡，1-选择，2-快速
final int count = i;
command = new Runnable(){
@Override
public void run(){
int[] data = {58,56,3,8,22,59,10,60,4,40,52,14,37,26,53,15,43,38,18,49,33,21,5,23,
41,45,13,27,55,29,30,7,50,32,20,47,35,48,12,17,39,9,24,42,16,44,25,
46,34,36,19,31,51,6,11,54,28,2,57,1};
//比赛过程排序打印时间等
MyTimerCounter.race(order, count, data);
}
};
//执行
pool.execute(command);
}
try {
Thread.sleep(0,1);
order.countDown();//计数器归零等待的线程开始执行
} catch (InterruptedException e) {
e.printStackTrace();
}
pool.shutdown();
}
//主要执行部分
public static void race(final CountDownLatch order, final int count, int[] data) {
String name = null;
switch(count){
case 0:name="运动员-冒泡";
break;
case 1:name="运动员-选择";
break;
case 2:name="运动员-快速";
break;
}
System.out.println(name+",准备开跑...");
try {
order.await();//等待执行
}
catch (InterruptedException e) {
e.printStackTrace();
}
long begin = System.nanoTime();
switch(count){
case 0:data = SortUtil.bubbleSort(data);
break;
case 1:data = SortUtil.selectionSort(data);
break;
case 2:data = SortUtil.quickSort(data,0,data.length);
break;
}
long end = System.nanoTime();
//打印排序后的结果
SortUtil.printArray(data,name,begin,end);
}
}
class SortUtil{
//冒泡排序
public static int[] bubbleSort(int[] data){
for(int i=0; i<data.length; i++){
for(int j=i ; j<data.length; j++){
if(data[j]<data[i]) swap(data, i, j);
}
}
return data;
}
//选择排序
public static int[] selectionSort(int[] data){
int minIndex;
for (int i=0; i<data.length; i++) {
minIndex = i;//假设每轮第一个元素为最小元素
//从每轮比较的开始元素的下一元素开始循环，因为自己没必要和自己比
for (int j=i+1;j<data.length; j++) {
//如果有比当前data[minIndex]更小的元素，则将该元素索引的值j替换minIndex，
//保证 minIndex存放的是本轮数组最小值的索引值
if (data[j]<data[minIndex]) {
minIndex = j;
}
}
//当最小元素索引确定后，则把该索引位置与本轮比较开始位置的数组数字相交换
swap(data, i, minIndex);
}
return data;
}
//快速排序
public static int[] quickSort(int[] data,int left,int right){
int i = left;
int j = right;
int flag = data[left]; //选一个数作为比较的基准数字小的放左边，大的放右边(先分然后把基准数字挪到中间) 通常选择的是第一个
while(true)
{
//从第二个数开始找大于基准数字的数 ,从前面开始找大于flag(即data[left])的数，
//如果data[i]>flag(即data[left]),循环结束,得到的i即为第一个大于基准数字flag的数字的数组索引；
while((++i)<right-1 && data[i]<flag);
//从最后一个数开始找第一个小于基准数字flag(即data[left])的数
//如果data[i]<flag,循环结束,得到的i即为第一个小于基准数字flag的数字的数组索引；
while((--j)>left && data[j]>flag);
//如果从左右两边寻找的数组索引位置出现了交叉的话，就说明根据基准数字分开的大小两份已经分好了（可以根据打印结果来看）
//于是一次排序的循环过程结束，跳出循环后，将基准数字挪到分好的两组数字的中间
if(i>=j) break;
//交换两边找到的数
SortUtil.swap(data, i, j);
//可以自定义个方法用来打印每次排序后的即时排序状况
//printArray(data);
}
//把基准数据放到相对于该基准数字而分的大小两组数字的中间
swap(data, left, j);
//递归快排基准数字左边的数据这时候的基准数据取得是基准数字左边所有数字左起的第一个
if(left<j)
quickSort(data,left,j);
//递归快排基准数字右边的数据这时候的基准数据取得是基准数字右边所有数字左起的第一个
if(right>i)
quickSort(data,i,right);
return data;
}
//数组两位置数字交换方法
public static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
data[i] - data[j];
}
//数组值打印方法有时间
public synchronized static void printArray(int[] data,String name, long begin,long end){
System.out.println();
System.out.println(name+" 到终点的结果:");
for(int i : data){
System.out.print(i+",");
}
System.out.println();
System.out.println(name+" 跑完全程耗时："+(end-begin)+" 纳秒...");
}
//打印数组数字无时间
public synchronized static void printArray(int[] data){
for(int i : data){
System.out.print(i+",");
}
System.out.println();
}
}

复制代码