五种排序算法（冒泡排序、选择排序、直接插入排序、希尔排序、快速排序）...

package cn.dzp.flyroc.day01;

import java.util.Arrays;

public class Sort {

    public static void main(String[] args){

        //选择排序
        int[] arr ={43,6,22,54,66,0};
        System.out.println("这是排序前的结果："+Arrays.toString(arr));
        selectSort(arr);
        System.out.println("------------------------------------------");

        //冒泡排序
        int[] arr2 ={43,5,32,2,1,63,0};
        System.out.println("这是排序前的结果："+Arrays.toString(arr2));
        bubbleSort(arr2);
        System.out.println("-------------------------------------------");

        //直接插入排序
        int[] arr3 ={32,5,77,2,0,9,99};
        System.out.println("这是排序前的结果："+Arrays.toString(arr3));
        insertSort(arr3);
        System.out.println("--------------------------------------------");

        //希尔排序
        int[] arr4 ={43,54,22,1,88,543};
        System.out.println("这是排序前的结果："+Arrays.toString(arr4));
        shellSort(arr4);
        System.out.println("--------------------------------------------");

        //快速排序
        int[] arr5 ={43,64,22,23,634,123};
        System.out.println("这是排序前的结果："+Arrays.toString(arr5));
        quickSort(arr5, 0, arr5.length-1);
        System.out.println("这是快速排序后的结果："+Arrays.toString(arr5));
    }

    //选择排序
    public static void selectSort(int[] arr){

        for (int i = 0; i < arr.length-1; i++){     //定义外循环，循环的次数，i是没轮种与其他元素比较的值
            for (int j = i +1; j < arr.length; j++){        //定义内循环，与i进行比较

                if (arr[j] < arr[i]){       //比较
                    swap(arr, j, i);        //交换两值
                }
            }
        }
        System.out.println("这是排序选择排序后的结果："+ Arrays.toString(arr));
    }

    //冒泡排序
    public static void bubbleSort(int[] arr2){

        for (int i = 0; i < arr2.length; i++){      //控制循环的次数，从索引为0开始遍历
            for (int j = 0; j < arr2.length-1-i; j++){      //控制每轮两两比较的次数

                if (arr2[j] > arr2[j+1]){       //元素比较
                    swap(arr2, j+1, j);     //元素交换
                }
            }
        }
        System.out.println("这是冒泡排序后的结果："+Arrays.toString(arr2));
    }

    //直接插入排序
    public static void insertSort(int[] arr3){

        int temp;       //定义待插入的元素
        int i;
        for (i = 1; i < arr3.length; i++){      //遍历数组

            temp = arr3[i];     //初始化待插入的元素
            int j;      //定义待插入元素之前的所有元素

            for (j = i-1; j>=0; j--){       //遍历待插入之前的所有元素

                if (arr3[j] > temp){        //待插入元素与之前元素比较
                    arr3[j+1] = arr3[j];
                }else {
                    break;
                }
            }
            arr3[j+1] = temp;
        }
        System.out.println("这是直接插入排序后的结果："+Arrays.toString(arr3));
    }

    //希尔排序
    public static void shellSort(int[] arr4){

        for (int gap = arr4.length/2; gap > 0; gap/=2) {        //定义增量
            for (int i = gap; i < arr4.length; i++) {       //从第gap元素开始遍历数组

                int j = i;      //定义第一个需要比较元素的索引值

                while (j - gap >= 0 && arr4[j] < arr4[j - gap]) {       //元素比较
                    swap(arr4, j-gap, j);       //元素交换
                    j -= gap;
                }
            }
        }
        System.out.println("这是希尔排序后的结果："+Arrays.toString(arr4));
    }

    //快速排序
    public static void quickSort(int[] arr5, int low, int high){        //定义数组，数组的第一个元素的索引值，数组的最后一个元素的索引值

        int start = low;        //定义从前往后的基准值的索引值
        int end = high;     //定义从后往前基准值的索引值
        int key = arr5[start];      //定义基准值为第一个元素

        while (end > start){        //判断end > start ,若是等于就说明基准值左边元素均小于右边元素

            //从后往前遍历
            while (end > start && arr5[end] > key){     //判断后边的元素是否大于基准值，继续寻找
                end--;
            }
            if (arr5[end] < key){       //找到了比基准值小的元素
               swap(arr5, start, end);
            }

            //从前往后遍历
            while (end > start && arr5[start] < key){       //判断前边的元素是否小于基准值，继续寻找
                start++;
            }
            if (arr5[start] > key){     //找到了比基准值大的元素
               swap(arr5, start, end);
            }
        }

        //递归
        if (low < start){
            quickSort(arr5, low, start-1);
        }
        if (end < high){
            quickSort(arr5, end+1, high);
        }
    }

    //交换
    public static void swap(int[] arr, int a, int b){

        int temp = arr[a];
        arr[a]= arr[b];
        arr[b] = temp;
    }
}

 

转载于:https://my.oschina.net/u/4169647/blog/3084901