排序算法

1.冒泡排序

package sort;
//冒泡排序
public class BubbleSort {
    public static void main(String[] args) {

            int[] dong = {3, 9, -1, 10, -2};
            boolean flag=false;//标识变量，表示是否进行交换
            for (int i = dong.length - 1; i > 0; i--) {
                for (int j = 0; j < i; j++) {
                    if (dong[j] > dong[j + 1]) {
                        flag=true;
                        int temp;
                        temp = dong[j];
                        dong[j] = dong[j + 1];
                        dong[j + 1] = temp;
                    }
                }
                if(!flag){//在一趟排序中，一次交换都没有发生过
                    break;
                }else {
                   flag=false;//重置flag，进行下次交换
                }
            }
            for (int i = 0; i < dong.length; i++) {
                System.out.println(dong[i]);
            }
        }
    }

（ps:其中的flag可能在特定的序列中提高冒跑排序的速度的，不写也不影响）

2.插入排序

package sort;

import java.util.Arrays;
//插入排序
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        insertSort(arr);
    }


    //插入排序
    public static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            //定义待插入数
            int insertVal = arr[i];
            int insertIndex = i - 1;//即arr[i]的前面这个数的下标

            //给insertVal找到插入的位置
            //1.insertIndex>=0保证在给insertIndex找插入位置时，不越界
            //2.insertVal<arr[insertIndex]待插入的数，还没有找到插入位置
            //3.就需要将arr[insertIndex]后移
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];//insertIndex后移
                insertIndex--;
            }
            //当退出while循环时，说明位置已经找到，insertIndex+1
            //这里优化代码
            if (insertIndex+1!=i) {
                arr[insertIndex + 1] = insertVal;
                System.out.println(Arrays.toString(arr));
            }
        }
    }
}

3.归并排序

package sort;

import java.util.Arrays;

//归并排序
public class MergetSort {
    public static void main(String[] args) {
        int[]arr={8,4,5,7,1,3,6,2};
        int temp[]=new int[arr.length];
        mergetSort(arr,0,arr.length-1,temp);
        System.out.println(Arrays.toString(arr));
    }


    //分解的方法
    public static void mergetSort(int[]arr,int left,int right,int[] temp){
        if (left<right){
            int mid=(left+right)/2;
            //向左递归进行分解
            mergetSort(arr,left,mid,temp);
            //向右递归分解
            mergetSort(arr,mid+1,right,temp);
            //到合并
            merget(arr,left,mid,right,temp);
        }
    }

//合并的方法
    /**
     *
     * @param arr 排序的原始数组
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引
     * @param right 右边有序序列的初始索引
     * @param temp 做中转的数组
     */
    public static void merget(int[]arr,int left,int mid,int right,int[]temp){
         int i=left;//初始化i，左边有序序列的初始索引
         int j=mid+1;//初始化j，右边有序序列的初始索引
         int t=0;//指向temp数组的当前索引

         //先把左右两边有序的数据按照规则填充到temp数组中
        //直到左右两边的有序序列，有一边处理完毕
        while (i<=mid&&j<=right) {//继续
            //如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
            //即将左边的当前数据拷贝到temp数组中
            //然后t++，i++
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t += 1;
                i += 1;
            } else{//如果左边的有序序列的当前元素，大于右边有序序列的当前元素
                //即将右边的当前数据拷贝到temp数组中
                //然后t++，i++
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }

        }
        //把剩余数据的一边的数据全部填充到temp
        while (i<=mid){//左边还有剩余
            temp[t]=arr[i];
            t += 1;
            i += 1;
        }
        while (j<=right){//右边还有剩余
            temp[t]=arr[j];
            t += 1;
            j += 1;
        }
        //将temp数组的元素拷贝到arr
        //注意，并不是每次都拷贝所有
        t=0;
        int tempLeft=left;
        while (tempLeft<=right){
            arr[tempLeft]=temp[t];
            t+=1;
            tempLeft+=1;
        }
    }
}

4.快速排序

package sort;

import java.util.Arrays;

//快速排序法
public class QuickSort {
    public static void main(String[] args) {
     int[] arr={-9,78,0,23,-567,70};
          quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr,int left,int right){
        int l=left;//左下标
        int r=right;//右下标
        //pirvot 中轴值
        int pirvot=arr[(left+right)/2];
        //while循环的目的是让比pirvot值小的放在左边，大的放在右边
        while (l<r){
            //在pirvot的左边一直找，找到大于等于pirvot值，才退出
            while (arr[l]<pirvot){
                l+=1;
            }
            //在pirvot的右边一直找，找到小于等于pirvot值，才退出
            while (arr[r]>pirvot){
                r-=1;
            }
            //如果l>=r,说明pirvot的左右两边的值，已经按照左边全部小于等于pirvot,右边全是大于等于pirvot
            if (l>=r){
                break;
            }
            //交换
            int temp=0;//临时变量
            temp=arr[l];
            arr[l]=arr[r];
            arr[r]=temp;
            //如果交换完后，发现这个arr[l]==pirvot值相等，前移
            if (arr[l]==pirvot){
                l-=1;
            }
            //如果交换完后，发现这个arr[r]==pirvot值相等，后移
            if (arr[r]==pirvot){
                r+=1;
            }
        }
        //如果l==r，必须l++,r--否则会出现栈溢出
        if (l==r){
            l+=1;
            r-=1;
        }
        //向左递归
        if (left<r){
            quickSort(arr,left,r);
        }
        //向右递归
        if (right>l){
            quickSort(arr,right,l);
        }
    }


}

5.桶排序

package sort;

import java.util.Arrays;

//基数排序（桶排序）
public class RadixSort {
    public static void main(String[] args) {
        int arr[]={53,3,542,748,14,214};
        radixSort(arr);
    }

    //定义一个二维数组，表示十个桶，每个桶就是一个一维数组
    //1.二维数组包含10个一维数组
    //2.为了防止在放入数的时候，数据溢出，则每个一维数组（桶），大小定为arr.length
    //3.基数排序是使用空间换时间的经典算法
    public static void radixSort(int[] arr) {
        //得到数组中的最大位数
        int max=arr[0];//假设第一位数就是最大数
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>max){
                max=arr[i];
            }
        }
        //得到最大数是几位数
        int maxLength=(max+"").length();

        int[][] bucket = new int[10][arr.length];



        //为了记录每个桶中，实际存放多少数据，我们定义一个一维数组来记录各个桶的每次放入的数据个数
        //bucketElementCount[0],记录的就是bucket[0]桶的放入数据个数
        int[] bucketElementCounts=new int[10];


          //这里使用循环处理
        for (int i=0,n=1;i<maxLength;i++,n*=10){
            //针对每个元素相应位进行排序处理：第一位是个位，第二位是十位，第三位是百位...
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素的对应位的数
                int digitOfElement=arr[j]/n%10;
                //放入到对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
                bucketElementCounts[digitOfElement]++;
            }
            //按照每个桶的顺序（一维数组的下标依次取出数据，放入原来数据）
            int index=0;
            //遍历每一个桶，并将桶中的数据，放入原数组
            for (int k=0;k<bucketElementCounts.length;k++){
                //如果桶中，有数据，我们才放入到原数组
                if (bucketElementCounts[k]!=0){
                    //循环该桶即第k个桶，放入
                    for (int l=0;l<bucketElementCounts[k];l++){
                        //取出元素放入arr
                        arr[index++]=bucket[k][l];

                    }

                }
                //第一轮处理后，需要把bucketElementCounts[k]=0！！！
                bucketElementCounts[k]=0;
            }
            System.out.println(Arrays.toString(arr));
        }

6.选择排序

package sort;
//选择排序
public class SelectSort {

        public static void main(String[] args) {
            int[] dong = {1, 9, 7, 8,2,6,5,3};
            for (int i = 0; i <dong.length-1 ; i++) {
                int min = i;

                for (int j = i+1 ; j < dong.length; j++) {

                    if (dong[min] > dong[j]) {
                        min = j;
                    }
                }
                if (min != i) {
                    int temp;
                    temp=dong[i];
                    dong[i]=dong[min];
                    dong[min]=temp;
                }
            }
            for (int i = 0; i <dong.length ; i++) {
                System.out.println(dong[i]);
            }
        }
}

7.希尔排序

package sort;

import java.util.Arrays;

//希尔排序
public class ShellSort {
    public static void main(String[] args) {



        int[] arr={8,9,1,7,2,3,5,4,6,0};
        shellSort(arr);
        shellSort2(arr);
    }

    public static void shellSort(int[] arr) {
        int temp = 0;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {

            for (int i = gap; i < arr.length; i++) {
                //遍历各组的所有元素（共5组，每组2个元素），步长5
                for (int j = i -gap; j >= 0; j -=gap) {
                    if (arr[j] > arr[j + gap]) {//如果当前的元素大于加上步长的那个元素，就交换
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
            System.out.println(Arrays.toString(arr));