【算法导论】第八章之桶排序

最新推荐文章于 2023-03-10 11:16:27 发布

「已注销」

最新推荐文章于 2023-03-10 11:16:27 发布

阅读量703

点赞数

CC 4.0 BY-SA版权

分类专栏： Algorithm

本文链接：https://blog.youkuaiyun.com/joe_007/article/details/8363733

Algorithm 专栏收录该内容

26 篇文章

订阅专栏

本文介绍了桶排序算法的应用，通过生成随机数组并对其进行桶排序，实现高效的数组排序过程。详细解释了算法步骤，包括生成输入数组、桶排序操作及打印排序后的数组。

aaaaaa

package com.zhoujie;

import java.util.ArrayList;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;

/**
 * backet sort
 * @author zhoujie
 *
 */
public class BacketSort {
	public static final int ARRAY_LENGTH = 100;
	public static final int ARRAY_MAX_VALUE = 1000;

	public static final String LOG_PREFIX = "=====================";
	public static final String LOG_SUFFIX = LOG_PREFIX;
	public static final String ARR_DELIMITER = "\t";

	public static void main(String[] args) {
		// 1. generate input array
		Random random = new Random();

		int[] intArr = new int[ARRAY_LENGTH];
		printLine(LOG_PREFIX + "The original array is:" + LOG_SUFFIX);
		for (int i = 0; i < intArr.length; i++) {
			intArr[i] = random.nextInt(ARRAY_MAX_VALUE);
			print(intArr[i]);
			if (i != intArr.length - 1) {
				print(ARR_DELIMITER);
			}
		}
		printLine("");

		// 2. backet sort
		intArr = backetSort(intArr);

		// 3. print sorted array
		printLine(LOG_PREFIX + "The sorted array is:" + LOG_SUFFIX);
		printLine(join(intArr, ARR_DELIMITER));
	}

	private static int[] backetSort(int[] intArr) {
		int [] resultArr = new int[intArr.length];
		Map<Integer, ArrayList<Double>> map = new TreeMap<Integer, ArrayList<Double>>();
		double[] doubleArr = new double[intArr.length];
		int i = 0;
		for(int item : intArr){
			doubleArr[i++] = item/(double)ARRAY_MAX_VALUE;
		}
		double step = 1/(double)doubleArr.length;
		printLine("step:" + step);

		// insert into backet
		for(double item : doubleArr){
			int backetIndex = (int) Math.floor(item*doubleArr.length);
			ArrayList<Double> list = map.get(backetIndex);
			if(list == null){
				list = new ArrayList<Double>();
				map.put(backetIndex, list);
			}
			list.add(item);
		}

		int count = 0;
		// sort every backet
		for(int key : map.keySet()){
			ArrayList<Double> list = map.get(key);
			int[] tempArr = new int[list.size()];
			int j = 0;
			for(double item : list){
				tempArr[j++] = (int) (item * ARRAY_MAX_VALUE);
			}

			QuickSort.quickSort(tempArr);
			for(int item : tempArr){
				resultArr[count++] = item;
			}
		}
		return resultArr;
	}

	public static void print(Object t) {
		System.out.print(t);
	}

	public static void printLine(Object t) {
		System.out.println(t);
	}

	public static String join(int[] arr, String delimiter) {
		StringBuilder sb = new StringBuilder();
		for (int element : arr) {
			sb.append(element);
			sb.append(delimiter);
		}
		return sb.substring(0, sb.length());
	}

}

aaaaaa