java排序算法总结

用Java实现排序：冒泡排序、插入排序、选择排序、Shell排序、快速排序、归并排序、堆排序、基数排序

冒泡算法

两个两个进行比较，交换位置

public class PopSort {
    public static int[] sort(int[] a){
        boolean sorted=true;
        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];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                    sorted=false;
                }
            }
            if(sorted==true){//优化，减少比较次数
                    break;
            }
        }
        return a;
    }
}

选择排序

从左边开始比较，小的放左边

public class SelectSort {
    public static int[] sort(int[] a){
        int temp;
        for(int i=0;i<a.length;i++){
            for(int j=a.length-1;j>i;j--){与后面的数进行比较
                if(a[j]<a[i]){//交换
                    temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;

                }
            }
        }
        return a;
    }
}

插入排序

public class InsetSort {
    public static int[] sort(int[] a){
        int temp;
        for(int i=1;i<a.length;i++){
            temp=a[i];
            for(int j=0;j<=i-1;j++){//有个坑，必须从前往后比，不能(int j=i-1;j>=0;j--)
                if(a[i]<a[j]){//把小的插到前面
                   for(int k=i;k>=j+1;k--){
                       a[k]=a[k-1];
                   }
                   a[j]=temp;
                }
            }
        }
        return a;
    }
}

Shell排序

public class ShellSort {
    public static int[] sort(int[] a){
        int n=a.length;
        int increment=n/2;
        int temp;
        while(increment>=1) {//必须分到每组为一个，没等于1，坑了好久
            for (int i = 0;i<=n/2;i++) {
                for(int j=i+increment;j<n;j+=increment){
                    temp=a[j];
                    for(int k=i;k<=j-increment;k+=increment){//进行插入排序
                        if(a[j]<a[k]){
                            for(int m=j;m>=k+increment;m-=increment){
                                a[m]=a[m-increment];
                            }
                            a[k]=temp;
                        }
                    }
                }

            }
            increment/=2;
        }
        return a;
    }
}

分成好多组进行排序，插入排序的优化

快速排序：

public class QuickSort {
    public static int[] sort(int[] a,int left,int right){
        if(left>right){//必须在刚开始就判断
            return a;
        }
        int i=left;
        int j=right;
        int base=a[left];

        while(i<j) {
            while (i<j&&a[i] <=base) {//从左到右，直到找到比base大的数
                i++;
            }
            while (i<j&&a[j] >= base) {//从右到左，直到找到比base小的数
                j--;
            }
            if(i<j) {//交换位置
                int temp;
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
        if(a[i]<base) {//调整base的位置
            int p = a[left];
            a[left] = a[i];
            a[i] = p;
        }
        if(a[i]>base) {
            int p = a[left];
            a[left] = a[i-1];
            a[i-1] = p;
            i--;
        }
        sort(a,left,i-1);//递归调用
        sort(a,i+1,right);
        return a;
    }

}

递归调用停止条件在第一行判断。

归并排序

public class MergeSort {
    public static int[] sort(int[]a,int low,int right){
        if(low<right){
            int mid=(right+low)/2;
            sort(a,low,mid);//前半部分
            sort(a,mid+1,right);//后半部分
            merge(a,low,mid,right);//归并排序
        }
        return a;
    }
    public static void merge(int[] b,int low,int mid,int hight){
      int[] temp=new int[b.length];//这个坑贼大，传递的值总是在操作一个数组对象
        int i=low;//temp的索引
        int j=low;//前面的索引
        int k=mid+1;//后面的索引
        while(low<=mid&&k<=hight){
            if(b[low]<=b[k]){//将两个数组中较小的放入临时数组中
                temp[i++]=b[low++];
            }else{
                temp[i++]=b[k++];
            }
        }
        while(low<=mid){//将前一个数组的剩余元素放入临时数组
            temp[i++]=b[low++];
        }
        while(k<=hight){//将后一个数组的剩余元素放入临时数组
            temp[i++]=b[k++];
        }
        while(j<=hight){将临时数组的元素传给原数组
            b[j]=temp[j++];
        }
    }
}

为什么要用b.length的原因：

堆排序

public class HeapSort {
    public static int[] heapSort(int[] a,int last){
        int count=last+1;
        for(int i=0;i<count;i++){
            sort(a,last-i);//必须加-i,把每次得到的最大数放到最后一位
            int temp=a[0];
            a[0]=a[last-i];//注意这个交换的i也必须加上
            a[last-i]=temp;
        }
        return a;
    }
    public static int[] sort(int[] a,int last){
        for(int i=(last-1)/2;i>=0;i--){
            int fatherNode=i;
            while(fatherNode*2+1<=last){
                int bigger=fatherNode*2+1;//先把左子节点当作大的
                if(bigger<last){          //如果有右边子节点
                    if(a[bigger]<a[bigger+1]){//如果右边子节点大，则bigger给它
                        bigger++;
                    }
                }
                if(a[fatherNode]<a[bigger]){//如果父节点小与子节点bigger，则交换位置
                    int temp=a[fatherNode];
                    a[fatherNode]=a[bigger];
                    a[bigger]=temp;
                    fatherNode=bigger;//这个很重要
                }else{
                    break;
                }
            }

        }
        return a;
    }
}

基数排序

public class RadixSort {
    public static int[] radixSort(int[] a){
        int[][] tong=new int[a.length][10];//作为一个10列的桶（0，1，2，3，4，5，6，7..)
        int n=1;
        int i=0;
        int temp=0;
        int[] a1=new int[a.length];//作为一个中间数组，排序a数组
        int[] count=new int[10];//保存每个桶里的元素数量
        for(i=0;i<a.length;i++){//比较出数组中最大的数
            temp=a[0];
            if (a[i]>temp) {
               temp=a[i];
            }
        }
        while(temp/10>0){//算出最大数为几位数
            temp/=10;
            n*=10;
        }

        int n1=1;
        while(n1<=n) {//从个位开始排序，一直到最高位
            for (int j = 0; j < a.length; j++) {//将元素放入相应的桶里
                int c = (a[j]/n1)% 10;
                tong[count[c]][c] = a[j];
                count[c]++;

            }
            int g=0;//刚开始把它放在了while外面，小坑
            for (int k = 0; k < 10; k++) {//按顺序从桶里取出来
                for (int m=0; m <count[k]; m++) {
                    a1[g++] = tong[m][k];
                }
            }
            for(int[] s:tong){
                for(int s1:s){
                    System.out.print(s1+"\t");
                }
                System.out.println();
            }
            n1*=10;
            System.arraycopy(a1,0,a,0,a.length);
            Arrays.fill(count,0);//这两个必须置零，不然问题就大了
            Arrays.fill(a1,0);
        }

        System.out.println(Arrays.toString(a));
        return a;
    }

}

用一周时间完了这几种排序，还是太弱。