常见排序算法(Java版)

常见排序算法：冒泡、插入、选择、shell、二分查找(Java版)

1. 冒泡排序

冒泡排序是一种简单直观的排序算法。比较相邻的元素，如果第一个比第二个大，就交换他们两个。对每一对相邻元素作相同的工作，从开始第一对到结尾的最后一对。这步做完，最后的元素会是最大的数。

代码实现

//冒泡排序

public class BubblingDemo {
    public static void main(String[] args){
        int[] a = {3,55,84,95,66,5,8,94,76,45,50,100};
        int temp;

        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] > a[j+1]){
                    temp = a[j];
                   a[j] = a[j+1];
                   a[j+1] = temp;
                }
            }
        }

        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

2.插入排序

插入排序的原理类似于打扑克牌时的整理牌，是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应的位置并插入。
步骤：将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。从头到尾一次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置（如果待插入元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面）

代码实现

//插入排序

public class InsertDemo {
    public static void main(String[] args) {

        int[] a = {3,55,84,95,66,5,8,94,76,45,50,100};

        for (int i = 1; i < a.length ; i++) {
            for (int j = i-1; j >= 0 ; j--) {
                if (a[i] < a[j]){
                    a[j+1] = a[j];
                    a[j] = a[i];
                }
            }
        }

        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }

    }
}

3.选择排序

选择排序是一种简单直观的排序算法，无论什么数据进去都是O(n²)的时间复杂度。所以用到它的时候，数据规模越小越好。
步骤：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。重复寻找步骤，直到所有元素均排序完毕

代码实现：

//选择排序

public class ChooseDemo {
    public static void main(String[] args){

        int[] a = {3,55,84,95,66,5,8,94,76,45,50,100};
        int temp;

        for (int i = 0; i < a.length; i++) {
            int index = i;
            for (int j = i+1; j < a.length - 1; j++) {
                if (a[index] > a[j]){
                    index = j;
                }
            }
            temp = a[i];
            a[i] = a[index];
            a[index] = temp;
        }

        for(int b : a){
            System.out.print(b + " ");
        }

    }
}

4. shell排序(希尔排序)

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本，但希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的

• 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
• 但插入排序一般来说时低效的，因为插入排序每次只能将数据移动一位；

希尔排序的基本思想是：先将整个待排的记录序列分割成为若干序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

步骤：

• 选择一个增量序列t1,t2,…,tk,其中t1 > tj，tk = 1；
• 按增量序列个数k，对1序列进行k趟排序
• 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序，仅增量因子为1时，整个序列作为一个表来处理，表长度即为整个序列的长度。
  

代码实现：

//希尔排序

public class ShellDemo {
    public static void main(String[] args) {

        int[] a = {3,55,84,95,66,5,8,94,76,45,50,100};
        int temp;

        int n = a.length;

        for (int gap = n/2; gap > 0; gap/=2) {
            for (int i = gap; i < n; i++) {
                if (a[i] < a[i-gap]){
                    temp = a[i];
                    int j;
                    for (j = i; j >= gap && a[j - gap] >temp ; j-=gap) {
                        a[j] = a[j-gap];
                    }
                    a[j] = temp;
                }
            }
        }

        for(int b : a){
            System.out.print(b + " ");
        }

    }
}

5. 二分查找

二分查找是一种在有序数组中查找某一特定元素的搜索算法，
步骤：搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

代码实现：

//二分查找
//引键盘输入的包
import java.util.Scanner;

public class BinaryDemo {
    public static void main(String[] args){

        int[] a = {3,5,8,45,50,55,66,76,84,94,95,100};

        int left = 0;
        int right = a.length - 1;
        boolean flag = false;
        //键盘输入
        Scanner scanner = new Scanner(System.in);
        int b = scanner.nextInt();


        while (left <= right) {

            int mid = left + (right - left) / 2;


                if ( b == a[mid] ){
                    flag = true;
                    mid += 1;
                    System.out.println(b + "在数组第" + mid +"位置");
                    break;
                } else if (b > a[mid]) {
                    left = mid + 1;
                }else {
                    right = mid - 1;
                }

        }
        if (!flag){
            System.out.println("该数组没有" + b);
        }

    }
}