标签：八大 temp nums int 算法 return 排序 left

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。