排序（2）--希尔，快速，归并

1.希尔

（1）原理：按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组

（2）时间复杂度： O（nlogn）

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

（4）代码实现：

public void sort(int[] array)
    {
        int size=array.length;
        int k=0;
        for(int i=size/2;i>=1;i=i/2)
        {
            for(int j=i;j<size;j++)
            {
                int temp=array[j];
                for(k=j-i;k>=0&&temp<array[k];k-=i)
                {
                    array[k+i]=array[k];
                }
                array[k+i]=temp;
            }
        }
    }

2.快速

（1）原理：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序

（2）时间复杂度： O（nlogn）

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

（4）代码实现：

public void sort(int[] array)
    {
        int right=array.length-1;
        int left=0;
        _sort(array,left,right);
    }

    private void _sort(int[] array, int left, int right) {
        if(left<right)
        {
            int _cut=cut(array,left,right);
            _sort(array,left,_cut-1);
            _sort(array,_cut+1,right);
        }
        
    }

    private int cut(int[] array, int left, int right) {
        int temp=array[left];
        while(left<right)
        {
            while(left<right&&temp<=array[right])
            {
                right--;
            }
            if(left<right)
            {
                array[left]=array[right];
                left++;
            }
            while(left<right&&temp>=array[left])
            {
                left++;
            }
            if(left<right)
            {
                array[right]=array[left];
                right--;
            }
        }
        array[left]=temp;
        return left;
    }

3.归并

（1）原理：通过不断分割到不能分割，再把所有子序列按序合并

（2）时间复杂度： O（nlogn）

（3）算法稳定性：稳定

（4）代码实现：

public void sort(int[] array)
    {
        mergesort(array,0,array.length-1);
    }

    private void mergesort(int[] array, int i, int j) {
        int mid=(i+j)/2;
        if(i<j)
        {
            mergesort(array,i,mid);
            mergesort(array,mid+1,j);
            merge(array,i,mid,j);
        }
    }

    private void merge(int[] array, int i, int mid, int j) {
        int[] temp=new int[j-i+1];
        int left=i;
        int right=mid+1;
        int num=0;
        while(left<=mid&&right<=j)
        {
            if(array[left]<array[right])
            {
                temp[num]=array[left];
                num++;left++;
            }
            else
            {
                temp[num]=array[right];
                num++;right++;
            }
        }
        while(left<=mid)
        {
            temp[num]=array[left];
            num++;left++;
        }
        while(right<=j)
        {
            temp[num]=array[right];
            num++;right++;
        }
        for(int flag=0;flag<j-i+1;flag++)
        {
            array[i+flag]=temp[flag];
        }
    }