Java集合三种排序

Question

package book;/****
 * 实体类
 * @author founder
 */
public class Book {
private String bookSN;  //图书编号
private int sellCount;  //销量
public String getBookSN() {
return bookSN;
}
public void setBookSN(String bookSN) {
this.bookSN = bookSN;
}
public int getSellCount() {
return sellCount;
}
public void setSellCount(int sellCount) {
this.sellCount = sellCount;
}}package book;import java.util.Comparator;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
/**
 * 针对集合的帮助类
 * @author founder
 */
public class ComparatorBook implements Comparator { /* (non-Javadoc)
 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
 */
public int compare(Object arg0, Object arg1) {
Book book0=(Book)arg0;
Book book1=(Book)arg1;
if(book0.getSellCount()<book1.getSellCount()){
return 0;
}else{
return 1;
}
}
}package book;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;/**
 * 操作类
 * @author founder
 */
public class BookDAO { /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
Book book1 = new Book();
book1.setSellCount(101);
Book book2 = new Book();
book2.setSellCount(102);
Book book3 = new Book();
book3.setSellCount(103);
Book book4 = new Book();
book4.setSellCount(100);
List bookList = new ArrayList();
bookList.add(book1);
bookList.add(book2);
bookList.add(book3);
bookList.add(book4);
BookDAO bookDAO = new BookDAO();
bookDAO.ListSortSellCount(bookList);
}***************************************************************************
 * 对销量升序
 * 
 * @return
 */
public List ListSortSellCount(List bookList) {
List<Book> linkedList = new LinkedList<Book>();
int temp = 0;
//  for (Object object : bookList) {
// Book book = (Book) object;
// int sellCount = book.getSellCount();
// if (sellCount > temp) {
// temp = sellCount;
// linkedList.add(book);
// }
// }
System.out.println("第一种集合排序方案:");
// 调用数组的排序和集合的排序方法
int[] score = new int[bookList.size()];
for (int i = 0; i < bookList.size(); i++) {
Book book = (Book) bookList.get(i);
int sellCount = book.getSellCount();
score[i] = sellCount;
}
Arrays.sort(score); // 排序
for (int index = 0; index < score.length; index++) {
Book book = new Book();
book.setSellCount(score[index]);
linkedList.add(book);
System.out.println(score[index]); //输出结果
}
System.out.println("第二种集合排序方案:");
// 冒泡排序算法: 适合于数组
int[] bookArray= new int[bookList.size()];
for (int i = 0; i < bookList.size(); i++) {
Book book = (Book) bookList.get(i);
int sellCount = book.getSellCount();
bookArray[i] = sellCount;
}
/****
 * 冒泡排序核心代码
 */
for (int i = 0; i < bookArray.length - 1; i++) {
for (int j = 0; j < bookArray.length - i - 1; j++) {
if (bookArray[j] > bookArray[j + 1]) {
temp = bookArray[j];
bookArray[j] = bookArray[j + 1];
bookArray[j + 1] = temp;
}
}
}
for (int index = 0; index < bookArray.length; index++) {
Book book = new Book();
book.setSellCount(bookArray[index]);
linkedList.add(book);
System.out.println(bookArray[index]); // 输出结果
}

System.out.println("第三种集合排序方案:");
//第三种方式： 使用Comparator接口的帮助类ComparatorBook来排序
ComparatorBook comparator=new ComparatorBook();
Collections.sort(bookList, comparator);
for (int i = 0; i < bookList.size(); i++) {
Book book=(Book)bookList.get(i);
System.out.println(book.getSellCount());
}

// for (Book book : linkedList) {
//   System.out.println(book.getSellCount());
// }
return bookList;
}
}各抒己见，中软国际2013最后一道编程题的，第2道小题，等交上答卷，我最后这道编程题的第2道小题果断的挂了，真是不甘心啊。javalist

Answer 1

我想，这个题，是要对Book对象进行排序，而不是对sellCount进行排序。
待排对象，应该是Book对象，排序的比较规则是比较Book对象中的sellCount属性。
List里面的Book对象，
可能会出现相同的两个以上的Book对象，
也可能出现bookSN不同而sellCount相同的多个对象。所以，很显然，前两种排序显然是错的，
第一种，提取出所以Book对象的销量属性，对属性排序，之后，创建新Book对象，丢失了图书序号属性。题目要求，应该是对Book对象进行排序，而不是新创建Book对象，即使你新创建Book对象，里面的属性也应该保证和输入的参数里面的对象属性是一致的才可以。
所以，第一种，排序结果，显然不合要求。第二种，思路和第一种的异常相似。第三种，利用JavaSE提供的希尔排序算法进行排序，结果应该是对的。但是，一般是不允许这样投机取巧的，因为，考的就是你对算法的理解。如果这道题不考算法，那就没问题。最后，说说返回值的问题。整个函数，最后的返回值是传入的参数。那么，第43行创建的链表，应该属于辅助对象，前两种排序的结果，就都失效了，也就是说，从43行到94之间的代码，写与不写没有什么太大的意义。

Answer 2

这道题的第一道小题就是去重，我那个答对了。而题目的要求确实是sellCount排序，对Book对象排序这没逻辑可言，拿到现实里说，书怎么排序，按照什么规则排序，这个逻辑上说不过去。你只能按照书的编号，书的销售量，书的价格排序。就想人与人没有可比性，但是人和人可以用年龄比较出谁大谁小一样。

Answer 3

Collections.sort貌似是一个modified mergesortcompare怎么会只有0和1呢？

Answer 4

sellCount是可以比大小的，但是，你怎么做的？
把所有Book的sellCount拿出来，比了一次大小，
然后，找不到每个sellCount与原来Book的关联关系，
又重新创建了新的Book对象，设置了sellCount属性，
关键是，你设置sellCount属性，其他属性你就不管了。
这样做，不符合题意。排序题，一般都是给你一个集合，让你对集合里面的元素进行排序。
你看看你程序的排序结果，排序的结果（新生成的集合）里面，还是原来待排集合中的元素么？
你排着排着，把原来集合的元素扔了，重新创建了个新的对象放进去了。
排着排着，里面的元素就变成别的元素了。
最夸张的是，新换的元素，与原集合中的元素，他们对应元素的属性还不是完全形同的。

Answer 5

Book类没做更改。
package book;
 
import java.util.Comparator;
 
/**
 * 比较器类，比较两个参数的大小。一般用于集合或者Map的排序。
 */
public class ComparatorBook implements Comparator<Book> { public int compare(Book o1, Book o2) {
if(o1==null)return -1;
if(o2==null)return 1;
if(o1==o2)return 0;
if(o1.getSellCount()>o2.getSellCount()){
return 1;
}
if(o2.getSellCount()==o1.getSellCount()){
return 0;
}
return -1;
}
}

Answer 6

package book;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;
 
public class BookDAO {
 
    /**
     * 测试用例
     */
    public static void main(String[] args) {
        Book book1 = new Book();
        book1.setBookSN("SN1");
        book1.setSellCount(101);
        Book book2 = new Book();
        book2.setBookSN("SN2");
        book2.setSellCount(102);
        Book book3 = new Book();
        book3.setBookSN("SN3");
        book3.setSellCount(103);
        Book book4 = new Book();
        book4.setBookSN("SN4");
        book4.setSellCount(100);
        List<Book> bookList = new ArrayList<Book>();
        bookList.add(book1);
        bookList.add(book2);
        bookList.add(book3);
        bookList.add(book4);
        BookDAO bookDAO = new BookDAO();
        List<Book> sorted = bookDAO.ListSortSellCount(bookList);
        for(Book book : sorted){
         System.out.println(book.getBookSN()+"\t"+book.getSellCount());
        }
    }
 
    /***************************************************************************
     * 对销量升序
     */
    public List<Book> ListSortSellCount(List<Book> bookList) {
        ComparatorBook comparator=new ComparatorBook();
        List<Book> result = null;
        result = bubbleSort(bookList);
        result = bubbleSort(bookList,comparator);
        result = selectionSort(bookList,comparator);
        result = jdkSort(bookList,comparator);
        return result;
    }
    
    public List<Book>  bubbleSort(List<Book> bookList){
     System.out.println("冒泡排序算法（不用比较器升序）:");
     Book[] array = bookList.toArray(new Book[bookList.size()]);
     Book temp = null;
     for(int i=0;i<array.length;i++){
     for(int j=array.length-1;j>i;j--){
     if(array[j-1].getSellCount()>array[j].getSellCount()){
     temp = array[j];
     array[j] = array[j-1];
     array[j-1] = temp;
     }
     }
     }
     ListIterator<Book> i = bookList.listIterator();
     for (int j=0; j<array.length; j++) {
         i.next();
         i.set(array[j]);
     }
     return bookList;
    }
    public List<Book>  bubbleSort(List<Book> bookList,ComparatorBook comparator){
     System.out.println("冒泡排序算法:");
     Book[] array = bookList.toArray(new Book[bookList.size()]);
     Book temp = null;
     for(int i=0;i<array.length;i++){
     for(int j=array.length-1;j>i;j--){
     if(comparator.compare(array[j-1], array[j])>0){
     temp = array[j];
     array[j] = array[j-1];
     array[j-1] = temp;
     }
     }
     }
     ListIterator<Book> i = bookList.listIterator();
     for (int j=0; j<array.length; j++) {
         i.next();
         i.set(array[j]);
     }
     return bookList;
    }
    public List<Book>  selectionSort(List<Book> bookList,ComparatorBook comparator){
     System.out.println("选择排序算法:");
     Book[] array = bookList.toArray(new Book[bookList.size()]);
     int index = 0;
     Book temp = null;
     for(int i=0;i<array.length;i++){
     index = i;
     for(int j=i+1;j<array.length;j++){
     if(comparator.compare(array[index], array[j])>0){
     index = j;
     }
     }
     temp = array[index];
array[index] = array[i];
array[i] = temp;
     }
     ListIterator<Book> i = bookList.listIterator();
     for (int j=0; j<array.length; j++) {
         i.next();
         i.set(array[j]);
     }
     return bookList;
    }
    public List<Book> jdkSort(List<Book> bookList,ComparatorBook comparator){
     System.out.println("JDK 排序算法:");
     Collections.sort(bookList, comparator);
     return bookList;
    }
    
}

Answer 7

ListSortSellCount方法里面，
展示了三种最基本的排序算法，一共4种情况。
注释掉其他3种情况，运行程序，可以看到排序结果。

Answer 8

JavaSE提供的是改进后的归并排序。

Answer 9

题目要求：1.去重，我已经做到了，亲们不用考虑。2.对Book.getSellCount排序。
不用我多解释了吧。

Answer 10

我觉得这道题不是考排序的算法，如果考排序的算法直接出一道整数数组的题目就可以了，既然是对对象排序，lz的思路是对的，第一种和第二种算重复了，我觉得是那个comparator里面的写得有错，漏了一个小于0的，另外Book还可以实现Comparable接口，然后调用Collections.sort(List)就可以,当然Comparator比较灵活，Comparable比较呆板