java冒泡排序与快速排序

1.冒泡排序

public class BubbleSort {
    public int sort1(int[] array){
        //计数器,计算比较了多少次
        int count = 0;
        int k,flag = array.length,temp;
        //当运行完一次之后,如果flag没变,则排序完成
        while(flag > 0){
            //k为右边界
            k = flag;
            //flag 为左边界
            flag = 0;
            for(int i = 1; i < k; i++){
                count++;
                if(array[i] < array[i - 1]){
                    temp = array[i];
                    array[i] = array[i - 1];
                    array[i - 1] = temp;
                    flag = i;
                }
            }
        }
        return count;
    }
    public int sort2(int[] array){
        int count = 0,temp;
        for(int i = 0; i < array.length; i ++){
            for(int j = i + 1; j < array.length; j ++){
                count ++;
                if(array[i] > array[j]){
                    temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        return count;
    }

    public static void main(String[] args) {
        BubbleSort bs = new BubbleSort();
        int[] array = new int[]{1,4,2,3,5};
        System.out.println(bs.sort1(array));
        printArray(array);
        array = new int[]{1,4,2,3,5};
        System.out.println(bs.sort2(array));
        printArray(array);
    }
    public static void  printArray(int[] array){
        for(int item : array){
            System.out.print(item + " ");
        }
        System.out.println();
    }
}
2.快速排序

思路:基于分治的思想,是冒泡排序的改进型。
1.分别从数组的两端扫描数组,设两个指示标志(lo指向起始位置,hi指向末尾),首先从后半部分开始,如果发现有元素比该基准点的值小,就交换lo和hi位置的值,
2.然后从前半部分开始扫秒,发现有元素大于基准点的值,就交换lo和hi位置的值,
3.如此往复循环,直到lo>=hi,然后把基准点的值放到hi这个位置。一次排序就完成了。
4.以后采用递归的方式分别对前半部分和后半部分排序,当前半部分和后半部分均有序时该数组就自然有序了。


public class QuicklySort {
    private int count = 0;
    public int position(int[] array, int low, int hight){
        while(low < hight){
            while(array[hight] >= array[low] && low < hight){
                count ++;
                hight --;
            }
            int key = array[low];
            array[low] = array[hight];
            array[hight] = key;

            while (array[low] <= array[hight] && low < hight){
                count ++;
                low ++;
            }
            key = array[hight];
            array[hight] = array[low];
            array[low] = key;
        }
        return low;
    }
    public void sort(int[] array, int low, int high){
        if(low >= high){
            return;
        }
        int index = position(array,low,high);
        sort(array,low,index - 1);
        sort(array,index + 1, high);
    }

    public static void main(String[] args) {
        int[] array = new int[]{1,5,4,6,2,3,8,7,8,9};
        QuicklySort qs = new QuicklySort();
        qs.sort(array,0,array.length - 1);
        System.out.println(qs.count);
        BubbleSort.printArray(array);

        BubbleSort bs = new BubbleSort();
        array = new int[]{1,5,4,6,2,3,8,7,8,9};
        System.out.println(bs.sort2(array));
        BubbleSort.printArray(array);
    }
}
3.问题测试

1. 对于快速排序时,如果index = 0,或者 index = length - 1;会不会报数组越界异常呢?
  经测试不会,
当index = 0,在sort方法的判断low >= high为true,直接返回了
index = length - 1时亦然。
阅读更多
个人分类: java原理 数据结构
上一篇spring mybatis EhCache数据库缓存配置
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭