• 排序算法汇总


    (从小到大排序)

    1.冒泡排序

      冒泡排序类似于小鱼吐泡泡,大的泡泡往上走。每一趟排序都将当前排序范围中最大的元素放到最右侧的位置。

      对 4 5 6 3 2 1 进行冒泡排序:

      第一趟:4 5 3 2 1 6

      第二趟:4 3 2 1 5 6

      第三趟:3 2 1 4 5 6

      第四趟:2 1 3 4 5 6

      第五趟:1 2 3 4 5 6

      相关代码如下:

    import java.util.*;
    class test  
    {
        public static void main (String[] args) throws java.lang.Exception
        {
            //实现冒泡算法
            int[] array = {1,7,5,6,8,9,2,3,0};
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            bubbleSort(array);
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            
        }
        public static void bubbleSort(int[] array){
            int len = array.length;
            
            for(int i=0;i<len;i++){
                boolean flag = false;
                for(int j=1;j<len-i;j++){
                    if(array[j]<array[j-1]){
                        int temp = array[j];
                        array[j] = array[j-1];
                        array[j-1] = temp;
                        flag = true;
                    }
                    
                }
                if(flag == false)
                    return;
            }
        }
    }

      时间复杂度为O(n2)。

      当相邻的两个元素相等的时候,是不用进行交换的,所以冒泡排序是稳定的排序算法!

    2.选择排序

      选择排序是从待排序的元素中选择最大/最小的,将其放在最合适的位置。

      待排序序列:38,12,92,12,52,66,39,99

      第一次选择排序结果:12,38,92,12,52,66,39,99

      第二次选择排序结果:12,12,92,38,52,66,39,99

      第三次选择排序结果:12,12,38,92,52,66,39,99  

      第四次选择排序结果:12,12,38,39,52,66,92,99 

      第五次选择排序结果:12,12,38,39,52,66,92,99

      第六次选择排序结果:12,12,38,39,52,66,92,99

      第七次选择排序结果:12,12,38,39,52,66,92,99

    具体代码为:

    import java.util.*;
    class test  
    {
        public static void main (String[] args) throws java.lang.Exception
        {
            //实现选择排序
            int[] array = {1,7,5,6,8,9,2,3,0};
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            
            selectSort(array);
            
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            
        }
        public static void selectSort(int[] array){
           int len = array.length;
           for(int i=0;i<len-1;i++){
               int min = array[i];
               int index = i;
               
               for(int j=i+1;j<len;j++){
                   if(array[j]<min){
                        min = array[j];
                        index = j;
                   }
               
               }
               if(min!=array[i]){
                   int temp = array[index];
                   array[index] = array[i];
                   array[i] = temp;
               }
               
           }
        }
    }

      时间复杂度为O(n2),由于选择之后可能会交换两个相同元素的前后位置,所以是不稳定的排序

    3.插入排序

      把未排序的元素从后往前插入到已经排好序的序列中。 适用于处理数据量比较少或者序列部分有序的情况。

    适用处理数据量比较少或者部分有序的数据
    本文由 帅地玩编程(www.iamshuaidi.com) 辛苦整理,可以拿去当作本地笔记,但请勿抄袭发布在自家网站或者博客引流,否则必追究(原文来自:https://www.iamshuaidi.com/535.html)
    import java.util.*;
    class test  
    {
        public static void main (String[] args) throws java.lang.Exception
        {
            //实现插入排序
            int[] array = {1,7,5,6,8,9,2,3,0};
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            
            insertSort(array);
            
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            
        }
        
        public static void insertSort(int[] array){
           int len = array.length;
           for(int i=1;i<len;i++){
               int insert = array[i];
              int j=i-1;
               for(;j>=0 && insert<array[j];j--){
                   array[j+1] = array[j];
               }
               array[j + 1] = insert;
           }
        }
    }

      时间复杂度为O(n2),从后往前插入的过程中,相等的话不需要移动,所以是稳定的排序算法。

    4.希尔排序

      希尔排序是插入排序的改进版,将元素以每k个为一组先进行分组,然后对这一组的数据实行插入排序,这样大的元素就靠后了,小的元素就靠前了。初始时k=n/2,分为两组,插入排序完成之后再将k除以2,直到k为1为止。

      具体代码如下:

    import java.util.*;
    class test  
    {
        public static void main (String[] args) throws java.lang.Exception
        {
            //实现希尔排序
            int[] array = {1,7,5,6,8,9,2,3,0};
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            
            shellSort(array);
            
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            
        }
        
        public static void shellSort(int[] array){
           int n = array.length;
           for(int gap=n/2;gap>0;gap/=2){
               for(int i=gap;i<n;i++){
                   insert(array,gap,i);
               }
           }
        }
        public static void insert(int[] array,int gap,int i){
            int inserted = array[i];
            int j ;
            for(j=i-gap;j>=0&&array[j]>inserted;j-=gap){
                array[j+gap] = array[j];
            }
            array[j+gap] = inserted;
        }
    }

      时间复杂度为O(n1.3),因为希尔排序是跳跃性插入,所以可能会破坏两个相同元素的前后位置,是不稳定的排序算法

    5.快速排序

      先选取一个基准元素,基准元素左侧的都小于基准,基准右侧的都大于基准元素。每一趟排序都能够确定一个基准元素的位置,然后再对基准左右两侧的元素分别递归进行快排。

      具体代码如下:

    import java.util.*;
    class test  
    {
        public static void main (String[] args) throws java.lang.Exception
        {
            //实现快速排序
            int[] array = {1,7,5,6,8,9,2,3,0};
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            
            quickSort(array,0,array.length-1);
            
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            
        }
        
        public static void quickSort(int[] array,int left,int right){
            if(left>=right)
                return;
            
           int start = left;
           int end = right;
           int temp = array[left];
           while(left<right){
               while(left<right&&array[right]>=temp){
                   right--;
               }
               array[left] = array[right];
               while(left<right&&array[left]<temp){
                   left++;
               }
               array[right] = array[left];
           }
           array[left] = temp;
           quickSort(array,start,left-1);
           quickSort(array,left+1,end);
        }
    }

      平均时间复杂度为O(nlogn),最坏时间复杂度是O(n2),不稳定

    6.归并排序

      归并排序就是用的一个“分而治之”的思想,分----并

      具体代码如下:

    import java.util.*;
    class test  
    {
        public static void main (String[] args) throws java.lang.Exception
        {
            //实现归并排序
            int[] array = {1,7,5,6,8,9,2,3,0};
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            int[] temp = new int[array.length];
            
            mergeSort(array,temp, 0,array.length-1);
            
            for(int i=0;i<array.length;i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
            
        }
        
        public static void mergeSort(int[] array, int[] temp,int left,int right){
            if(left<right){
                int center = (left+right)/2;
                mergeSort(array,temp,left,center);
                mergeSort(array,temp,center+1,right);
                merge(array,temp,left,center,right);
            }
        }
        public static void merge(int[] array,int[] temp,int left,int center,int right){
            int i=left,j=center+1;
            for(int k=left;k<=right;k++){
                if(i>center)
                    temp[k] = array[j++];
                else if(j>right)
                    temp[k] = array[i++];
                else if(array[i]<array[j])
                    temp[k] = array[i++];
                else
                    temp[k] = array[j++];
            }
            for(int k=left;k<=right;k++){
                array[k] = temp[k];
            }
        }
    }

      时间复杂度为O(nlogn),是稳定的排序算法。

    各自努力,不问归期
  • 相关阅读:
    Python的网络编程[0] -> socket[1] -> socket 模块
    Python的网络编程[0] -> socket[0] -> socket 与 TCP / UDP
    Python的功能模块[4] -> pdb/ipdb -> 实现 Python 的单步调试
    Python的功能模块[3] -> binascii -> 编码转换
    Python的功能模块[2] -> abc -> 利用 abc 建立抽象基类
    Python的功能模块[1] -> struct -> struct 在网络编程中的使用
    Python的功能模块[0] -> wmi -> 获取 Windows 内部信息
    Python的程序结构[8] -> 装饰器/Decorator -> 装饰器浅析
    Python的程序结构[7] -> 生成器/Generator -> 生成器浅析
    Python的程序结构[6] -> 迭代器/Iterator -> 迭代器浅析
  • 原文地址:https://www.cnblogs.com/xiaona-/p/15263602.html
Copyright © 2020-2023  润新知