一道java笔试

Question

用程序产生10个随机数,序号从1到10然后对这10个数进行从小到大排序,然后输出这10个数和相对应的序号

Answer 1

可以直接用TreeSet搞定！
做法很多，重要看你用那种！

Answer 2

import java.util.Arrays;
import java.util.Random;public class SortArrays { /**
 * @param args
 */
public static int[] array = new int[10];
public static void output(){
if(array != null){
for(int i = 0 ; i < array.length ; i++){
System.out.println((i+1) +" : " + array[i] );
}
}
}
public static void setRandomNum(){
Random rd = new Random();
for(int i = 0 ; i < array.length ;i++){
array[i] = rd.nextInt(10);
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
SortArrays  sortArray = new SortArrays(); 
sortArray.setRandomNum();
Arrays.sort(array);
sortArray.output(); 
}}

Answer 3

不对吧，output()中打印的时候，序号不是排序好后的序号，而是排序前这个数是几号就是几号，比如原来的数是（[]中是序号）：[1]2，[2]1，[3]5，[4]4排序后因该是：[2]1，[1]2，[4]4，[3]5是这样的一个结果啊

Answer 4

import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;public class Other {
public static void main(String[] args) {
setRandomNum();
Arrays.sort(array,new Comparator(){
public int compare(Object arg0, Object arg1) {
Hashtable ht0 = (Hashtable)arg0;
Hashtable ht1 = (Hashtable)arg1;
return Integer.parseInt(ht0.get("num").toString()) - Integer.parseInt(ht1.get("num").toString());
}
});
output();
} public static Hashtable[] array = new Hashtable[10]; public static void output() {
if (array != null) {
for (int i = 0; i < array.length; i++) {
Hashtable ht = (Hashtable)array[i];
System.out.println(ht.get("pos") + " : " + ht.get("num"));
}
}
} public static void setRandomNum() {
Random rd = new Random();
for (int i = 0; i < array.length; i++) {
Hashtable ht = new Hashtable();
ht.put("num", "" + rd.nextInt(10));// 数字
ht.put("pos", "" + i);// 下标
array[i] = ht;
}
}
}

Answer 5

public class Test{public static int randomInt(int min,int max)   {   
  return (int)(Math.random()*(max-min+1))+min;
}
public static List getDifNumList(int max){
List list = new ArrayList();
int size = 0;
while(size<max){
boolean flag = false;
int index = StringUtil.randomInt(1,max);
if(list != null && list.size() != 0){
for(int i=0;i<list.size();i++){
Integer it = (Integer)list.get(i);
if(Integer.valueOf(it) == index){
flag = true;
break;
}
}
}
if(!flag){
list.add(new Integer(index));
size++;
}else{
flag = false;
}
}
return list;
}public static void main(String[] args) {
List list = getDifNumList(10);
List newList = new ArrayList();
for(int i=0;i<list.size();i++){
int num = (Integer)list.get(i);
System.out.println(list.indexOf(num)+":"+num);
NumberAndIndex number = new NumberAndIndex(list.indexOf(num),num);
newList.add(number);
}
System.out.println("***********");
Collections.sort(newList, new Comparator<NumberAndIndex>() {
public int compare(NumberAndIndex info1,NumberAndIndex info2) {
int num1 = info1.getNum();
int num2 = info2.getNum();
if (num1 > num2) {
return 1;
} else if (num1 == num2) {
return 0;
} else {
return -1;
}
}
});
for(int i=0;i<newList.size();i++){
NumberAndIndex num = (NumberAndIndex)newList.get(i);
System.out.println(num.getIndex()+":"+num.getNum());
}
}static class NumberAndIndex implements Serializable{
private int index;
private int num;

public NumberAndIndex(){

}
public NumberAndIndex(int index,int num){
this.index = index;
this.num = num;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
}这样就OK了，已经测试过了！

Answer 6

import java.util.*;
public class SortTest {
public static void main(String[] args) {
int[] number=new int[11];
int[] randNumber=new int[11];
Random rand=new Random(47);
//生成随机数，存储到randNumber
for(int i=1;i<number.length;i++){
number[i]=i;
randNumber[i]=rand.nextInt(100);
System.out.print(number[i]+": "+randNumber[i]+"\t");

}

//冒泡排序
for(int i=1;i<number.length-1;i++){
for(int j=1;j<number.length-i;j++)
if(randNumber[j]>randNumber[j+1]){
int temp=number[j];
number[j]=number[j+1];
number[j+1]=temp;

temp=randNumber[j];
randNumber[j]=randNumber[j+1];
randNumber[j+1]=temp;          
}
}

//输出结果
System.out.println();
for(int i=1;i<number.length;i++){
System.out.print(number[i]+": "+randNumber[i]+"\t");
}
}}

Answer 7

有什么要求吗？如果没有特殊要求的话，用数组时最简单不过了！ 代码如下：import java.util.*;
public class code {
   
   public static void main(String[] args)
   {
        int[] a=new int[10];
        for(int i=0;i<10;i++){
        a[i]=(int) (Math.random() * 100);//数组内容为99以内的随机数      }
        
          Arrays.sort(a);
         for(int i=0;i<10;i++){
        System.out.println("第"+(i+1)+"个数为："+a[i]+"   "+"序号为："+(i+1));      }
          
   }}
执行结果中一组：
C:\>javac code.javaC:\>java code
第1个数为：11   序号为：1
第2个数为：19   序号为：2
第3个数为：35   序号为：3
第4个数为：54   序号为：4
第5个数为：55   序号为：5
第6个数为：60   序号为：6
第7个数为：62   序号为：7
第8个数为：68   序号为：8
第9个数为：78   序号为：9
第10个数为：90   序号为：10

Answer 8

楼主一定不是那个意思我想应该是这样的：
value key
22     1
14     2
16     3
92     4
25     5
58     6
8      7
9      8
3      9
===========
排序后
3      9
8      7
9      8
14     2
16     3
22     1
25     5
58     6
92     4

Answer 9

package newTest;import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;public class TestSort { int[] iSort = new int[10];
Map map = new TreeMap();
ArrayList list = new ArrayList(); void setSort(int[] a) {
for (int i = 1; i < a.length; i++) {
a[i] = (int) (Math.random() * 100);
map.put(i, a[i]);
list.add(map.get(i));
System.out.println(map.get(i) + "  " + i);
}
} void isSort(Map m) {

Collection vs = map.values();
Collections.sort(list);
Iterator it = list.iterator(); while (it.hasNext()) {
System.out.println(it.next());                        //这里需要取道map的key值，并打印
                        //System.out.println(能取得对应value的key值);
                        //遇到了问题，各位有什么好方法没，给点思路 }
} public static void main(String[] args) {
TestSort ts = new TestSort();
ts.setSort(ts.iSort);
System.out.println("===========");
ts.isSort(ts.map); }
}

Answer 10

package testio;import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Map.Entry;public class TestSort { int[] iSort = new int[10];
Map map = new TreeMap();
ArrayList list = new ArrayList(); void setSort(int[] a) {
for (int i = 1; i < a.length; i++) {
a[i] = (int) (Math.random() * 100);
map.put(a[i], i);
list.add(map.get(i));
System.out.println(map.get(a[i]) + "  " + a[i]);
}
} void isSort(Map m) { Set set = m.entrySet(); Iterator it = set.iterator(); while (it.hasNext()) {
Map.Entry entry = (Entry) it.next();
System.out.println(entry.getValue() + "  " + entry.getKey()); }
} public static void main(String[] args) {
TestSort ts = new TestSort();
ts.setSort(ts.iSort);
System.out.println("===========");
ts.isSort(ts.map); }
}
好用了 ，不过投机取巧了 ，呵呵 ，期待更好的方案

Answer 11

一、数组法（如34楼）
使用两个数组，分别存储随机数和序号，按随机数排序同时移动序号数组。但是效率不高
二、Map法（如33楼）
key为随机数，value为序号。但是随机数相同则会产生麻烦
三、字符串法（自己想的名字，呵呵）
思路：将随机数和序号组成字符串（如随机数78序号1->78:1），将所有随机数放入List中，然后重写Collection.sort()方法，截取字符串的第0位到":"，按照数字排序即可。代码如下：
public static void main(String[] args) {
List <String> listSeqAndNum = new ArrayList <String>();
for(int i=0;i<10;i++) {
listSeqAndNum.add((int)(Math.random()*100)+":"+(i+1));
}
for (Iterator<String> iterator = listSeqAndNum.iterator(); iterator.hasNext();) {
System.out.println(iterator.next());
}
Collections.sort(listSeqAndNum , new Comparator<String>(){
public int compare(String a, String b) {
int orderA = Integer.parseInt(a.substring(0, a.indexOf(":")));
int orderB = Integer.parseInt( b.substring(0, b.indexOf(":")));
return orderA - orderB;
}
});
System.out.println("=============================");
for (Iterator<String> iterator = listSeqAndNum.iterator(); iterator.hasNext();) {
System.out.println(iterator.next());
}

}
欢迎各位点评，希望此程序可以抛砖引玉，让更多大侠提出好的解决方案。
关于此程序的引申和思考会在我的CSDN博客中详细写明。

Answer 12

Arrays.sort(array); 
java实现的快速排序

Answer 13

package com.trisun.mail;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class TestSort { public static void main(String[] args) {

List<SortRemand> listTemp = new ArrayList<SortRemand>();
for(int i=1;i<11;i++){
SortRemand sr = new SortRemand();
sr.setNumRemand((int)(Math.random()*100));
sr.setNumSeq(i);
listTemp.add(sr);
}

SortComparator sc = new SortComparator();
Collections.sort(listTemp, sc);

for(SortRemand sortRemand:listTemp){
System.out.println(sortRemand.getNumRemand()+"---对应的编号--"+sortRemand.getNumSeq());
}
}}package com.trisun.mail;import java.util.Comparator;public class SortComparator implements Comparator { @Override
public int compare(Object o1, Object o2) {
SortRemand sr1 = (SortRemand)o1;
SortRemand sr2 = (SortRemand)o2;
int falg = sr1.getNumRemand().compareTo(sr2.getNumRemand());
return falg;
}}package com.trisun.mail;public class SortRemand {

private Integer numSeq;

private Integer numRemand; public Integer getNumSeq() {
return numSeq;
} public void setNumSeq(Integer numSeq) {
this.numSeq = numSeq;
} public Integer getNumRemand() {
return numRemand;
} public void setNumRemand(Integer numRemand) {
this.numRemand = numRemand;
} @Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((numRemand == null) ? 0 : numRemand.hashCode());
result = prime * result + ((numSeq == null) ? 0 : numSeq.hashCode());
return result;
} @Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final SortRemand other = (SortRemand) obj;
if (numRemand == null) {
if (other.numRemand != null)
return false;
} else if (!numRemand.equals(other.numRemand))
return false;
if (numSeq == null) {
if (other.numSeq != null)
return false;
} else if (!numSeq.equals(other.numSeq))
return false;
return true;
} @Override
public String toString() {
// TODO Auto-generated method stub
return super.toString();
}
}1---对应的编号--5
15---对应的编号--2
38---对应的编号--7
45---对应的编号--6
54---对应的编号--10
62---对应的编号--8
66---对应的编号--9
70---对应的编号--3
88---对应的编号--4
95---对应的编号--1

Answer 14

封装类+客户化排序  好主意  比我的Map.Entry有说服力 学习了

Answer 15

同意，
    @Override
    public int hashCode() 
    @Override
    public boolean equals(Object obj) 
    @Override
    public String toString()
重写这3个方法有特殊意义吗？ 还是顺手写上的。

Answer 16

用map做应该是比较简单的,不过要考虑产生的重复数字

Answer 17

20楼看起来是最简单了，但存在这么一个问题，
     Arrays.sort(a);
就改变了原来数组的下标了，
然而你输出的结果时候，总会看到一个升序的效果。。

Answer 18

import java.lang.Math.*;
import java.util.*;
public class SortRandom
{
public static void main(String[] args)
{
  int[] a=new int[10];
int i;
for(i=0;i<=9;i++)
{
a[i]=(int)(Math.random()*100);
System.out.println(a[i]);
}
  print(a);
  Arrays.sort(a);         //系统自带的排序
//SelectSort(a);       //调用自定义冒泡排序
    print(a);  }
private static void SelectSort(int[] a)  //冒泡排序
{
for(int i=0; i<a.length; i++) 
{
for(int j=i+1; j<a.length; j++)
 {
if(a[j] < a[i]) 
{
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}

  }  private static void print(int[] a) 
{
for(int i=0; i<a.length; i++) 
{
System.out.print(a[i] + " ");
}
System.out.println();
}
 
}
可惜了，没办法输出随机数的原始的下标！！！

Answer 19

哈，都用java了，应该是把值和序号放到对象里，然后用Comparable来排序，这才是java应用嘛。

Answer 20

public class RandomTest { public static void main(String[] args) { int numLength = 10;
int[] nums = getRandomNums(numLength);
String[] temp = new String[numLength];
for (int i = 0; i < nums.length; i++)
temp[i] = "" + nums[i] + "," + i;
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums.length; j++) {
if (nums[i] == Integer.parseInt(temp[j].split(",")[0].trim())) {
System.out.print("id:" + temp[j].split(",")[1] + " and num:" + nums[i]);
System.out.println();
temp[j] = "-1";
break;
}
}
}
} public static int[] getRandomNums(int i) { int[] nums = new int[i];
Random random = new Random();
for (int j = 0; j < i; j++)
nums[j] = random.nextInt(10);
return nums;
}
}id:7 and num:0
id:3 and num:1
id:0 and num:4
id:1 and num:4
id:6 and num:5
id:8 and num:5
id:4 and num:6
id:2 and num:8
id:5 and num:8
id:9 and num:9

Answer 21

public class TestSortTen {
    public static void main(String args[]){
     Random r=new Random();
     TreeMap<Integer,Integer> tm=new TreeMap<Integer,Integer>();
     for(int i=0;i<10;i++){
     tm.put(r.nextInt(20),i+1);
     }
     System.out.println(tm.toString());
     }
}
{1=10, 3=5, 6=1, 10=4, 11=3, 15=8, 16=7, 18=2, 19=6}
=号左边是随机数,右边是序号。