冒泡+快速+堆排序

package xie.struct;



import java.util.ArrayList;



public class Sort<T extends Comparable<T>> {

    public static final int QuickSort = 1;

    public static final int SelectMin = 4;

    public static final int MaoPao = 3;

    public static final int HeapSort = 2;

    

    

    private ArrayList<T> data;//数据存储



    public Sort() {

    }



    public void runSort(int mode) {

        switch (mode) {

        case 1:

            System.out.println("快速排序输出：");

            this.QuickSort(data, 0, data.size() - 1);

            break;

        case 2:

            System.out.println("堆排序输出：");

            this.heapSort();

            break;

        case 3:

            System.out.println("冒泡排序输出：");

            this.MaoPao();

            break;

        case 4:

            break;

        default:

            break;

        }

    }



    public void setData(ArrayList<T> a) {

        this.data = a;

    }



    public void addData(T data) {

        this.data.add(data);

    }



    public String toString() {

        for (int i = 0; i < data.size(); i++)

            System.out.print(data.get(i) + "/");

        return null;



    }

    

    public void MaoPao()

    {

        int i,j; 

        int n=this.data.size();

        for(i=0;i<n;i++)  

            for(j=1;j<n-i;j++){

                if(this.data.get(j-1).compareTo(this.data.get(j))>0)

                {

                T swap=this.data.get(j);

                this.data.set(j,this.data.get(j-1));

                this.data.set(j-1,swap);

                }

            }

    }

    

    



    /*

     * 快速排序代码

     */

    private void QuickSort(ArrayList<T> a, int left, int right) {

        if (left < right) {

            int low = left;

            int high = right;

            T key = a.get(low);

            while (low < high) {

                while (low < high && a.get(high).compareTo(key) >= 0)

                    high--;

                a.set(low, a.get(high));

                while (low < high && a.get(low).compareTo(key) < 0)

                    low++;

                a.set(high, a.get(low));

            }

            a.set(low, key);

            QuickSort(a, left, low - 1);

            QuickSort(a, low + 1, right);

        }

    }



    /*

     * 

     * 堆排序函数代码

     */



    private void buildHeap() {

        int len = this.data.size();

        int i;

        for (i = len / 2 - 1; i >= 0; i--)

            this.adjustHeap(i);



    }



    private void adjustHeap(int index) {

        int len = this.data.size();

        int left = index * 2 + 1;

        int right = index * 2 + 2;

        int smaller = left;

        T swap;

        if (left > len - 1)

            return;

        if (right < len

                && this.data.get(left).compareTo(this.data.get(right)) > 0) {

            smaller = right;

        }

        if (smaller < len

                && this.data.get(index).compareTo(this.data.get(smaller)) > 0) {

            swap = this.data.get(smaller);

            this.data.set(smaller, this.data.get(index));

            this.data.set(index, swap);

            this.adjustHeap(smaller);

        }

    }



    private void heapSort() {

        this.buildHeap();

        int len = this.data.size();

        while (len > 0) {

            System.out.print(this.data.get(0)+"/");

            this.data.set(0, this.data.get(len - 1));

            this.data.remove(len - 1);

            len--;

            this.adjustHeap(0);

        }

    }



    /*

     * 

     * 测试代码

     */



    public static void main(String args[]) {

        ArrayList<String> array = new ArrayList<String>();

        array.add("A");

        array.add("D");

        array.add("G");

        array.add("H");

        array.add("S");

        array.add("J");

        array.add("B");

        Sort<String> sort = new Sort<String>();

        sort.setData(array);

        sort.runSort(Sort.QuickSort);

        sort.toString();

        

        sort.setData(array);

        sort.runSort(Sort.MaoPao);

        sort.toString();

        

        sort.setData(array);

        sort.runSort(Sort.HeapSort);

    }

}

 

快速排序输出：
A/B/D/G/H/J/S/

冒泡排序输出：
A/B/D/G/H/J/S/

堆排序输出：
A/B/D/G/H/J/S/