对于面试BAT需要掌握的排序算法，用Java语言打出

第一个：冒泡排序(Bubble_sort)

对于冒泡排序可谓最简单了，但是有时候会有很多人不理解它的排序思想，而忘记它的打法。

举个例子int []array = {5,1,3,2,4}；冒泡排序是排array.length-1次躺序，为什么？

因为冒泡排序是稳定排序，而且每一次趟序都能把一个数字放在最终固定的位置上，所以，当排序到最后一个数字的时候就不用再排序了。所以总共排array.length-1次趟序。

冒泡排序的每一次趟序都是从0号位索引开始依次往后两两比较，且每一次排好一个数字，就减少一个数字的比较，所以在第二个for循环中会出现for(int j=0;j<array.length-1-i;j++)的情况。

两两比较的时候，判断前面的数字大于后面的数字时进行两两交换。

冒泡排序代码如下：

package sort_algorithm;

public class Bubble_sort
{
    public static void main(String[]args)
    {
        int[]array = {6,1,7,3,4,2,5,10,9,8};
        for(int i=0;i<array.length-1;i++)
        {
            for(int j=0;j<array.length-1-i;j++)
            {
                if(array[j]>array[j+1])
                {
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        for(int i:array)
        {
            System.out.print(i+" ");
        }
        System.out.println();
    }
}
 

第二个：归并排序(MergeSort)

很多人都觉得归并排序原理很简单，但是不知道代码该怎么打，觉得代码应该很复杂吧，毕竟是归并嘛。

归并排序整体的思想是递归，将一个数组不断从中间分成两半，然后比较排序，用新的排出顺序来的数组覆盖老数组，直至排号序，先归并再排序的思想进行递归调用。而且归并的递归有如折半查找和折半排序。

package sort_algorithm;

public class MergeSort
{
    public static void main(String[]args)
    {
        int[]array = {6,1,7,3,4,2,5,10,9,8};
        sort(array,0,array.length-1);
        for(int i:array)
            System.out.print(i+" ");
        System.out.println();
    }
    public static void sort(int[]a,int low,int high)
    {
        int mid = (low+high)/2;
        if(low<high)
        {
          sort(a,low,mid);
          sort(a,mid+1,high);
          merge(a,low,mid,high);
        }
    }
    public static void merge(int[]a,int low,int mid,int high)
    {
        int i=low;
        int j=mid+1;
        int []temp = new int[high-low+1];
        int index=0;
        while(i<=mid&&j<=high)
        {
          if(a[i]>a[j])
          {
              temp[index++]=a[j++];
          }
          else if(a[i]<a[j])
          {
              temp[index++]=a[i++];
          }
        }
        while(i<=mid)
        {
         temp[index++]=a[i++];
        }
        while(j<=high)
        {
            temp[index++]=a[j++];
        }
        for(int x=0;x<temp.length;x++)
        {
            a[x+low]=temp[x];
        }
    }
}

第三个：快速排序(quickSort)

快速排序将第一个数字为关键字key，选择一个 i 索引和一个 j 索引，i 从头往尾遍历，寻找第一个大于key的值，j 从尾往头遍历寻找第一个小于key的值。然后再i<j的时候交换，当i>j后，将array[j]于array[key]交换，将该数组以原来的key为分界点分为两个数组，然后进行重复以上的操作，进行递归调用

源代码如下：

package sort_algorithm;

public class QuickSort
{
    public static void main(String[]args)
    {
        int[]array = {6,1,7,3,4,2,5,10,9,8};
        quickSort(array);
        for(int i:array)
        {
            System.out.print(i+" ");
        }
        System.out.println();
    }
    
    public static void quickSort(int[]a)
    {
      quickSort(a,0,a.length-1);
    }
    public static void quickSort(int[]a,int low,int high)
    {
        if(low>high)
            return;
        int i = low;
        int j = high;
        int key = a[low];
        while(i<j)
        {
            while(i<j&&a[j]>key)
            {
                j--;
            }
            while(i<j&&a[i]<=key)
            {
                i++;
            }
            if(i<j)
            {
                int p = a[i];
                a[i] = a[j];
                a[j] = p;
            }
        }
        int p = a[j];
        a[j] = a[low];
        a[low] = p;
        quickSort(a,low,j-1);
        quickSort(a,j+1,high);
    }
}

第四个：简单选择排序

简单选择排序，是将先将第一个元素作为最小元素，然后向后遍历数组，寻找出一个最小的且小于第一个元素的数字，进行交换，然后将数组中第二个数字再次作为最小元素，然后向后遍历所有数字，寻找一个最小的且小于第二个数字的数与其交换，然后以此类推，往后遍历。

源代码如下：

package sort_algorithm;

public class Select_sort
{
    public static void main(String[]args)
    {
        int[]array = {6,1,7,3,4,2,5,10,9,8};
        for(int i=0;i<array.length-1;i++)
        {
            for(int j=i+1;j<array.length;j++)
            {
                if(array[i]>array[j])
                {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
        for(int i:array)
        {
            System.out.print(i+" ");
        }
        System.out.println();
    }
    
    
}

第五个：简单插入排序

简单插入排序形象的解释是这样的 5，2，3，1，4；

（5）2，3，1，4

（2，5）3，1，4

（2，3，5）1，4

（1，2，3，5），4

（1，2，3，4，5）

解释完毕。

源代码如下：

package sort_algorithm;

public class Simple_insertion_sort
{
    public static void main(String[]args)
    {
        int[]array = {6,1,7,3,4,2,5,10,9,8};
        for(int i=0;i<array.length-1;i++)    
        {
            for(int j=i+1;j>0;j--)
            {
                if(array[j]<array[j-1])
                {
                    int temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                }
            }
        }
        for(int i:array)
        {
            System.out.print(i+" ");
        }
        System.out.println();
    }
}

第六个：希尔排序

希尔排序是难化的简单插入排序，一般取数组长度一半作为初始化标准值的gap，以gap为步长间隔进行数组中数字的排序，gap每次以除2 的方式缩小，知道缩小到步长为1。在数组中步长间隔为gap的数字直接进行比较和排序，随着gap的逐渐缩小，数组直接的组数也也越来越小，知道gap=1后，数组排序完毕

源代码如下：

package sort_algorithm;

public class Shell_sort
{
    public static void main(String[]args)
    {
        int[]array = {6,1,7,3,4,2,5,10,9,8};
        for(int gap = array.length/2;gap>0;gap/=2)
        {
            for(int i=gap;i<array.length;i++)
            {
                int j = i;
                while(j-gap>=0&&array[j-gap]>array[j])
                {
                    int temp = array[j-gap];
                    array[j-gap] = array[j];
                    array[j] = temp;
                    j-=gap;
                }
            }
        }
        for(int i:array)
            System.out.print(i+" ");
        System.out.println();
    }
}