分组排序的一个实现
问题如下：
有一排红黑混合的球，标有重复数字无序排列，例如：{R3, R1, B2, B4, R1, R4, R2, B1, B3, B2, B1}。现在希望进行先红后黑由小到大的排序，并且这些球原先所在位置的下标要由小到大（红黑区别）
思路如下：
1、此题目主要考察对排序算法中的稳定排序的熟悉程度
2、稳定排序中主要考虑冒泡和归并(JDK中的Arrays.sort就是使用mergeSort)两种排序
Ball类
import lombok.Data;
@Data
public class Ball {
private Integer id; // 球号码
private String color; // red || black
private Integer index; // 球下标
public Ball() {}
public Ball(Integer id, String color) {
this.id = id;
this.color = color;
}
public Ball(Integer id, String color, Integer index) {
this.id = id;
this.color = color;
this.index = index;
}
}
冒泡排序的实现如下：
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import lombok.Data;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Data
public class BallBubbleSort {
private Map<String, Ball[]> result = new HashMap<String, Ball[]>();
public Map<String, Ball[]> sort(Ball[] balls) {
Ball[] reds = assemblyBallArray(balls, "Red");
Ball[] blacks = assemblyBallArray(balls, "Black");
bubbleSortLowAndHigh(reds);
bubbleSortLowAndHigh(blacks);
Map<String, Ball[]> result = new HashMap<String, Ball[]>();
result.put("Red", reds);
result.put("Black", blacks);
return result;
}
public void sort2(Ball[] balls) {
Ball[] reds = assemblyBallArray(balls, "Red");
Ball[] blacks = assemblyBallArray(balls, "Black");
bubbleSortLowAndHigh(reds);
bubbleSortLowAndHigh(blacks);
result.put("Red", reds);
result.put("Black", blacks);
}
public Ball[] assemblyBallArray(Ball[] balls, String type) {
List<Ball> res = Lists.newArrayList();
for (Ball ball : balls) {
if (ball.getColor().equals(type)) res.add(ball);
}
return res.toArray(new Ball[res.size()]);
}
/*public Ball[] assemblyBallArray(Ball[] balls, String type) {
List<Ball> ballList = null;
if (ballList == null) {
ballList = Lists.newArrayList();
for (Ball ball : balls) {
if (ball.getColor().equals(type)) ballList.add(ball);
}
}
List<Ball> res = ballList;
ballList = null;
return res.toArray(new Ball[res.size()]);
}*/
public void bubbleSortBall(Ball[] balls) {
for (int k = 0; k < balls.length; k++) {
balls[k].setIndex(k);
}
for (int i = 0; i < balls.length - 1; i++) {
for (int j = 0; j < balls.length - i - 1; j++) {
if(balls[j].getId() > balls[j+1].getId()) {
Ball tmp = balls[j];
balls[j] = balls[j+1];
balls[j+1] = tmp;
}
}
}
}
public void bubbleSortBallOptimizePos(Ball[] balls) {
for (int k = 0; k < balls.length; k++) {
balls[k].setIndex(k);
}
int arrLen = balls.length - 1; //初始时,最后位置保持不变
while (arrLen > 0) {
int pos = 0; //每趟开始时,无记录交换
for (int i = 0; i < arrLen; i++) {
if(balls[i].getId() > balls[i + 1].getId()) {
pos = i; //记录交换的位置
Ball tmp = balls[i];
balls[i] = balls[i + 1];
balls[i + 1] = tmp;
System.out.println("pos -> " + pos);
}
}
arrLen = pos; //为下一趟排序作准备
System.out.println("arrLen -> " + arrLen);
}
}
public void bubbleSortLowAndHigh(Ball[] balls) {
for (int k = 0; k < balls.length; k++) {
balls[k].setIndex(k);
}
int low = 0;
int high= balls.length-1; //设置变量的初始值
int j = 0;
Ball tmp = null;
while (low < high) {
for (j = low; j < high; ++j) { //正向冒泡,找到最大者
if (balls[j].getId() > balls[j + 1].getId()) {
tmp = balls[j]; balls[j]=balls[j + 1];balls[j + 1]=tmp;
}
}
--high; //修改high值, 前移一位
for (j = high; j>low; --j) { //反向冒泡,找到最小者
if (balls[j].getId() <balls[j - 1].getId()) {
tmp = balls[j]; balls[j]=balls[j - 1];balls[j - 1]=tmp;
}
}
++low; //修改low值,后移一位
}
}
public static void main(String[] args) {
Ball R1 = new Ball(1, "Red");
Ball R2 = new Ball(3, "Red");
Ball R3 = new Ball(4, "Red");
Ball R4 = new Ball(2, "Red");
Ball R5 = new Ball(1, "Red");
Ball B1 = new Ball(2, "Black");
Ball B2 = new Ball(4, "Black");
Ball B3 = new Ball(1, "Black");
Ball B4 = new Ball(3, "Black");
Ball[] balls = {R3, R1, B2, B4, R4, B1, R2, B3, R5};
BallBubbleSort ballBubbleSort = new BallBubbleSort();
ballBubbleSort.sort2(balls);
System.out.println(JSON.toJSONString(ballBubbleSort.getResult()));
// System.out.println(JSON.toJSONString(ballBubbleSort.sort(balls)));
/* 默认冒泡算法复杂度 */
int[] a = {3, 1, 4, 1, 2};
int countOutside1 = 0;
int countInside1 = 0;
for(int i =0 ; i< a.length-1; i++) {
countOutside1++;
for(int j = 0; j < a.length-i-1; j++) {
countInside1++;
if(a[j] > a[j+1])
{
int tmp = a[j] ; a[j] = a[j+1] ; a[j+1] = tmp;
}
}
}
System.out.println(countOutside1);
System.out.println(countInside1);
/* 第一种改良冒泡算法复杂度 */
int[] b = {3, 1, 4, 1, 2};
int countOutside2 = 0;
int countInside2 = 0;
int arrLen = b.length - 1;
while (arrLen > 0) {
countOutside2++;
int pos = 0;
for (int i = 0; i < arrLen; i++) {
countInside2++;
if(b[i] > b[i + 1]) {
pos = i;
int tmp = b[i] ; b[i] = b[i+1] ; b[i+1] = tmp;
}
}
arrLen = pos;
}
System.out.println("======");
System.out.println(countOutside2);
System.out.println(countInside2);
/* 第二种改良冒泡算法复杂度 */
int[] c = {3, 1, 4, 1, 2};
int countOutside3 = 0;
int countInside3To1 = 0;
int countInside3To2 = 0;
int low = 0;
int high= c.length-1;
int tmp,j;
while (low < high) {
countOutside3++;
for (j= low; j< high; ++j) {
countInside3To1++;
if (c[j]> c[j+1]) {
tmp = c[j]; c[j]=c[j+1];c[j+1]=tmp;
}
}
--high;
for (j=high; j>low; --j) {
countInside3To2++;
if (c[j]<c[j-1]) {
tmp = c[j]; c[j]=c[j-1];c[j-1]=tmp;
}
}
++low;
}
System.out.println("======");
System.out.println(countOutside3);
System.out.println(countInside3To1);
System.out.println(countInside3To2);
System.out.println("POP Sort ->" + JSON.toJSONString(a));
System.out.println("POP Sort ->" + JSON.toJSONString(b));
System.out.println("POP Sort ->" + JSON.toJSONString(c));
}
}
归并排序的实现如下：
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import lombok.Data;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Data
public class BallMergeSort {
private Map<String, Ball[]> result = new HashMap<String, Ball[]>();
public void mergearray(Ball[] balls, int first, int mid, int last, Ball[] temp) {
int i = first, j = mid + 1;
int m = mid, n = last;
int k = 0;
while (i <= m && j <= n)
{
if (balls[i].getId() <= balls[j].getId())
temp[k++] = balls[i++];
else
temp[k++] = balls[j++];
}
while (i <= m)
temp[k++] = balls[i++];
while (j <= n)
temp[k++] = balls[j++];
for (i = 0; i < k; i++)
balls[first + i] = temp[i];
}
public void mergesort(Ball[] balls, int first, int last, Ball[] temp) {
if (first < last)
{
int mid = (first + last) / 2;
mergesort(balls, first, mid, temp); //左边有序
mergesort(balls, mid + 1, last, temp); //右边有序
mergearray(balls, first, mid, last, temp); //再将二个有序数列合并
}
}
public boolean MergeSort(Ball[] balls, int n) {
for (int k = 0; k < balls.length; k++) {
balls[k].setIndex(k);
}
Ball[] p = new Ball[n];
if (p == null)
return false;
mergesort(balls, 0, n - 1, p);
return true;
}
public void sort(Ball[] balls) {
for (int k = 0; k < balls.length; k++) {
balls[k].setIndex(k);
}
Ball[] reds = assemblyBallArray(balls, "Red");
Ball[] blacks = assemblyBallArray(balls, "Black");
Ball[] redsTmp = new Ball[reds.length];
Ball[] blacksTmp = new Ball[blacks.length];
mergesort(reds, 0, reds.length - 1, redsTmp);
mergesort(blacks, 0, blacks.length - 1, blacksTmp);
result.put("Red", reds);
result.put("Black", blacks);
}
public Ball[] assemblyBallArray(Ball[] balls, String type) {
List<Ball> res = Lists.newArrayList();
for (Ball ball : balls) {
if (ball.getColor().equals(type)) res.add(ball);
}
return res.toArray(new Ball[res.size()]);
}
public static void main(String[] args) {
Ball R1 = new Ball(1, "Red");
Ball R2 = new Ball(3, "Red");
Ball R3 = new Ball(4, "Red");
Ball R4 = new Ball(2, "Red");
Ball R5 = new Ball(1, "Red");
Ball B1 = new Ball(2, "Black");
Ball B2 = new Ball(4, "Black");
Ball B3 = new Ball(1, "Black");
Ball B4 = new Ball(3, "Black");
Ball[] balls = {R3, R1, B2, B4, R4, B1, R2, B3, R5};
// Ball[] balls = {R3, R1, R4, R2, R5};
BallMergeSort ballMergeSort = new BallMergeSort();
// ballMergeSort.MergeSort(balls, balls.length);
ballMergeSort.sort(balls);
System.out.println(JSON.toJSONString(ballMergeSort.getResult()));
}
}
