排序算法

 

1.冒泡排序

package PaiXu;
/*
 * 每一趟比较，把最大的数沉下去
 */
public class MaoPaoDemo2 {
    
    public static void main(String[] args){
        int a[]={1,3,5,7,8,6,2,0,11,13,20,18,16};
        int temp;
        for(int i=0;i<a.length-1;i++){
            for(int j=0;j<a.length-1-i;j++){
                if(a[j]>a[j+1]){
                    temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                }
            }
            
        }
        
        for(int data:a){
            System.out.print(data+" ");
        }
    }

}

运行结果：

0 1 2 3 5 6 7 8 11 13 16 18 20 

1.2冒泡算法优化

　　若发现某趟排序中，没有发生数据交换，则证明顺序已经排好，不用进行后面的比较排序工作

package PaiXu;
/*
 * 每一趟比较，把最大的数沉下去
 * 算法优化：当某一天趟未出现数据交换时，说明顺寻已经排好，不用再进行后面的排序工作
 */
public class MaoPaoDemo3 {
    public static void main(String[] args){
        //int a[]={1,3,5,7,8,6,2,0,11,13,20,18,16};
        int a[]={1,2,3,4,5,6};
        int temp;
        boolean flag=true;
        for(int i=0;i<a.length-1;i++){
            System.out.println("第"+(i+1)+"趟比较");
            for(int j=0;j<a.length-1-i;j++){
                if(a[j]>a[j+1]){
                    temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                    flag=false;
                }
            }
            if(flag){
                break;
            }
            
        }
        
        for(int data:a){
            System.out.print(data+" ");
        }
    }
    }

运行结果：

1.3 算法复杂度

　　O（n^2）

2.选择排序算法

2.1选择排序算法思想

 

2.2 选择排序算法思路

2.3 代码实现

package PaiXu;

public class XuanZeDemo {

    public static void main(String[] args){
        int a[]={1,3,5,7,8,6,2,0,11,13,20,18,16};
        int temp;
        for(int i=0;i<a.length-1;i++){
            for(int j=(i+1);j<a.length;j++){
                if(a[i]>a[j]||a[i]==a[j]){
                    temp=a[j];
                    a[j]=a[i];
                    a[i]=temp;
                }
                
            }
        }
        for(int num:a){
            System.out.print(num+" ");
        }
    }
}

运行结果：

0 1 2 3 5 6 7 8 11 13 16 18 20 

2.4 算法复杂度

　　O（n^2）

3.插入排序算法

package PaiXu;
/*
 * 插入排序算法
 */
public class ChaRuDemo {
    
    public static void main(String[] args){
        int a[]={1,3,5,7,8,6,2,0,11,13,20,18,16};
        int index;
        int value;
        
        for(int i=1;i<a.length;i++){
            value=a[i];
            index=i-1;
            
            while(index>-1&&value<a[index]){
                a[index+1]=a[index];
                index--;
            }
            
            a[index+1]=value;
        }
        
        
        for(int data:a){
            System.out.print(data+" ");
        }
    }

}

运行结果：

0 1 2 3 5 6 7 8 11 13 16 18 20 

3.1 算法复杂度

4.希尔排序算法

　　希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n²）的第一批算法之一。

　　简单插入排序很循规蹈矩，不管数组分布是怎么样的，依然一步一步的对元素进行比较，移动，插入，比如[5,4,3,2,1,0]这种倒序序列，数组末端的0要回到首位置很是费劲，比较和移动元素均需n-1次。而希尔排序在数组中采用跳跃式分组的策略，通过某个增量（gap）将数组元素划分为若干组，然后分组进行插入排序，随后逐步缩小增量，继续按组进行插入排序操作，直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序，小的基本在前，大的基本在后。然后缩小增量，到增量为1时，其实多数情况下只需微调即可，不会涉及过多的数据移动。

　　我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

5.快速排序算法

　　快速排序实现的重点在于数组的拆分，通常将数组的第一个元素定义为比较元素，然后将数组中小于比较元素的数放到左边，将大于比较元素的放到右边，

　　这样就将数组拆分成了左右两部分：小于比较元素的数组；大于比较元素的数组。再对这两个数组进行同样的拆分，直到拆分到不能再拆分，数组就自然而然地以升序排列了。

package PaiXu;

public class KuaiSuDemo {
    public static void main(String[] args){
        int[] a={23,45,17,11,13,89,72,26,3,17,11,13};
        QuickSort(a,0,a.length-1);
        for(int data:a){
            System.out.print(data+" ");
        }
        
    }
    
    /*
     * 对传过来的数组进行处理，将数组的首位元素设定为参考元素，
     * 然后从两边遍历数组，将大于参考元素的数放到其右边，小于的放到左边
     * 从右边先开始
     * 最终返回参考元素的位置
     */
    public static int PaiXu(int[] a,int left,int right){
        int temp=a[left];//暂存当前数组的首个元素
    
        while(left<right){
        //从数组右边开始往左看，直到遇到的数小于temp
            while(left<right&&a[right]>=temp){
                right--;
            }
            a[left]=a[right];//将小于temp的值赋给temp左边，left指向的位置。
        
            while(left<right&&a[left]<=temp){
                left++;
            }
            a[right]=a[left];
        
        }
        
        a[left]=temp;//将之前保存的数组首位元素放入此时left指针指向的位置
        return left;//将当前left指针所在位置返回,及返回当前已处理好的数组的分界位置
        
        
    }
    
    //
    public static void QuickSort(int[] a,int left,int right){
        
        int index=0;
        if(left<right){//当left=right时，说明当前数组中只有一个元素，无序再进行排序
            index=PaiXu(a,left,right);
            QuickSort(a,left,index-1);
            QuickSort(a,index+1,right);
        }
    }

}

6.归并排序算法

6.1 基本思想

　　归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治策略（分治法将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

　　可以看到这种结构很像一棵完全二叉树，本文的归并排序采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log₂n。

6.2 合并相邻有序子序列

　　再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。

 

 

package PaiXu;

public class GuiBingDemo {
    
    public static void main(String[] args){
        int[] a={8,9,1,7,2,3,5,4,6,0};
        int[] temp=new int[a.length];
        Sort(a,0,a.length-1,temp);
        
        for(int data:a){
            System.out.print(data+" ");
        }
        
    }

    
    public static void Sort(int[]a,int left,int right,int[] temp){
        if(left<right){
            int mid=(left+right)/2;
            Sort(a,left,mid,temp);
            Sort(a,mid+1,right,temp);
            
            
            //将两个有序数组合并为一个有序数组
            PaiXu(a,left,right,mid,temp);
        }
    }
    
    
    public static void PaiXu(int[]a,int left,int right,int mid,int[] temp){
        int i=left;
        int j=mid+1;
        int index=0;
        while(i<=mid&&j<=right){
            if(a[i]<a[j]){
                temp[index]=a[i];
                i++;
            }else{
                temp[index]=a[j];
                j++;
            }
            index++;
        }
        
        while(i<=mid){
            temp[index]=a[i];
            index++;
            i++;
        }
        
        while(j<=right){
            temp[index]=a[j];
            index++;
            j++;
        }
        
        
        //将合并好后的临时数组复制到原数组a
        index=0;
        for(int k=left;k<=right;k++){
            a[k]=temp[index];
            index++;
        }
        
    }
}

 

运行结果：

0 1 2 3 4 5 6 7 8 9 

 7.基数排序算法

　　基数排序适合于有不同位数的大小数字

7.1 核心思想
　　先找十个桶：0~9
　　第一轮按照元素的个位数排序
　　桶内分别存放上述数组元素的个位数，按照数组元素的顺序依次存放

　　之后，按照从左向右，从上到下的顺序依次取出元素，组成新的数组。

　　在新的数组中，进行第二轮，按照十位数排序，依次存放于桶中：

　　按照之前的顺序取出，组成新的数组。
　　进行第三轮，按照百位数排序：

　　将百位数的元素取出之后，我们发现新的数组已经变成了有序数组

7.2 代码

package PaiXu;

public class JiShuDemo {
    public static void main(String[] args){
        int[] a={26,3,38,66,88,188,881,999,1,12,88,58,6006,9,0};
        Sort(a);
    }

    
    public static void Sort(int[] a){
        int le=getMax(a);
        int[][]temp=new int[10][a.length];//用二维数组表示某个数存放在第几个桶的第几位
        int []count=new int[10];//用来定位在某个桶中的哪一个位置
        int index;
        for(int i=0;i<le;i++){
            for(int j=0,n=1;j<a.length;j++,n*=10){
                index=(a[j]/n)%10;
                
                //count[index]中index代表是哪个桶，而count[index]的值代表标号为index的桶中当前元素的位置，也即当前数据在标号为index的桶中的位置
                temp[index][count[index]]=a[j];
                count[index]++;
            }
            
            //将各个桶中的数取出来
            int l=0;
            for(int m=0;m<10;m++){
                for(int k=0;k<count[m];k++){
                    a[l]=temp[m][k];
                    l++;
                }
                
            }
        
        }
        
        for(int data:a){
            System.out.print(data+" ");
        }
        
    }
    
    public static int getMax(int[] a){
        //找出本组最大的数，并确定其位数
        int max=a[0];
        for(int i=1;i<a.length;i++){
            if(max<a[i]){
            max=a[i];
                    }
            }
        int le=(max+"").length();//获取最大数的位数
        
        return le;
    }
    
    
    
}

运行结果：

 

分析：在执行完一轮存取后，没有将count[index]清零，导致temp[index][count[index]]越界

 

这里写的也有问题

修改后的完整代码：

package PaiXu;

public class JiShuDemo {
    public static void main(String[] args){
        int[] a={26,3,38,66,88,188,881,999,1,12,88,58,6006,9,0};
        Sort(a);
    }

    
    public static void Sort(int[] a){
        int le=getMax(a);
        int[][]temp=new int[10][a.length+1];//用二维数组表示某个数存放在第几个桶的第几位
        int []count=new int[10];//用来定位在某个桶中的哪一个位置
        int index;
        for(int i=0,n=1;i<le;i++,n*=10){
            for(int j=0;j<a.length;j++){
                index=(a[j]/n)%10;

                //count[index]中index代表是哪个桶，而count[index]的值代表标号为index的桶中当前元素的位置，也即当前数据在标号为index的桶中的位置
                
                count[index]++;
                temp[index][count[index]]=a[j];
                //count[index]++;
            }
            
            //将各个桶中的数取出来
            int l=0;
            for(int m=0;m<10;m++){
                for(int k=1;k<=count[m];k++){
                    a[l]=temp[m][k];
                    l++;
                }
                count[m]=0;//清零很重要，否则count[]的值会一直累加上去，导致第21行出现越界错误
                
            }
            
        }
        
        for(int data:a){
            System.out.print(data+" ");
        }
        
    }
    
    public static int getMax(int[] a){
        //找出本组最大的数，并确定其位数
        int max=a[0];
        for(int i=1;i<a.length;i++){
            if(max<a[i]){
            max=a[i];
                    }
            }
        int le=(max+"").length();//获取最大数的位数
        
        return le;
    }
    
    
    
}

运行结果：