Java实现八大排序算法

本文对常见的排序算法进行了总结。

常见排序算法如下：

• 直接插入排序
• 希尔排序
• 简单选择排序
• 堆排序
• 冒泡排序
• 快速排序
• 归并排序
• 基数排序

它们都属于内部排序，也就是只考虑数据量较小仅需要使用内存的排序算法，他们之间关系如下：

稳定与非稳定:

如果一个排序算法能够保留数组中重复元素的相对位置则可以被称为是稳定的。反之，则是非稳定的。

class Solution {
    public int[] sortArray(int[] nums) {
        //return sort(nums,0,nums.length-1);  //快排
        //return heapsort(nums);   //堆排序
        //return Pob(nums);   //冒泡排序
        //return insert(nums);  //插入排序
        return shell(nums);   //希尔排序
        //return  SimpleSelect(nums);  //简单选择
    }
    //快排
    public int[] sort(int[] nums,int low,int high)
    {
        if(low>=high)
        {
            return nums;
        }
        int left=low;
        int right=high;
        int privot=nums[left];
        while(left<right)
        {
            while(left<right&&privot<=nums[right])
            {
                right--;
            }
            nums[left]=nums[right];
            while(left<right&&privot>=nums[left])
            {
                left++;
            }
            nums[right]=nums[left];
        }
        nums[left]=privot;
        sort(nums,low,left-1);
        sort(nums,left+1,high);
        return nums;
    }
    //堆排序
    public int[] heapsort(int[] a)
    {
        for(int i=a.length-1;i>0;i--)
        {
            adjust(a,i);
            int temp=a[0];
            a[0]=a[i];
            a[i]=temp;
        }
        return a;
    }
    public int[] adjust(int[] a,int n)
    {
        for(int i=(n-1)/2;i>=0;i--)
        {
            int left=2*i+1;
            if(left!=n&&a[left]<a[left+1])
            {
                left++;
            }
            if(a[i]<a[left])
            {
                int temp=a[i];
                a[i]=a[left];
                a[left]=temp;
            }
        }
        return a;
    }
    //冒泡排序
    public int[] Pob(int[] a)
    {
        for(int i=0;i<a.length;i++)
        {
            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;
                }
            }
        }
        return a;
    }
    //插入排序
   public int[] insert(int[] a)
   {
       for(int i=0;i<a.length;i++)
       {
           int temp=a[i];
           int j=i-1;
           while(j>=0&&a[j]>temp)
           {
               a[j+1]=a[j];
               j--;
           }
           a[j+1]=temp;
       }
       return a;
   }
    //简单选择
    public int[] SimpleSelect(int[] a)
    {
        for(int i=0;i<a.length;i++)
        {
            int min=i;
            for(int j=i+1;j<a.length;j++)
            {
                if(a[j]<a[min])
                {
                    min=j;
                }
            }
            if(min!=i)
            {
                int temp=a[i];
                a[i]=a[min];
                a[min]=temp;
            }
        }
        return a;
    }
    //希尔
    public int[] shell(int[] a)
    {
        for(int dk=a.length/2;dk>=1;dk=dk/2)
        {
            for(int i=dk;i<a.length;i++)
            {
                int temp=a[i];
                int j;
                for(j=i-dk;j>=0&&temp<a[j];j=j-dk)
                {
                    a[j+dk]=a[j];
                }
                a[j+dk]=temp;
            }
        }
        return a;
    }
}

从时间复杂度来说：

• 平方阶O(n²)排序：各类简单排序：直接插入、直接选择和冒泡排序
• 线性对数阶O(nlog₂n)排序：快速排序、堆排序和归并排序
• O(n1+§))排序，§是介于0和1之间的常数：希尔排序
• 线性阶O(n)排序：基数排序，此外还有桶、箱排序

论是否有序的影响：

• 当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；
• 而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；
• 原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

标签：八大,temp,nums,int,算法,return,排序,left
来源： https://www.cnblogs.com/Liuyunsan/p/15935757.html