排序--冒泡，插入，选择

Posted 2020-11-20 blogofjzq

1.冒泡排序

（1）原理：多趟比较，每趟比较中通过对每对相邻数据进行不断的判断和交换将最大的数据放到未排序序列的最后，就像大泡泡不断向上浮动一样

（2）时间复杂度：  

（3）算法稳定性：稳定

（4）代码实现：

public void sort(int[] array)
    {
        int size=array.length;
        for(int i=1;i<size;i++)
        {
            for(int j=0;j<size-i;j++)
            {
                if(array[j]>array[j+1])
                {
                    swap(array,j,j+1);
                }
            }
        }
    }

2.插入排序

（1）原理：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

（2）时间复杂度：  

（3）算法稳定性：稳定

（4）代码实现：

public void sort(int[] array)
    {
        int size=array.length;
        for(int i=1;i<size;i++)
        {
            int temp=array[i];
            int j=i-1;
            while(j>=0&&temp<array[j])
            {
                array[j+1]=array[j];
                j--;
            }
            array[j+1]=temp;
        }
    }
    public void binarysort(int[] array)//折半插入
    {
        int size=array.length;
        for(int i=1;i<size;i++)
        {
            int temp=array[i];
            int low=0;
            int high=i-1;
            while(low<=high)
            {
                int mid=(low+high)/2;
                if(temp<array[mid])
                {
                    high=mid-1;
                }
                else
                {
                    low=mid+1;
                }
            }
            for(int j=i-1;j>=low;j--)
            {
                array[j+1]=array[j];
            }
            array[low]=temp;
        }
    }

3.选择排序

（1）原理：每一次从待排序的数据中选出最小的一个元素，存放在无序序列的起始位置，直到全部待排序的数据元素排完

（2）时间复杂度：  

（3）算法稳定性：不稳定

（4）代码实现：

public void sort(int[] array)
    {
        int size=array.length;
        for(int i=0;i<size;i++)
        {
            int min=i;
            for(int j=i+1;j<size;j++)
            {
                if(array[min]>array[j])
                {
                    min=j;
                }
            }
            if(min!=i)
            {
                swap(array,min,i);
            }
        }
    }