常見排序

 

有空加上堆排：1.先創建大堆，往上冒泡，下來的泡再一直往下。  2,2選1，後插。

排序能夠複習下。自己代碼簡潔。

//常見的排序，冒泡，歸併，快排。
    public static class sort
    {
        public static int[] getData()
        {
            int[] ret=new int[]{5,2,9,-3};
            return ret;
        }
        
        //冒泡,浪費了不少次比較，每次循環，沒有爲下一次循環提供幫助。時間複雜度 n平方
        public static void popo()
        {
            int[] data=getData();
            int tempMax=0;
            for(int i=0;i<data.length;i++)
            {
                int tempIndex=i;
                for(int h=i+1;h<data.length;h++)
                {
                    if(data[h]>data[tempIndex])
                    {
                        tempIndex=h;
                    }
                }
                tempMax=data[tempIndex];
                data[tempIndex]= data[i];
                data[i]=tempMax;
            }
            printLog(data);
        }
        
        public static void printLog(int[] ret)
        {
            for(int i=0;i<ret.length;i++)
            {
                LSLog.printLine(ret[i]+"", 1);
            }
        }
        
        //歸併排序， 典型的分治：問題太大。那麼就把問題一拆爲二，結果分別排序好的組合起來，當爲1時，不須要拆和排序。是最小問題。
        public static void merginSort()
        {
            int[] data=getData();
            if(data.length>=2)
            {
                mergin(data, 0, data.length-1);
            }
            printLog(data);
        }
        
        //分解：中分from to.合併2個。  最小問題：1個數字。不用處理。
        private static void mergin(int[] data,int from,int to)
        {
            int lengto=to-from+1;
            int half=lengto/2;
            LSLog.printLine("from:"+from+".to:"+to+".half:"+half, 1);
            assert(half>=0):"???";
            if(lengto==1)
            {
                
            }
            else
            {
                mergin(data, from, from+half-1);
                mergin(data, from+half, to);
                int dynamicFrom=from;
                for(int i=half;i<=to;i++)
                {
                    for(int h=dynamicFrom;h<=half-1+i-half;h++)
                    {
                        if(data[i]<data[h])
                        {
                            int tempMin=data[i];
                            System.arraycopy(data, h, data, h+1,i-h);
                            data[h]=tempMin;
                            dynamicFrom=h+1;
                        }
                    }
                }
            }
        }
        
        
        
        
        //冒泡實在不行，浪費了不少次比較結果。  快排聰明點，每次比較，作點額外工做，左右按大小分邊，因此下次查找大或小，就少了一半。
        public static void QuickSort()
        {
            int[] data=getData();
            QSort2(data, 0, data.length-1);
            printLog(data);
        }
        
        //代碼簡潔，效率稍低：碰到大的就後插。
        private static void QSort2(int[] data,int from ,int to)
        {
            if(to-from<=0){}
            else if(to-from==1)
            {
                if(data[from]>data[to])
                {
                    swapINT(data, from, to);
                }
            }
            else 
            {
                int CompareIndex=getCompareIndex(data, from, to);
                swapINT(data, to, CompareIndex);
                CompareIndex=to;
                for(int i=0;i<CompareIndex;i++)
                {
                    if(data[i]>data[CompareIndex])
                    {
                        int tempBigger=data[i];
                        System.arraycopy(data, i+1, data, i, CompareIndex-i);//modify+1
                        data[CompareIndex]=tempBigger;
                        CompareIndex--;//modify
                        i--;
                    }
                }
                QSort2(data,from, CompareIndex-1);
                QSort2(data,CompareIndex+1, to);//modify
            }
        }
        
        
        //高效版，處理邊界麻煩，不當心就錯：一大一對調。
        private static void QSort(int[] data,int from ,int to)
        {
            //assert(from<to):"from>to?";
            if(to-from<=0){}
            else if(to-from==1)
            {
                if(data[from]>data[to])
                {
                    swapINT(data, from, to);
                }
            }
            else 
            {
                boolean isSorted=false;
                int centerIndex=getCompareIndex(data, from, to);
                swapINT(data, to, centerIndex);
                int beginCheckIndex=from;
                int endCheckIndex=to-1;
                int lastCenter=0;
                while (!isSorted)
                {
                    for(beginCheckIndex=beginCheckIndex;beginCheckIndex<=endCheckIndex;beginCheckIndex++)
                    {
                        if(data[beginCheckIndex]>data[to])
                        {
                            break;
                        }
                    }
                    if(beginCheckIndex>endCheckIndex)
                    {
                        isSorted=true;
                        lastCenter=to;
                    }
                    else if(beginCheckIndex==endCheckIndex)
                    {
                        swapINT(data, beginCheckIndex, to);
                        lastCenter=beginCheckIndex;
                        isSorted=true;
                    }
                    else 
                    {
                        for(endCheckIndex=endCheckIndex;endCheckIndex>beginCheckIndex;endCheckIndex--)
                        {
                            if(data[endCheckIndex]<data[to])
                            {
                                break;
                            }
                        }
                        if(endCheckIndex==beginCheckIndex)
                        {
                            isSorted=true;
                            swapINT(data, beginCheckIndex, to);
                            lastCenter=beginCheckIndex;
                        }
                        else
                        {
                            swapINT(data, beginCheckIndex, endCheckIndex);
                            isSorted=false;
                            beginCheckIndex++;
                            endCheckIndex++;
                        }
                    }
                    
                QSort(data, from, beginCheckIndex-1);
                QSort(data, beginCheckIndex+1, to);
                //{2,6,9,1,4,0,3,5,7,8};
                // |               |
                }
            }
        }
        
        
        
        private static void swapINT(int[] data,int from ,int to)
        {
            int temp=data[from];
            data[from]=data[to];
            data[to]=temp;
        }
        
        //作成了求推理題目
        private static int getCompareIndex(int[] data,int fromIndex,int toIndex)
        {
            int ret=0;
            int centerIndex=(fromIndex+toIndex)/2;
            //choose bigger
            ret=data[fromIndex]>data[centerIndex]?fromIndex:centerIndex;
            int templeft=data[fromIndex]<=data[centerIndex]?fromIndex:centerIndex;
            //choose smaller
            ret=data[ret]<data[toIndex]?ret:toIndex;
            //choose bigger
            ret=data[ret]>data[templeft]?ret:templeft;
            
            return ret;
        }
        
    }