排序算法,快速排序与冒泡排序

用java实现排序算法.

在算法的实现过程中是用的ArrayList.从该类的实现方面来看,对算法的执行效率也是有影响的.在这里仅仅记录以下自己的学习过程及结果.

1,快速排序

代码的实现如下,该类是一个测试类方法 quickSortMethod()就是快速排序的实现,他的实现使用的是一个递归算法,

ArrayList的实现是一个数组,而且数组的大小是10,如果元素大于10个就会申请新的空间,大小为原来的1.5倍, int newCapacity = oldCapacity + (oldCapacity >> 1);从底层的代码可以看出他为了提高效率使用移位来提高效率.

为了进可能的减少arrayList的数据机构的影响,这里使用foreach遍历数组.由于这里测试的数据比较大,而ArrayLIst的初始大小为10,而且每次增长为原来的二倍,让后把旧的数据复制到新的数组里面.

总之这样来写一个算法多少是有些影响的.

package com.test.sort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class QuickSort {

    public List quickSortMethod(List<Integer> parentList){//quickSort
        List<Integer> leftList = new ArrayList<Integer>();
        List<Integer> rightList = new ArrayList<Integer>();
        List<Integer> resultList ;
        if (parentList.size() <= 1) {
            return parentList;
        }
        Integer qInteger = parentList.get(0);
        Boolean first = true;
        for (Integer temp : parentList) {
            if(first) {
                first = !first;
                continue;
            }
            if (temp > qInteger) {
                rightList.add(temp);
            }else {
                leftList.add(temp);
            }
            
        }
        resultList = this.quickSortMethod(leftList);
        resultList.add(qInteger);
        resultList.addAll(this.quickSortMethod(rightList));
        return resultList;   
    }
    
    public static void main(String[] args) {
        List<Integer> results;
        QuickSort qSort = new QuickSort();
        List<Integer> list = new ArrayList();
        int elemCount = 100000;
        for(int i = 0; i<elemCount; i++) {
            list.add((int) (Math.random()*elemCount));
        }
        Long startTime = System.currentTimeMillis();
        results = qSort.quickSortMethod(list);
        Long endTime = System.currentTimeMillis();
        Long totalTime =  endTime - startTime;
        System.out.println(startTime);
        System.out.println(endTime);
        System.out.println("quick Sort Time = " + totalTime );
        //qSort.log(results);
        
        //bubble Sort
        startTime = System.currentTimeMillis();
        results = qSort.bubbleSort(list);
        endTime = System.currentTimeMillis();
        totalTime =  endTime - startTime;
        System.out.println(startTime);
        System.out.println(endTime);
        System.out.println("dubble sort Time = " + totalTime );
        //qSort.log(results);        
    }
    
    
    public List bubbleSort(List<Integer> parentList) {
        if (parentList == null || parentList.size() == 0) {
            System.err.println("List isn't elem");
            return null;
        }
        
        for (int i = 0,listSize = parentList.size(); i < listSize; i++) {
            for(int j = 0; j < listSize - i - 1; j++){
                if (parentList.get(j) > parentList.get(j+1)) {
                    int temp = parentList.get(j);
                    parentList.set(j, parentList.get(j+1));
                    parentList.set(j+1, temp);
                }
            }
        }
        return parentList;
    }
    
    public void log(List<Integer> parentList){
        for (Integer  elem: parentList) {
            System.out.println(elem);
        }
        System.out.println("==================================");
    }
}

2 冒泡排序.

冒泡的排序算法 bubbleSort(),这个算法的实现是通过两层循环来实现的.这个算法ArrayList通过api get来得到一个元素,foreach代码会被编译为 Iterator 的形式来迭代.当list是数组的时候差别不大.当List的结构是链表的时候就差别打了.

3 运行结果.

以上的这些仅仅是学习中的笔记