java基础排序

java排序-基础排序

原创  2018年04月12日 16:30:04

• 标签：
• java排序

• 6

通过代码实现java排序的基础排序算法:

1 冒泡排序

package com.sort.base;

import com.sort.util.PrintUtil;

/**
 * Created by jack on 2018/3/24.
 * 冒泡排序
 * 1 时间复杂度:T(n)=O(n*n)
 * 2 空间复杂度:O(n)=O(1)
 * 算法流程：
 *  外层循环，遍历迭代次数,变量从0开始
 *  内层循环,遍历比较当前值和每个值的大小,比自己大的就进行交换
 * 算法本质：最小的值,永远都冒在最上面
 */
public class BubbleSort {

    public static int[] bubbleSort(int[]array){
        int temp;
        //比较多少次
        for (int i=0;i<array.length;i++){
            //找到比自己大的 就替换
            for (int j=array.length-1;j>i;j--){
                //当前值小于下一个值 就进行交换
                if (array[j]<array[j-1]){
                    //当前值赋值与temp
                    temp = array[j];
                    //当前值和下一个值进行交换
                    array[j]=array[j-1];
                    //temp和下一个值进行交换
                    array[j-1]=temp;
                }
            }
            System.out.print("第"+i+"次,排序");
            int []arr =array;
            PrintUtil.printStr(arr);
            System.out.println();
        }
        return array;
    }

    public static void main(String[] args) {
        int [] array ={34,23,1,2};
        System.out.println("原始数组");
        PrintUtil.printStr(array);
        System.out.println();

        System.out.println("排序之后的数组");
        //bubbleSort(array);
        PrintUtil.printStr(bubbleSort(array));
    }
}

2 插入排序

package com.sort.base;

import com.sort.util.PrintUtil;

/**
 * Created by jack on 2018/3/24.
 * 插入排序
 * 算法流程：
 *  每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止
 * 算法本质：
 *  遇到比当前值小的就进行插入
 * 算法复杂度：
 *  时间复杂度：O(n^2)
 *  空间复杂度：O(1)
 */
public class InsertSort {

    public static int[] insertSort(int[] arr) {
        int tmp ;
        int j;

        for(int i = 1; i < arr.length; i++) {
            tmp = arr[i];
            j = i;
            while(j > 0 && arr[j-1] >=tmp) {
                arr[j] = arr[j - 1];
                j--;
            }
            arr[j] = tmp;
        }
        return arr;
    }




    public static void main(String[] args) {
        int []arr={34,23,1,2};
        System.out.println("原始数组");
        PrintUtil.printStr(arr);
        System.out.println();

        System.out.println("排序之后的数组");
        PrintUtil.printStr(insertSort(arr));
    }
}

3 选择排序

package com.sort.base;

import com.sort.util.PrintUtil;

/**
 * Created by jack on 2018/3/24.
 * 选择排序
 * 算法流程：
 *  从未排好的部分的第一个作为最小（最大）的，然后依次和剩余的比较，如果有更小（更大）的，记下下标
 *  以此作为新的最小（最大）值，继续比较，一趟结束后，可以得到最小值。
 * 算法本质：
 *  K永远指向最小的值,j是随机变量一直在移动
 *
 * 算法复杂度
 *  时间复杂度：O(n^2)
 *  空间复杂度：O(1)
 */
public class SelectSort {

    private static int[] selectSort(int[]arr){
        int temp;
        int k;
        for (int i=0;i<arr.length-1;i++){
            k=i;
            for (int j = i; j <arr.length ; j++) {
                if (arr[j]<arr[k]){
                    k=j;
                }
            }
            temp=arr[i];
            arr[i]=arr[k];
            arr[k]=temp;
        }
        return arr;
    }
    public static void main(String[] args) {
        int []arr={34,23,1,2};
        System.out.println("原始数组");
        PrintUtil.printStr(arr);
        System.out.println();

        System.out.println("排序之后的数组");
        //bubbleSort(array);
        PrintUtil.printStr(selectSort(arr));
    }
}

4 希尔排序

package com.sort.base;

import com.sort.util.PrintUtil;

/**
 * Created by jack on 2018/3/24.
 * 希尔排序
 *  算法流程:和插入排序类似,只不过增加了间隔大小
 *  算法本质:增大插入排序的间隔大小，减少比较次数
 *  算法复杂度：
 *    时间复杂度：
 *          最好的：O(nlogn)
 *          最坏的:O(n*n)
 */
public class ShellSort {

    public static int[]shellSort(int[]arr){
        int h=1;
        int j;
        int temp;

        while(h<arr.length){
            h=3*h+1;
        }

        System.out.println("max h:"+h);

        while(h>0){
            for (int i = h; i <arr.length ; i++) {
                j=i;
                temp=arr[i];
                //跨间隔进行插入排序
                while(j>h-1 &&arr[j-h]>=temp){
                    arr[j]=arr[j-h];
                    j-=h;
                }
                arr[j]=temp;
            }
            //递减插入间隔
            h=(h-1)/3;
            System.out.println(" h:"+h);
        }

        return arr;
    }

    public static void main(String[] args) {
        int []arr={34,23,1,2,4,6,7,5,9,8};
        System.out.println("原始数组");
        PrintUtil.printStr(arr);
        System.out.println();

        System.out.println("排序之后的数组");
        //bubbleSort(array);
        PrintUtil.printStr(shellSort(arr));
    }
}