这个项目的主要思想是并行冒泡排序。我对这个项目的处理方法是，创建一个大数组，然后根据线程数将其划分为部分（4或5）。例如，如果数组的大小是10，我将它分成2个子数组，0-4和5-9，然后一个线程必须扫描大数组，如果值在0-4之间，则分配第一个子数组，如果不分配给下一个子数组。然后将泡泡排序算法同时应用于所有子阵列。最后，应将所有子数组添加到线程安全队列中。 现在我有三个类，我创建数组的主类，用于改组数组的U tiles类，查找数组的最小值和最大值以及具有冒泡排序算法的冒泡排序类。 我现在面临的挑战是，如何将大数组划分为小的子数组，并用值填充子数组。 我将感谢所有的建议和帮助。下面是我的课程。
package com.company;
import javax.xml.transform.sax.SAXSource;
import java.util.Random;
public class Main {
public static void main(String[] args) {
// filling the array with integer values
int[] anArray = Utils.fillArray((int) 10);
Utils.shuffleArray(anArray);
// find the min and max of the array
System.out.println("************************");
BubbleSort sort = new BubbleSort(anArray);
profiler.start();
sort.sortMethod();
// Utils.printArray(anArray);
Utils.findMinMax(anArray);
}
}
package com.company;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
public class Utils {
private static volatile int max;
private static volatile int min;
private static int[][] arrays;
public Utils(int[][] arrays,int[] array) {
max = array[0];
min = array[0];
}
// taken from the kings class
// source: http://stackoverflow.com/questions/1519736/random-shuffling-of-an-array
// Implementing Fisher�Yates shuffle
public static void shuffleArray(int[] ar) {
// If running on Java 6 or older, use `new Random()` on RHS here
ThreadLocalRandom rnd = ThreadLocalRandom.current();
for (int i = ar.length - 1; i > 0; i--) {
int index = rnd.nextInt(i + 1);
// Simple swap
int a = ar[index];
ar[index] = ar[i];
ar[i] = a;
}
}
public static void printArray(int[] anArray) {
System.out.print("Array: ");
for (int i=0; i< anArray.length; i++){
System.out.print(anArray[i]+" ");
}
System.out.println();
}
public static int[] fillArray(int amount) {
int[] result = new int[amount];
for (int i=0; i<amount; i++){
result[i] = i;
}
return result;
}
public static void findMinMax(int[] array) {
int i = 0;
for (; i < (array.length) / 2; i++) {
int num1 = array[1 * 2];
int num2 = array[i * 2 + 1];
if (num1 >= num2) {
if (num1 > max)
max = num1;
if (num2 < min)
min = num2;
} else {
if (num2 > max) {
max = num2;
if (num1 < min)
min = num1;
}
}
}
if (i * 2 < array.length) {
int num = array[i * 2];
if (num > max)
max = num;
if (num < min)
min = num;
}
System.out.println("min is: " + min);
System.out.println("max is : " + max);
}
}
public static int getMax() {
return max;
}
public static int getMin() {
return min;
}
public static void print(int[] anArray, int i) {
}
}
答案 0 :(得分：0)
我认为您应该尝试使用Fork / Join进行合并排序。
喜欢这里：
import java.util.Random;
import java.util.concurrent.*;
/**
* Example of Merge Sort using Fork/Join framework.
*
* @author L.Gobinath
*/
public class ForkJoinArraySort {
// From Java 7 '_' can be used to separate digits.
public static final int ARRAY_SIZE = 10_000_000;
public static void main(String[] args) {
// Create a pool of threads
ForkJoinPool pool = new ForkJoinPool();
int[] array = createArray(ARRAY_SIZE);
long startTime;
long endTime;
MergeSort mergeSort = new MergeSort(array, 0, array.length - 1);
startTime = System.currentTimeMillis();
pool.invoke(mergeSort); // Start execution and wait for result/return
endTime = System.currentTimeMillis();
System.out.println("Time taken: " + (endTime - startTime) + " millis");
}
/**
* Create an array with random numbers.
* @param size Size of the array.
* @return An array with the given size.
*/
private static int[] createArray(final int size) {
int[] array = new int[size];
Random rand = new Random();
for (int i = 0; i < size; i++) {
array[i] = rand.nextInt(1000);
}
return array;
}
}
/**
* Extends RecursiveAction.
* Notice that the compute method does not return anything.
*/
class MergeSort extends RecursiveAction {
private int array[];
private int left;
private int right;
public MergeSort(int[] array, int left, int right) {
this.array = array;
this.left = left;
this.right = right;
}
/**
* Inherited from RecursiveAction.
* Compare it with the run method of a Thread.
*/
@Override
protected void compute() {
if (left < right) {
int mid = (left + right) / 2;
RecursiveAction leftSort = new MergeSort(array, left, mid);
RecursiveAction rightSort = new MergeSort(array, mid + 1, right);
invokeAll(leftSort, rightSort);
merge(left, mid, right);
}
}
/**
* Merge two parts of an array in sorted manner.
* @param left Left side of left array.
* @param mid Middle of separation.
* @param right Right side of right array.
*/
private void merge(int left, int mid, int right) {
int temp [] = new int[right - left + 1];
int x = left;
int y = mid + 1;
int z = 0;
//There some kind of sort at the leaf
//You can use your BubbleSort class
//***************************************************************
while (x <= mid && y <= right) {
if (array[x] <= array[y]) {
temp[z] = array[x];
z++;
x++;
} else {
temp[z] = array[y];
z++;
y++;
}
}
//***************************************************************
while (y <= right) {
temp[z++] = array[y++];
}
while (x <= mid) {
temp[z++] = array[x++];
}
for (z = 0; z < temp.length; z++) {
array[left + z] = temp[z];
}
}
}
（我有自己的算法，在那里我使用了合并排序，在我研究算法化的时候在叶子节点中使用冒泡排序排序。但是很久以前，我丢失了它，抱歉。）
P.S。我认为回忆起Array.sort仍然比泡泡排序的个人实现更快是多余的。