Java语言实现六种排序算法

1.冒泡排序

实现思路：外层循环控制比较的轮数，内层循环从下标0开始，进行和后一位值的两两比较，并交换顺序，直到外层循环完成后，冒泡排序完成。

public class Bubble {
    public static void main(String[] args) {
        int arr[] = new int[]{1, 7, 4, 8, 9, 2, 6, 3};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void sort(int arr[]) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1; j++) {
                if (arr[j + 1] < arr[j]) {
                    int temp =arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
}

2.选择排序

简单思想：先对下标0当做最小标识位，顺序寻找直到找到数组中最小的值，再将该值的下标与最小标识位进行交换，并交换对应的值；并对标志位进行自加操作，继续找标识位及标识位后最小的值，直到最小标识位成为数组中最后一个下标，则排序结束。

public class SelectSort {
    public static void main(String[] args) {
int arr[]=new int []{4,5,2,6,1,0,3};
sekectSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sekectSort(int arr[]){
        for(int i=0;i<arr.length;i++){
            int minIndex=i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[minIndex]>arr[j]){
                minIndex=j;
                }
            }
            //将每次遍历过程中最小的数的下标交换
            int flag=arr[i];
            arr[i]=arr[minIndex];
            arr[minIndex]=flag;

        }
    }
}

冒泡排序和选择排序的区别：

1.冒泡排序是比较相邻位置的两个数；选择排序是按顺序比较，找最大值或者最小值；

2.冒泡排序每一轮比较后，位置不对都需要换位置，选择排序每一轮比较都只需要换一次位置；

3.冒泡排序是通过数去找位置，选择排序是给定位置去找数；

3.插入排序

简单思想：可以看做是打扑克牌时整牌的过程，以左边第一张牌为基准，依次将右边的各张牌牌按大小进行插入整理。外层循环控制比较的次数，内层循环进行对应牌数量内的内部排序。

public class Insert {
    public static void main(String[] args) {
        int arr[]=new int []{0,9,5,2,5,3,2,1,7,8};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));

    }
    public static void insertSort(int arr[]){
        for(int i=1;i<arr.length;i++){
            for(int j=i;j>0;j--){
                if(arr[j]<arr[j-1]){
                    int temp=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;
                }
            }
        }
    }
}

4.希尔排序

简单思想：希尔排序是直接插入排序算法的一种更高版本的改进版本。

1. 把记录按步长分组，对每组记录采用直接插入排序方法进行排序；
2. 随着步长逐渐减小，所分成的组包含的记录越来越多；
   当步长值减小到1时，整个数据合成一组，构成一组有序记录，完成排序；

public class Shell {
    public static void main(String[] args) {
        int arr[]=new int[]{2,9,5,3,76,98,9,0,4,1,7};
shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void shellSort(int arr[]){
       for(int h=arr.length/2;h>0;h/=2){
           for(int i=h;i<arr.length;i++){
               for(int j=i-h;j>=0;j-=h){
                   if(arr[j]>arr[j+h]){
                           int temp=arr[j];
                           arr[j]=arr[j+h];
                           arr[j+h]=temp;
                   }
               }
           }
       }

    }
}

5.快速排序

public class Quick {
    public static void main(String[] args) {
        int arr[] = new int[]{5, 7, 1, 2, 9, 3, 8, 6, 0};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int arr[], int start, int end) {
        if (start < end) {
            int stard = arr[start];
            int low = start;
            int high = end;
            while (low < high) {
                while(low<high&&arr[high]>stard){
                    high--;
                }
                arr[low]=arr[high];
                while(low<high&&arr[start]<=stard){
                    low++;
                }
                arr[high]=arr[low];
            }
            arr[low] = stard;
            //递归
            quickSort(arr, start, low);
            quickSort(arr, low + 1, end);


        }
    }
}

6.归并排序

public class Test {
    public static void main(String[] args) {
        int arr[] = new int[]{1,2,6,3,4,8,0};
 mergeSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));

    }

//此方法用于对middle前后已经分别有序的两部分进行排序，相当于最内层的排序，需要递归使用该方法达到整体有序
    public static void merge(int arr[],int left,int middle,int right) {
        //用于存储归并后的临时数组
        int temp[] = new int[right - left + 1];
        int index = 0;
        //将原数组拆分为两部分，记录第一部分中需要遍历的下标
        int i = left;
        //记录第二部分中需要遍历的下标
        int j = middle + 1;
        //遍历两个数组，两两比较并取出较小的那个，放在临时数组中
                   while (i <= middle && j <= right) {
                if (arr[i] <=arr[j]) {
                    temp[index] = arr[i];
                    i++;

                } else {
                    temp[index] = arr[j];
                    j++;
                    }
                       index++;
            }
            //处理未参与比较的数据
            while (j <=right) {
                temp[index]=arr[j];
                j++;
                index++;
            }
            while(i<=middle){
                       temp[index]=arr[i];
                i++;
                index++;
            }
            //把临时数组中的元素重新存进原数组
            for(int k=0;k<temp.length;k++){
                arr[k+left]=temp[k];
            }
        }
//递归
        public static void mergeSort(int arr[],int left,int right) {
            int middle = (right + left) / 2;
            if (left < right) {
                mergeSort(arr, left, middle);
                mergeSort(arr, middle + 1, right);
                merge(arr, left, middle, right);
            }
        }
    }