数据结构(Java)——查找和排序（2）

简单就是平凡，平凡即是伟大

1. 排序辅助类

Contact.java

package ds.java.ch09;
/** 
 * @author LbZhang
 * @version 创建时间：2015年11月19日 下午1:27:57 
 * @param <T>
 * @description 实现了Comparable的Contact类
 */
public class Contact implements Comparable<Contact> {

    private String firstName;
    private String lastName;
    private String phone;

    public Contact(){

    }
    public Contact(String firstName, String lastName, String phone) {
        super();
        this.firstName = firstName;
        this.lastName = lastName;
        this.phone = phone;
    }


    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.firstName+","+this.lastName+":"+this.phone;
    }

    @Override
    public int compareTo(Contact o) {

        if(firstName.equals(o.firstName)){
            return lastName.compareTo(o.lastName);
        }else{
            return firstName.compareTo(o.firstName);
        }
    }


    public String getFirstName() {
        return firstName;
    }


    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }


    public String getLastName() {
        return lastName;
    }


    public void setLastName(String lastName) {
        this.lastName = lastName;
    }


    public String getPhone() {
        return phone;
    }


    public void setPhone(String phone) {
        this.phone = phone;
    }
}

SortPhoneList.java

package ds.java.ch09;
/** 
 * @author LbZhang
 * @version 创建时间：2015年11月19日 下午1:37:05 
 * @description 测试主类
 */
public class SortPhoneList {
    public static void main(String[] args) {
        //测试数据添加
        Contact[] friends = new Contact[7];

        friends[0] = new Contact("John", "Smith", "610-555-7384");
        friends[1] = new Contact("Sarah", "Barnes", "215-555-3827");
        friends[2] = new Contact("Mark", "Riley", "733-555-2969");
        friends[3] = new Contact("Laura", "Getz", "663-555-3984");
        friends[4] = new Contact("Larry", "Smith", "464-555-3489");
        friends[5] = new Contact("Frank", "Phelps", "322-555-2284");
        friends[6] = new Contact("Marsha", "Grant", "243-555-2837");

        //SortAlgorithm.insertionSort(friends);
        //SortAlgorithm.selectionSort(friends);
        SortAlgorithm.bubbleSort(friends);
        for (Contact friend : friends)
            System.out.println(friend);
    }

}

---

2. 直接选择排序

设数组为a[0…n-1]。
1. 初始时，数组全为无序区为a[0..n-1]。令i=0
2. 在无序区a[i…n-1]中选取一个最小的元素，将其与a[i]交换。交换之后a[0…i]就形成了一个有序区。
3. i++并重复第二步直到i==n-1。排序完成。

/**
     * 选择排序： 选择排序算法通过反复地将某一特定值放到它在列表中的最终已排序位置，从而完成某一列表值的排序。 选择排序的策略：
     * 【1】扫描整个列表找到最小值，将这个值与第一个元素交换
     * 【2】扫描除了有序列表之外的部分无序列表找到最小值，然后将它与无序列表第1个位置上的元素交换 
     * 【3】不断重复【2】一直到无序列表只剩一个元素
     * 
     * @param data
     * <T extends Comparable<? super T>> 用于约束T
     * 
     */
    public static <T extends Comparable<? super T>> void selectionSort(T[] data) {
        int min;
        T temp;
        for (int i = 0; i < data.length - 1; i++) {
            min = i;
            // /找出最小的下标
            for (int j = i + 1; j < data.length; j++) {
                if (data[min].compareTo(data[j]) > 0) {
                    min = j;
                }
            }
            // 交换位置
            swap(data, min, i);
        }

    }

---

3. 直接插入排序

设数组为a[0…n-1]。首先构造有序区域
1. 初始时，a[0]自成1个有序区，无序区为a[1..n-1]。令i=1
2. 将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。
3. i++并重复第二步直到i==n-1。排序完成。

/**
     * 插入排序: 通过反复的将某一特定值插入到该列表的某个已经排序的子集中完成对列表值的排序。 插入排序的策略：
     * 【1】对列表中的开始的两个值依据其相对大小对其进行排序，如果有必要则将它们互换。 
     * 【2】将列表的第三个值插入到已经有序的列表中的恰当位置
     * 【3】然后不断的将无序列表的元素一次取出插入到有序列表的合适位置，继续这一个过程最后实现全部有序。
     * 
     * @param data
     */
    public static <T extends Comparable<? super T>> void insertionSort(T[] data) {

        // 从第一个开始比较
        for (int i = 1; i < data.length; i++) {
            T key = data[i];
            int pos = i;//
            // /有序列表 当前这个元素是否需要前移 如果当前的待插入元素比有序列表pos位置的小
            while (pos > 0 && data[pos - 1].compareTo(key) > 0) {
                data[pos] = data[pos - 1];
                pos--;
            }
            data[pos] = key;
        }

    }

---

4. 冒泡排序

冒泡排序是非常容易理解和实现，以从小到大排序举例： 设数组长度为N。
1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。
2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。
3．N=N-1，如果N不为0就重复前面二步，否则排序完成。

> 引用块内容

Java
/**
     * 冒泡排序：通过重复的比较相邻元素且在必要时将它们互换，从而完成对某个列表的排序.
     * 【1】扫描该列表且比较邻接元素如果他们不是相对顺序排序排列将其互换。这里就是就是将最大值冒泡到列表最后的位置.
     * @param data
     */
    public static <T extends Comparable<? super T>> void bubbleSort(T[] data){

/**
 *      for(int i=1;i<data.length;i++){
            ///已经有序的部分
            for(int j =0;j<data.length-i;j++){              
                if(data[j].compareTo(data[j+1])>0){
                    swap(data,j,j+1);
                }

            }

        }
 */
        int pos;
        int scan;

        for(pos = data.length-1;pos>=0;pos--){
            for(scan=0;scan<pos;scan++){
                if(data[scan].compareTo(data[scan+1])>0){
                    swap(data,scan,scan+1);
                }
            }
        }

    }

---

泛型理解
PECS原则：ProducerExtends，ConsumerSuper。
集合用泛型操作时，装入集合用super，从集合取出用extends。又称Get and Set 原则。
辅助方法

/**
     * 交换位置
     * 
     * @param data
     * @param index1
     * @param index2
     */
    private static <T extends Comparable<? super T>> void swap(T[] data, int i,
            int j) {
        T temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }