算法准备一

  好久没有写博文了，但是每天都关注着博文，今天想想是8月1日，来重新启动自己的博文，过完这个暑假就要开始找工作了，因此从算法开始吧：

　　　今天讨论的是JAVA系统内部的排序和冒泡排序，以及快速排序，因为冒泡排序和快速排序都是属于交换排序的所以一起研究一下：

1.首先看的是系统内部提供的排序：java.util.Arrays.sort()排序：

其里面使用了两种排序方法，快速排序和优化的合并排序。【以下引用他人的话：】

快速排序主要是对哪些基本类型数据（int,short,long等）排序， 而合并排序用于对对象类型进行排序。
使用不同类型的排序算法主要是由于快速排序是不稳定的，而合并排序是稳定的。这里的稳定是指比较相等的数据在排序之后仍然按照排序之前的前后顺序排列。对于基本数据类型，稳定性没有意义，而对于对象类型，稳定性是比较重要的，因为对象相等的判断可能只是判断关键属性，最好保持相等对象的非关键属性的顺序与排序前一直；另外一个原因是由于合并排序相对而言比较次数比快速排序少，移动（对象引用的移动）次数比快速排序多，而对于对象来说，比较一般比移动耗时。
补充一点合并排序的时间复杂度是n*logn, 快速排序的平均时间复杂度也是n*logn，但是合并排序的需要额外的n个引用的空间。

 

2.冒泡排序：冒泡排序是最简单的一种排序，思路很简单：这里就不啰嗦了。

3.快速排序：是利用的左右left,right来不断分割来实现的，具体见代码如下：

   注：因为数据量小，所以基本上耗时看不出来，数据量大的时候是可以看出来的。

  

package cn.mdj.test3;

import java.util.Arrays;
import java.util.Random;

public class BubbleSort {

    /**
     * 实例1：
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        
        for(int i = 1;i < 5; i++){
            int[] arr = new int[10];
            int min = 100;
            int max = 500;
            //产生100-500内的随机数
            Random random = new Random(); 
            for(int j=0;j<10;j++){
                arr[j] = random.nextInt(max)%(max-min+1) + min;    
            }
            System.out.println("");
            System.out.println("\n第"+i+"次：");
            long start = System.currentTimeMillis();
            Arrays.sort(arr);
            long end = System.currentTimeMillis();
            System.out.println("内部排序耗时:"+ (end-start));
            System.out.println("前十个元素为：");
            for(int z=0;z<arr.length;z++){
                System.out.print(arr[z]+"、");
            }
            /*
            start = System.currentTimeMillis();
            Bubblesort(arr);
            end = System.currentTimeMillis();
            
            System.out.println("");
            System.out.println("冒泡排序耗时:"+ (end-start));
            System.out.println("前十个元素为：");
            for(int z=0;z<arr.length;z++){
                System.out.print(arr[z]+"、");
            }
            */
            start = System.currentTimeMillis();
            QuickSort(arr,0,arr.length-1);
            end = System.currentTimeMillis();
            System.out.println("");
            System.out.println("快速排序耗时:"+ (end-start));
            System.out.println("前十个元素为：");
            for(int z=0;z<arr.length;z++){
                System.out.print(arr[z]+"、");
            }
        }
    }
    
    /**
     * 冒泡排序：
     * @param arr
     */
    public static void Bubblesort(int[] arr){
        int temp;
        for(int i=0;i<arr.length - 1;i++){
            for(int j=arr.length-1;j > i ; j--){
                if(arr[j-1] > arr[j]){
                    temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
    
    /**
     * 快速排序：
     * @param arr
     * @param start
     * @param end
     */
    public static void QuickSort(int[] arr,int start,int end){
        int left = start;
        int right = end;
        int baseNum = arr[start];
        while(left<right){
            while(left<right && arr[right] >= baseNum){
                right--;
            }
            if(left<right){
                arr[left] = arr[right];
                left++;
            }
            while(left<right && arr[left] <= baseNum){
                left++;
            }
            if(left<right){
                arr[right] = arr[left];
                right--;
            }
        }
        
        arr[left] = baseNum;
        
        if(start < left){
            QuickSort(arr,start,left-1);
        }
        if(right < end){
            QuickSort(arr,right+1,end);
        }
    }
}

　　因为今天很忙，还有其它事情，暂时就先简单写一下吧，具体的算法思想其实任何一本数据结构里面应该都有的。