Java排序算法

1、桶排序：思路简单，占用空间大，就是把数字本身作为数组的下表，然后顺序输出即可

2、冒泡排序：运算量大

    /**
     * 冒泡,或者叫下沉
     * @param array
     */
    public  void MaopaoSort(int[] array , int num)/*入参：数组本身和数组大小*/
    {
        for(int i=0; i<num; i++)
        {
            for(int j=0; j<(num-2-i); j++) //排过一轮之后最后最后一个数字变成了最大的
            {
                if(array[j]>array[j+1])
                {
                    array[j]=array[j]+array[j+1]; //可以不用第三个变量进行swap的方法
　　　　　　　　　　　 array[j+1]=a[j]-array[j+1];
　　　　　　　　　　　 array[j]=a[j]-array[j+1];
                }
            }
        }
    } 

3、快速排序  

    /**
     * 快速排序
     * @param args
     */
    public void quickSort(int[] array, int left, int right)
    {
        if(lef t>= right)//无须再比
        {
             return;
        }
        
        int tmp = array[left];//先取出一个临时值作为分界标识
        int i = left;
        int j = right;
        
        while(i<j)
        {
            while(i<j && array[j] >= tmp) //从右侧开始向中间靠近
            {
                j--;
            }
            if(i<j)//找到比分界值小的元素
            {
                a[i] = a[j];//不要担心被覆盖，因为a[i]已经被保存起来了
                i++;
            }
            
            while(i<j && a[i] <= tmp)//从左侧开始向中间靠近
            {
                i++;
            }
            if(i<j)//找到比分界值大的元素
            {
                a[j] = a[i];
                j--;
            }
         }//一轮排序完成，分成两组，左边的组都比tmp值小，右边的组都比tmp大  
         a[i] = tmp;//新的分界值
         quickSort(array,i+1,right);//这个从新排序的分界开始还不是很明白
         quickSort(array,left,j-1);
42         
    }
    /**
     * 快速排序非递归版本,这个版本我理解得不好
     * @param args
     */
    public <T  extends Comparable<T>> void quickSort2(List<T> array,int left,int right)
    {
        Num num = new Num(left,right);
        LinkedList<Num> link = new LinkedList<Num>();
        link.addLast(num);
        
        while(!link.isEmpty())
        {
            Num tmpnum = link.removeFirst();
            int i = tmpnum.l;
            int j = tmpnum.r;
            if(i>=j)
            {
                continue ;
            }
            int l = i;
            int r = j;
            T tmp = array.get(i);
            
            while(i<j)
            {
                while(i<j && array.get(j).compareTo(tmp) >= 0)
                {
                    j--;
                }
                if(i<j)
                {
                    array.set(i, array.get(j));
                    i++;
                }
                
                while(i<j && array.get(i).compareTo(tmp) <= 0)
                {
                    i++;
                }
                if(i<j)
                {
                    array.set(j,array.get(i));
                    j--;
                }
                
            }
            array.set(i, tmp);
            link.addLast(new Num(i+1,r));
            link.addLast(new Num(l,j-1));    
        }        
 }

参考：

http://blog.csdn.net/morewindows/article/category/859207

《啊哈！算法》