一个看起来似乎很简单的算法，突然卡住了，大家起来看下怎么解决
现有两个简单数组A与B：
一、 int[] A = {8,2,3,3,2,7};
二、 String[] B = new String[]{"a","b","c","d","e","f"};
现我要求，这两个数组的下标要实现一一对应，即8-a,2-b,3-c,3-d,2-e,7-f
此时，我想实现，当我对A数组进行排序时（比如升序排为：{2,2,3,3,7,8}）
如何简单的同步实现数组B的跟着A变换化呢?
比如，当A升级排序时，此时，B要变为：{b,e,c,d,f,a}(要据文红色对应的原则)
楼主一开始想到用TreeMap来做，当由于A中有相对的数值，不符合KEY唯一性的要求，实现不了，所以就一时似乎卡住了，各位高人怎么看?
Pair 是什么?怎么定义?
类似这样
public class Pair implements Comparable<Pair>{
//
int number;
String name;
//
public int compareTo(Pair p){
return this.number-p.number;
}
}[解决办法]
在排序的过程中,创建另一个下标数组就可以了,
int[] A = {8,2,3,3,2,7};
int[] SORT = {0,1,2,3,4,5};
当A变成{2,2,3,3,7,8}
SORT变成{1,4,2,3,5,0}
[解决办法]
其实treemap是完全可以用的，你只需要将key值设成double类型遇到相同的键值将其小数位递增
[解决办法]
我就会用笨办法:
import java.util.*;
public class ArraysAB {
public static void main(String[] args) {
int[] A = { 8, 2, 3, 3, 2, 7 };
String[] B = { "a", "b", "c", "d", "e", "f" };
Set<AB> set = new TreeSet<AB>();//把二个数组内容连同下标封装成对象.放TreeSet里。
for(int i = 0; i< A.length; i++)
{
AB ab = new AB(A[i], i, B[i]);
set.add(ab);
}
//将排序后的容器内容，存放数组输出。
//
int[] A1 = new int[A.length];//排序后的A.
String[] B1 = new String[A.length];//排序后的B
//int[] indexA = new int[A.length];//原数组A的下标顺序。
int k =0;
for(AB ab0:set)
{
A1[k] = ab0.getA();
B1[k] = ab0.getB();
//indexA[k] = ab0.getIndex();
k++;
}
System.out.println(" -------- 排序前数组： -------------");
System.out.println(Arrays.toString(A));
System.out.println(Arrays.toString(B));
System.out.println(" ********* 排序后数组：*************");
System.out.println(Arrays.toString(A1));
System.out.println(Arrays.toString(B1));
//System.out.println(Arrays.toString(indexA));
}
}
//类AB 用于封装数组的内容。
//
class AB implements Comparable<AB> {
private int a;
private int index;
private String b;
public AB(int a, int index, String b) {
this.a = a;
this.b = b;
this.index = index;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + a;
result = prime * result + ((b == null) ? 0 : b.hashCode());
result = prime * result + index;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
AB other = (AB) obj;
if (a != other.a)
return false;
if (b == null) {
if (other.b != null)
return false;
} else if (!b.equals(other.b))
return false;
if (index != other.index)
return false;
return true;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public String getB() {
return b;
}
public void setB(String b) {
this.b = b;
}
public int compareTo(AB other) {
if (this.a > other.a) {
return 1;
} else if ((this.a == other.a) && (this.index > other.index )) {
return 1;
}else if((this.a == other.a) && (this.index == other.index )){
return 0;
}else{
return -1;
}
}
}
[解决办法]
package test;
public class SortTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] A = {8,2,3,3,2,7};
String[] B = new String[]{"a","b","c","d","e","f"};
for(int i=0;i<A.length;i++){
System.out.print(A[i]+"--"+B[i]+"\t");
}
System.out.println();
int newSort[]=new int[A.length];
for(int i=0;i<newSort.length;i++){
newSort[i]=i;
}
//每次假设都是最小的
for(int i=0;i<A.length-1;i++){
int min=A[i];
int index=i;
for(int j=i;j<A.length;j++){
if(A[j]<min){
index=j;
min=A[j];
}
}
//交换位置
if(index!=i){
int temp=A[i];
A[i]=A[index];
A[index]=temp;
temp=newSort[i];
newSort[i]=newSort[index];
newSort[index]=temp;
}
}
for(int i=0;i<A.length;i++){
System.out.print(A[i]+"--"+B[newSort[i]]+"\t");
}
}
}