java实现常用算法

一.拆半插入排序

/**
 * 拆半插入排序（二分插入排序）：是直接插入排序改良版，也需要i-1趟插入，不同之处在于，第i趟插入，先找到插入的位置
 *
 * @create 2017-12-20 11:59
 **/
public class BinaryInsertSort {
    public static void main(String[] args){
        int[] data = new int[]{1,2,4,8,-1,3,-10,-4};
        System.out.println("排序前的数据："+ Arrays.toString(data));
        binzryInsertSort(data);
        System.out.println("排序后的数据："+Arrays.toString(data));
    }

    public static void binzryInsertSort(int[] data){
        if(data==null||data.length==0) return;
        for(int i=1;i<data.length;i++){
           if(data[i]<data[i-1]){
                int temp = data[i];
                int low = 0;
                int high = i-1;
                while(low<=high){
                   int mid = (low+high)/2;
                   if(data[mid]<temp){
                      low = mid+1;
                   }else{
                       high = mid-1;
                   }
                }
                for(int j =i;j>low;j--){
                      data[j]=data[j-1];
                }
                data[low]=temp;
           }
        }
    }
}

二.泡排序

/**
 * 冒泡排序:将每个元素视为气泡,遵循轻的气泡不能在重的之下,不断循环将轻的浮到上面
 * 时间复杂度：O(n2)
 * 空间复杂度：O(1)
 * 算法稳定，冒泡算法有许多特性和插入排序算法相似，但是系统开销更大
 * @create 2017-12-20 10:09
 **/
public class BubbleSort {
    public static void main(String[] args){
        int[] data = new int[]{1,2,4,8,-1,3,-10,-4};
        System.out.println("排序前的数据："+ Arrays.toString(data));
        bubbleSort(data);
        System.out.println("排序后的数据："+Arrays.toString(data));
    }

    public static void bubbleSort(int[] data){
        if(data == null || data.length==0) return ;
        for (int i = 0;i<data.length;i++) {//每次循环一定能将待排序数组中的最大值交换到最后
            boolean flag = false;
            for (int j = 0;j<data.length-i-1;j++){//这样这里的j就没有必要循环到data.length
                if(data[j]>data[j+1]){
                    CommonSort.swagData(data,j,j+1);
                    flag=true;
                }
            }
            if(!flag) break;//如果完成一侧循环发现数组是有序的就没有必要继续循环了
        }
    }
}

三.直接选择排序

public class DirectSort {

    public static void main(String[] args){
        int[] data = new int[]{1,2,4,8,-1,3,-10,-4};
        System.out.println("排序前的数据："+ Arrays.toString(data));
        selectSort(data);
        System.out.println("排序后的数据："+Arrays.toString(data));
    }
    public static void selectSort(int[] data){
        if(data==null||data.length==0) return;
        for (int i = 0;i<data.length;i++) {
            int min = data[i];
            for(int j=i+1;j<data.length;j++){
                if(data[j]<data[i]){
                    CommonSort.swagData(data,i,j);
                }
            }

        }
    }
}

四.堆排序

/**
 * 堆排序：大根堆排序/小根堆排序，每次为待排序数据创建新堆，然后将新堆的第一项与最后一项交换（待排序）
 * 不断的调整堆直到堆中只有一个元素
 * 时间复杂度：O(nlog2n)
 * 空间复杂度：O(1)
 * 不稳定，不推荐使用
 * @create 2017-12-15 14:59
 **/
public class HeapSort {
    public static void main(String[] args){
        int[] data = new int[]{1,2,4,8,-1,3,-10,-4};
        System.out.println("排序前的数据："+ Arrays.toString(data));
        heapSort(data);
        System.out.println("排序后的数据："+Arrays.toString(data));
    }
    public static void heapSort(int[] data){
        if(data==null||data.length==0) return;
        for(int i=0;i<data.length;i++){
            int len=data.length-1-i;
            createNewHeap(data,len);
            CommonSort.swagData(data,0,len);
        }
    }

    private static void createNewHeap(int[] data, int lastIndex) {
        for (int i =(lastIndex-1)/2;i>=0;i--){
            int k  =i;
            while(k*2+1<=lastIndex){
               int bigIndex = 2*k+1;
               if(bigIndex<lastIndex){
                   if(data[bigIndex]<data[bigIndex+1]){
                      bigIndex++;
                   }
               }
               if(data[k]<data[bigIndex]){
                  CommonSort.swagData(data,k,bigIndex);
                  k=bigIndex;
               }else{
                   break;
               }
            }
        }
    }
}

五.直接插入排序

/**
 * 直接插入排序
 *
 * @create 2017-12-20 11:27
 **/
public class InsertSort {
    public static void main(String[] args){
        int[] data = new int[]{1,2,4,8,-1,3,-10,-4};
        System.out.println("排序前的数据："+ Arrays.toString(data));
        insertSort(data);
        System.out.println("排序后的数据："+Arrays.toString(data));
    }

    public static void insertSort(int[] data){
        if(data == null||data.length==0) return;
        for(int i= 1;i<data.length;i++){
           int temp = data[i];
           if(data[i]<data[i-1]){
               int j = i-1;
               //将有序数组整体后移，找到temp的位置进行赋值
               while(j>=0&&data[j]>temp){
                  data[j+1]=data[j];
                  j--;
               }
               data[j+1] =temp;
           }
        }
     }
}

六.快速排序

/**
 * 快速排序：从元素中随便找一个元素作为分界值，循环遍历将比其小的放到其左边，比其打的放到其右边，
 * 接下来对左右两个子序列依照上面规则进行循环遍历，直到每个子序列中只有一个元素
 * 时间复杂度：O(nlog2n)
 * @create 2017-12-20 10:30
 **/
public class QuickSort {
    public static void main(String[] args){
        int[] data = new int[]{1,2,4,8,-1,3,-10,-4};
        System.out.println("排序前的数据："+ Arrays.toString(data));
        quickSort(data,0,data.length-1);
        System.out.println("排序后的数据："+Arrays.toString(data));
    }

    public static void quickSort(int[] data,int start,int end){
        if(start >end) return;//很关键，控制选取的分界点数据为最大或最小时直接跳出
        int piv = data[start];//选取分界点
        int i = start+1;//开始循环位置
        int j = end;
        while(i<=j){
            while(i<=end&&data[i]<piv){//从左向右开始一直找一个比分界点小的数据
                i++;
            }
            while(j>=start&&data[j]>piv){//从右向左寻找比分界点大的数据
               j--;
            }
            if(i<j){
                CommonSort.swagData(data,i,j);
            }
        }
        CommonSort.swagData(data,start,j);
        quickSort(data,start,j-1);
        quickSort(data,j+1,end);
    }
}

七.希尔排序

/**
 * 希尔排序：是对直接插入排序的一种改进
 *
 * @create 2017-12-20 14:12
 **/
public class ShellSort {
    public static void main(String[] args){
        int[] data = new int[]{1,2,4,8,-1,3,-10,-4};
        System.out.println("排序前的数据："+ Arrays.toString(data));
        shellSort(data);
        System.out.println("排序后的数据："+Arrays.toString(data));
    }

    public static void shellSort(int[] data){
        //计算出最大h
        int h =1;
        while(h<data.length/3){
            h=h*3+1;
        }
        while(h>0){
            for(int i = h;i<data.length;i+=h){
                if(data[i]<data[i-h]){
                   int temp=data[i];
                   int j = i-h;
                   while(j>=0&&data[j]>temp){
                       data[j+h]=data[j];
                       j-=h;
                   }
                   data[j+h]=temp;
                }
            }
            h=(h-1)/3;
        }
    }
}

---

想了解更多java相关技术，请关注公众号“JavaEE那些事”

扫描下面二维码，更多技术资料等你来拿