比较

package text;

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

public class MaoPaoUtil {
    private int[] numbs={88,11,22,3,666,77,999,345,77,2121,413132,4545,5452,87874,1,545,-1,6554,213,1321};
    
    /**
     * 传统的冒泡算法
     */
    public void oldMaoPao(){

        int runNumb=0;
        /**
         * 先计算需要比对的次数,每次循环可以确定当轮的最大数或者最小数，10个数9次就出了结果，11个数10次就出了结果，类推
         */
        for(int i=0;i<numbs.length-1;i++){
        
            /**
             * 然后计算每一轮，里面有多少个数互相比较，每轮都少了一个数，10个数，9次就能比对为，公式就很简单了
             */
            for(int j=0;j<numbs.length-1-i;j++){
                runNumb++;
                /**
                 * 计算这一轮比对的值,为当前位置的值，和下一个位置的值
                 */
                int n1=numbs[j];
                int n2=numbs[j+1];
                /**
                 * 我们比哪个大
                 */
                if(n1>n2){
                    /**
                     * 把他们的位置值换一下，换位算法
                     */
                    int n3=n1;
                    n1=n2;
                    n2=n3;
                    /**
                     * 值互换好了，把值放进去
                     */
                    numbs[j]=n1;
                    numbs[j+1]=n2;
                }
                
            }
        
        }
        /**
         *         现在值就出来了    
         */
        for(int n:numbs){
            System.out.println(n);
        }
        System.out.println("总共计算了多少次:"+runNumb);
        System.out.println("-----------分割线------------");
    }
    
    /**
     * 传统的算法优化点点
     */
    public void oldMaoPaoIsBetter(){
        int runNumb=0;

        /**
         * 先计算需要比对的次数,每次循环可以确定当轮的最大数或者最小数，10个数9次就出了结果，11个数10次就出了结果，类推
         */
        for(int i=0;i<numbs.length;i++){
            boolean isChange=false;
            /**
             * 然后计算每一轮，里面有多少个数互相比较，每轮都少了一个数，10个数，9次就能比对为，公式就很简单了
             */
            for(int j=0;j<numbs.length-1-i;j++){
                runNumb++;
                /**
                 * 计算这一轮比对的值,为当前位置的值，和下一个位置的值
                 */
                int n1=numbs[j];
                int n2=numbs[j+1];
                /**
                 * 我们比哪个大
                 */
                if(n1>n2){
                    /**
                     * 把他们的位置值换一下，换位算法
                     */
                    int n3=n1;
                    n1=n2;
                    n2=n3;
                    /**
                     * 值互换好了，把值放进去
                     */
                    numbs[j]=n1;
                    numbs[j+1]=n2;
                    /**
                     * 记录这轮发生了改变
                     */
                    isChange=true;
                }
            }
            
            if(!isChange){
                /**
                 * 如果没发生改变，就说明，数据是最优的了，可以提前结束循环了
                 */
                break;
            }
        
        }
        /**
         *         现在值就出来了    
         */
        for(int n:numbs){
            System.out.println(n);
        }
        System.out.println("总共计算了多少次:"+runNumb);
        System.out.println("-----------分割线------------");
    }
    
    
    public void xiaoGeCreate(){
        int runNumb=0;
        /**
         * 先创建个对象，放存的值
         */
        List<Integer>numbList=new ArrayList<Integer>();
        int putIndex=-1;//放入的位置
        
        for(int i=0;i<numbs.length;i++){
            int nowN=numbs[i];
            if(putIndex==-1){
                runNumb++;
                /**
                 * 说明刚开始
                 */
                putIndex=0;
                numbList.add(nowN);
            }else{
                /**
                 * 如果上次放入进去的数，比这次的要大，把这个数字计算一下，放入到这个数的前面
                 */
                int ln=numbList.get(putIndex);
                
                if(ln==nowN){
                    runNumb++;
                    /**
                     * 相等，直接放到后面就好了
                     */
                    putIndex=putIndex++;
                    numbList.add(putIndex,nowN);
                }else if(nowN>ln){
                    /**
                     * 这个值比上轮大,计算在它后面的位置，从它后面一个位置开始计算
                     */
                    boolean isChange=false;
                    for(int j=putIndex+1;j<numbList.size();j++){
                        runNumb++;
                        int qn=numbList.get(j);
                        if(nowN<=qn){
                            /**
                             * 如果小于等于,就放到这个位置就好了
                             */
                            isChange=true;
                            System.out.println("----------pao dao zheli laile1:"+nowN+"-----------------"+ln);
                            numbList.add(j, nowN);
                            break;
                        }
                    }
                    /**
                     * 能运行到这里，说明这个数，比后面的都大，加到最后面就可以了
                     */
                    if(!isChange){
                        runNumb++;
                        putIndex=numbList.size();
                        numbList.add(nowN);
                        System.out.println("----------pao dao zheli laile2:"+nowN+"-----------------"+ln);
                    }
                
                
                }else{
                    /**
                     * 这个值比上轮小,计算在它前面的位置
                     */
                    boolean isChange=false;
                    for(int j=putIndex-1;j>=0;j--){
                        runNumb++;
                        int qn=numbList.get(j);
                        if(nowN>=qn){
                            /**
                             * 如果这次加入的数，比这个数字要大，就放到它的后面
                             */
                            isChange=true;
                            numbList.add(j+1, nowN);
                            System.out.println("----------pao dao zheli laile3:"+nowN+"-----------------"+ln);
                            break;
                        }
                        
                    }
                    if(!isChange){
                        runNumb++;
                        putIndex=0;
                        numbList.add(0,nowN);
                        System.out.println("----------pao dao zheli laile4:"+nowN+"-----------------"+ln);
                    }
                    
                
                }
                
                
                
            
                
                /**
                 *         现在值就出来了    
                 */
                for(int n:numbList){
                    System.out.println("shenme gui:"+n);
                }
                System.out.println("---------------------------------------------");
            }
        }

        /**
         *         现在值就出来了    
         */
        for(int n:numbList){
            System.out.println(n);
        }
        System.out.println(numbList.size()==numbs.length);
        System.out.println("总共计算了多少次:"+runNumb);
        System.out.println("-----------分割线------------");
    }
    
    
    public static void main(String[] args) {
        new MaoPaoUtil().oldMaoPao();
        new MaoPaoUtil().oldMaoPao();
        new MaoPaoUtil().xiaoGeCreate();;
    }
}
 

最后结果：老的冒泡是190次，新的冒泡，次数满足的条件下可能会比较少，自己改的算法只需要跑81次。缺点是新的算法，内存会多一倍，换位算法，多了几个占位对象，是为了写给某峰看的！很久没发布这种文章了，做开发还是要多动动脑子