泡泡排序的并行实现

时间:2017-10-10 08:31:55

标签: java arrays

这个项目的主要思想是并行冒泡排序。我对这个项目的处理方法是,创建一个大数组,然后根据线程数将其划分为部分(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) {
    }
}

1 个答案:

答案 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仍然比泡泡排序的个人实现更快是多余的。