距离矢量路由算法的java代码_八大排序算法比较（附Java代码）

冒泡排序

/**
 * 冒泡排序 比较好理解
 * 两两相比 较大的放后面
 * 时间复杂度O(n^2)
 */

/**
 * 改进前的冒泡排序算法进行100,000数据排序运行时间为：3829ms
 * 优化后的冒泡排序算法进行100,000数据排序运行时间为：3551ms
 */
public static void bubbleSort(int[] array){ //原始的冒泡排序，比较的次数是固定的
    int len=array.length;
    int temp=0;
    for(int i=0;i<len-1;i++){
        for(int j=0;j<len-1-i;j++){
            if(array[j]>array[j+1]){
                temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
            }
        }
    }
}

public static void bubbleSort2(int[] array){ //改进的冒泡排序，有序时无需比较
    int len=array.length;
    int temp=0;
    boolean flag=true;
    for(int i=0;i<len-1;i++){
        for(int j=0;j<len-1-i;j++){
            if(array[j]>array[j+1]){
                flag=false;
                temp=array[j];
                array[j]=array[j+1];
                array[j+1]=temp;
            }
        }
        if(flag){ //如果有序 则跳出循环
            break;
        }else {
            flag=true;
        }
    }
}

插入排序

/**
 * 插入排序,将无序元素依次插入到有序数组中
 * 和选择排序很类似。但是其时间取决于数组的初始顺序
 * 时间复杂度为O(n^2)
 */

/**
 * 由于数据量大时可能存在一堆数据后移的情况，所以时间并不一定比选择排序快
 * 插入排序算法进行50,000数据排序运行时间为：1280ms
 */
public static void insertSort(int[] array){
    int temp=0;
    int len=array.length;
    for(int i=1;i<len;i++){
        for(int j=i;j>0;j--){
            if(array[j]<array[j-1]){
                temp=array[j];
                array[j]=array[j-1];
                array[j-1]=temp;
            }
        }
    }
}

选择排序

/**
 * 选择排序
 * 与冒泡排序不同，无需频繁进行交换的操作，时间较冒泡排序短
 * 时间复杂度为O(n^2)
 */

/**
 * 选择排序算法进行50,000数据排序运行时间为：626ms
 */

public static void selectSort(int[] array){
    int len=array.length;
    int temp=0;
    for (int i=0;i<len;i++){
        int min=i;  //min为最小值对应的索引
        for(int j=i;j<len;j++){ //内层循环的目的是为了找到最小值
            if(array[j]<array[min]){
                min=j;
            }
        }
        temp=array[min];
        array[min]=array[i];
        array[i]=temp;
    }
}

希尔排序

/**
 * 希尔排序
 * 插入排序的变种，慢慢地调整数组的顺序，使插入排序效率变高
 * 最坏情况下时间复杂度为O(n^(1-2))
 */

/**
 * 希尔排序的效率肯定是要比插入排序要高的
 * 希尔排序算法进行50,000数据排序运行时间为：705ms
 */
public static void shellSort(int[] array){
    int len=array.length;
    int h=1;
    while(h<len/3)
        h=3*h+1; //希尔排序的增量，相邻增量应该尽可能互斥！！！  h=1,4,13,40,121...
    int temp=0;
    while (h>=1){
        for (int i=h;i<len;i++){
            for(int j=i;j>=h;j-=h){
                if(array[j]<array[j-h]){
                    temp=array[j];
                    array[j]=array[j-h];
                    array[j-h]=temp;
                }
            }
        }
        h/=3;
    }
}

快速排序

/**
 * 快速排序
 * 使用递归的方法，有一些难以理解，多看几遍就好
 * 主要思想就是设定pivot，将所有比pivot大的放右边，比pivot小的放左边
 * 平均的时间复杂度为O(nlogn) ,有序情况下的复杂度为O(n^2)
 */

/**
 * 快排是真的快 ,比冒泡插入选择希尔要快上好多
 * 快速排序算法进行50,000数据排序运行时间为：4.00ms
 */
public static void quickSort(int[] array, int left, int right){
    if(left>right){  //递归结束的条件!!! 没有这个 递归就出不来了
        return;
    }
    int L=left,R=right;
    int pivot=array[left];  //pivot随意设置，这里我们设置pivot为最左边的元素
    while (left<right){
        while (array[right]>=pivot && right>left){ //一定要大于等于或者小于等于 不然数字相同可能出现死循环
            right--; //右指针不断后移
        }
        if(right>left){
            array[left]=array[right]; //左右指针不重合时，将right的值赋给left
        }
        while (array[left]<=pivot && right>left){
            left++; //左指针开始移动
        }
        if(left<right){
            array[right]=array[left];
        }
    }
    array[left]=pivot; //完成第一次排序

    quickSort(array,L,left-1);
    quickSort(array,left+1,R);
}

归并排序

/**
 * 归并排序
 * 同样使用递归，采用分而治之的想法，通过递归的方式将若干个有序序列合并为一个
 * 时间复杂度为 O(nlogn)，同样非常快
 */


/**
 * 归并排序算法进行50,000数据排序运行时间为：4.90ms
 */

public static void merge(int[] array,int left,int mid,int right){ //进行归并操作的函数
    int[] temp=new int[right-left+1]; //建立缓存数组
    int i=left,j=mid+1;
    int index=0;  //temp的索引
    while (i<=mid && j<=right){
        if(array[i]<=array[j]){
//                temp[index]=array[i];
//                i++;
//                index++;
            temp[index++]=array[i++]; //这段代码可以简化成这个形式
        }else {
            temp[index++]=array[j++];
        }
    }
    while (i<=mid){
        temp[index++]=array[i++];
    }
    while (j<=right){
        temp[index++]=array[j++];
    }

    for (int k=left;k<=right;k++){ //将temp传回array
        array[k]=temp[k-left];
    }
}

public static void mergeSort(int[] array,int left,int right){ //归并排序
    if(left>=right){
        return;
    }
    int mid=(left+right)/2;
    mergeSort(array,left,mid);
    mergeSort(array,mid+1,right);  //先分解成最小的
    merge(array,left,mid,right); //再合并
}

基数排序

/**
 * 基数排序
 * 空间换时间，所以时间复杂度最低，为 O(d(n+r)) r是基数(基本都是10),d为长度。。。  可趋近于O(n)
 * PS:我反而觉得基数排序比较复杂，提前需要设置很多变量和数组
 */

/**
 * 基数排序算法进行50,000数据排序运行时间为：2.35ms
 */
public static void radixSort(int[] array){
    int max=array[0];
    for (int i=1;i<array.length;i++){
        if(array[i]>max){
            max=array[i];  //首先找到数组中的最大数
        }
    }
    int times=(max+"").length(); //得到桶排序的轮数，也就是最大数有几位

    int[][] temp=new int[10][array.length]; //定义10个桶，每个桶的容量为元素总个数
    int t=1; //t表示第几轮
    int n=1; //每过一轮n*10，为了得到相应位的数字
    int num;
    int[] orderTemp=new int[10]; //数组orderTemp[i]用来表示该位是i的数的个数
    while (t<=times){
        for(int i=0;i<array.length;i++){
            num=(array[i]/n)%10;
            temp[num][orderTemp[num]]=array[i];
            orderTemp[num]++;
        }
        int index=0;
        for (int i=0;i<10;i++){
            if(orderTemp[i]>0){ //如果桶中元素大于0
                for (int j=0;j<orderTemp[i];j++){
                    array[index++]=temp[i][j];
                }
            }
            orderTemp[i]=0; //一定要把桶子清空哦！！
        }
        n*=10;
        t++;
    }
}

堆排序

/**
 * 堆排序
 * 1)将待排序的序列构造成一个大顶堆
 * 2)将根节点与末尾元素交换，末尾元素就为最大值
 * 3)剩余数据重新构造成一个大顶堆
 * 4)不断执行操作，完成排序
 * 时间复杂度为O(nlogn)
 */

/**
 * 堆排序算法进行50,000数据排序运行时间为：4.07ms
 */

public static void adjustHeap(int[] arr,int i, int length){ //调整一个以i为顶点的子树
    int temp=arr[i];
    for (int k=i*2+1;k<length;k=k*2+1){
        if(k+1<length && arr[k]<arr[k+1]){
            k++;  //如果左叶子小于右叶子，k就变成右叶子
        }
        if (temp<arr[k]){  //对子树进行调整.  注意！这里要用temp来比较不能用a[i]，我们目的是把temp进行移动
            arr[i]=arr[k];
            i=k;
        } else {
            break;  //说明该子树已然是一个最大堆，直接跳出循环即可
        }
    }
    arr[i]=temp;
}

public static void heapSort(int[] arr){
    for(int i=arr.length/2-1;i>=0;i--){  //i从最后一个非叶子节点开始。位置为i=arr.length/2-1
        adjustHeap(arr,i,arr.length); //该步骤为建立一个最大堆
    }
    for (int i=arr.length-1;i>0;i--){
        int temp=arr[i];
        arr[i]=arr[0];
        arr[0]=temp;
        adjustHeap(arr,0,i);
    }
}

完结撒花~