计数排序和桶排序 java代码实现

计数排序

java代码实现

package csdn.dreamzuora.sort;

import java.util.List;

/**
 * Title: 抽象出排序类
 * Description:
 *
 * @version 1.0
 * @author: weijie
 * @date: 2020/10/22 17:59
 */
public abstract class Sort<E> {


    public void sort(List<E> array){

    };

    public void sort(List<E> array, int left, int right){

    };

}

package csdn.dreamzuora.sort;

import java.util.ArrayList;
import java.util.List;

/**
 * Title: 计数排序
 * Description:
 * 思想：牺牲空间换取时间 计数排序需要占用大量空间，它仅适用于数据比较集中的情况
 * @version 1.0
 * @author: weijie
 * @date: 2020/10/26 23:30
 */
public class CountSort extends Sort<Integer> {
    @Override
    public void sort(List<Integer> array) {
        int size = array.size();
        Integer max = array.get(0);
        Integer min = array.get(0);
        //找出最大值，最小值
        for (int i = 1; i < size; i++){
            Integer val = array.get(i);
            if (max < val){
                max = val;
            }
            if (min > val){
                min = val;
            }
        }
        //计算空间占用
        int len = max - min;
        //数值偏移量
        int offset = min;
        //利用最大值和最小值分配空间
        int [] tempList = new int[len + 1];
        for (int i = 0; i < size; i++){
            Integer val = array.get(i) - offset;
            Integer count = tempList[val];
            if (count == null){
                count = 0;
            }
            tempList[val] = ++count;
        }
        int k = 0;
        for (int i = 0; i < len; i++){
            Integer count = tempList[i];
            if (count != null){
                while (count != 0){
                    array.set(k++, i + offset);
                    count --;
                }
            }
        }
    }
}

单元测试

package csdn.dreamzuora.sort;

import org.junit.Test;
import org.junit.jupiter.api.Assertions;

import java.util.Arrays;
import java.util.List;

import static org.junit.Assert.*;

/**
 * Title:
 * Description:
 *
 * @version 1.0
 * @author: weijie
 * @date: 2020/10/27 12:12
 */
public class CountSortTest {

    @Test
    public void sort() {
        CountSort countSort = new CountSort();
        List<Integer> list = Arrays.asList(4, 8, 4, 6, 2, 10);
        List<Integer> expectList = Arrays.asList(2, 4, 4, 6, 8, 10);
        countSort.sort(list);
        Assertions.assertEquals(expectList, list);
    }
}

桶排序

java代码实现

package csdn.dreamzuora.sort;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

/**
 * Title: 桶排序
 * Description: 注意和计数排序区别
 * 桶排序可用于最大最小值相差较大的数据情况，比如[9012,19702,39867,68957,83556,102456]。
 *
 * 思想：把数组 arr 划分为n个大小相同子区间（桶），每个子区间各自排序，最后合并
 * 计数排序是桶排序的一种特殊情况
 *
 * @url:https://www.cnblogs.com/qq1452753919/p/10506114.html
 *
 * @version 1.0
 * @author: weijie
 * @date: 2020/10/22 17:52
 */
public class BucketSort extends Sort<Integer>{

    @Override
    public void sort(List<Integer> array) {
        if (array == null || array.isEmpty()){
            return;
        }
        int max = array.get(0);
        int min = array.get(0);
        int size = array.size();
        for (int i = 0; i < size; i++){
            max = Math.max(array.get(i), max);
            min = Math.min(array.get(i), min);
        }
        int offset = max - min;
        int bucketSize = (max - min) / size + 1;
        List<LinkedList<Integer>> bucketList = new ArrayList<>(bucketSize);
        //桶初始化
        for (int i = 0; i < bucketSize; i++){
            bucketList.add(new LinkedList<>());
        }
        //将每个元素放入桶中
        for (int i= 0; i < size; i++){
            int val = array.get(i);
            // 3 17 20 48    45/5=9+1=10
            int num = (array.get(i) - min) * (bucketSize - 1) / offset;
            bucketList.get(num).add(val);
        }
        List<Integer> sortList = new ArrayList<>();
        //对每个桶进行排序
        for (int i = 0; i < bucketSize; i++){
            Collections.sort(bucketList.get(i));
        }
        //输出全部元素
        int index = 0;
        for (LinkedList<Integer> itemList : bucketList){
            for (Integer val : itemList){
                sortList.set(index++ , val);
            }
        }
    }
}

单元测试

package csdn.dreamzuora.sort;

import org.junit.Test;
import org.junit.jupiter.api.Assertions;

import java.util.*;

import static org.junit.Assert.*;

/**
 * Title:
 * Description:
 *
 * @version 1.0
 * @author: weijie
 * @date: 2020/10/27 23:45
 */
public class BucketSortTest {

    BubbleSort bubbleSort = new BubbleSort();

    @Test
    public void sort() {
        List<Integer> list = Arrays.asList(4, 8, 4, 6, 2, 10);
        List<Integer> expectList = Arrays.asList(2, 4, 4, 6, 8, 10);
        bubbleSort.sort(list);
        Assertions.assertEquals(expectList, list);
    }

    @Test
    public void sort2() {
        Random random = new Random();
        List<Integer> actuallyList = Arrays.asList(random.nextInt(100), random.nextInt(100), random.nextInt(100), random.nextInt(100), random.nextInt(100), random.nextInt(100));
        List<Integer> expectList = new ArrayList<>(actuallyList);
        Collections.sort(expectList);
        bubbleSort.sort(actuallyList);
        Assertions.assertEquals(expectList, actuallyList);
    }
}