排序的分类及部分实现

　　根据在排序过程中涉及的存储器不同，可将排序方法分为两大类：内部排序和外部排序。

　　内部排序是指待排序列完全存放在内存中所进行的排序过程，适合不太大的元素序列。

　　外部排序指的是大文件的排序，待排序的文件无法一次装入内存，将待排序的记录存储再外存储器上，需要在内存和外部存储器之间进行多次数据交换，已达到排序整个文件的目的。

　　根据有序序列长度增加所用策略不同，可将内部排序方法分为5类：交换排序、选择排序、插入排序、归并排序和基数排序。其中交换排序、插入排序和选择排序是一个逐步扩大记录的有序序列长度的过程。

　　交换排序是对无序区中记录的关键字两两进行比较，若逆序交换，直到关键字之间不存在逆序为止。冒泡排序和快速排序是交换排序中最典型的两个方法。

　　简单选择排序和堆排序是选择排序中最典型的两个方法。

　　直接插入排序和希尔排序是插入排序中最典型的两个方法。

　　归并排序是不断将两个或两个以上有序区合并成一个有序区，直到全部记录有序。

 　　可分为稳定排序与不稳定排序两种：

　　稳定排序有冒泡排序、直接插入排序、归并排序、基数排序；

　　不稳定排序有选择排序、快速排序、希尔排序、堆排序

　　几种简单排序的Java实现

　　1、冒泡排序

public class BubblingSort
{
    public static void main(String[] args)
    {
        int[] a = {6,5,3,2,0};
        sort(a);
    }
    
    /**
     * 冒泡排序
     * 复杂度最优为n
     * 最差为n平方
     */
    private static void sort(int[] a)
    {
        for(int i = 0; i < a.length; i ++)
        {
            boolean flag = true;    //优化，设置标识
            for(int j = i + 1; j < a.length; j ++)
            {
                if(a[i] < a[j])        //前后两个元素比较
                {
                    int temp = a[i];    //交换
                    a[i] = a[j];
                    a[j] = temp;
                    flag = false;        //若有交换，标识设为false，表示数组还不是有序数组
                }
            }
            if(flag)                    //若一轮比较之后，flag为true，即未进行过交换，证明数组已是有序，跳出循环
            {
                break;
            }
        }
        for(int i = 0; i < a.length; i ++)
        {
            System.out.print(a[i] + "  ");
        }
    }
}

 

　　

　　2、插入排序

public class InsertSort 
{
    public static void main(String[] args)
    {
        int[] a = {2,5,6,0,3};
        sort(a);
    }
    
    /**
     * 插入排序
     * 复杂度最优为n
     * 最差为n平方
     */
    private static void sort(int[] a)
    {
        for(int i = 0; i < a.length - 1; i ++)
        {
            if(a[i] > a[i + 1])        //若当前值大于下一个值，进行插排（'>'为正序，'<'为倒序）
            {
                int x = a[i + 1];    //先将下标为i+1的值存入临时变量x中
                int j = i + 1;        //设置一个将数组值后移的下标j，j为当前进行判断的后一位下标（j之前可看成一个有序数组）
                /**
                 * 将j之前的有序数组后移，直到临时变量的值找到有序数组中合适的位置
                 */
                do                    
                {
                    j --;            
                    a[j + 1] = a[j];
                }while(j > 0 && x < a[j - 1]);
                a[j] = x;    //将临时变量x的值放入有序数组的合适位置
            }
        }
        for(int i = 0; i < a.length; i ++)
        {
            System.out.print(a[i] + "  ");
        }
    }
}

 

　　3、快速排序　

public class QuickSort
{
    public static void main(String[] args)
    {
        int[] a = {6,5,3,2,0};
        sort(a,0,a.length - 1);
        for(int i = 0; i < a.length; i ++)
        {
            System.out.print(a[i] + "  ");
        }
    }

    private static void sort(int[] a, int left, int right)
    {
        if(left >= right)    //如果左边的数组大于或等于就代表已经整理完成一个组了
        {
            return;
        }
        int i = left;
        int j = right;
        int key = a[left];
        while(i < j)    //控制在当组内寻找一遍
        {
            /**
             * 而寻找结束的条件就是：
             * 1、找到一个小于或者大于key的数（大小取决于你想升序还是降序）
             * 2、没有符合的i与j相遇
             */
            while(i < j && key <= a[j])
            {
                j --;    //向前寻找
            }
            a[i] = a[j];    //找到一个这样的数后就把他赋给前面的被拿走的i的值（如果第一次循环且key是a[0],那么就是给key)
            while(i < j && key >= a[i])
            {
                i ++;
            }
            a[j] = a[i];
            a[i] = key;
        }
        sort(a,left,i -1);
        sort(a,i + 1, right);
    }
}

 

　　4、选择排序

public class SelectSort
{
    public static void main(String[] args)
    {
        int[] a = {0,2,3,5,6};
        sort(a);
    }

    
    /**
     * 选择排序
     * 平均复杂度为n平方
     */
    private static void sort(int[] a)
    {
        for(int i = 0; i < a.length - 1; i ++)
        {
            int k = i;        //设置标识
            for(int j = i + 1; j < a.length; j ++)
            {
                if(a[k] > a[j])    //将下标为i的元素与其后的元素比较
                {
                    k = j;        //k记录最小（大）值的下标
                }
            }
            if(k != i)            //若k不等于当前下标，进行交换
            {
                int temp = a[k];
                a[k] = a[i];
                a[i] = temp;
            }
        }
        for(int i = 0; i < a.length; i ++)
        {
            System.out.print(a[i] + "  ");
        }
    }
}