部分排序算法总结

1.希尔排序

基本思想:

希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

JavaScript:

var arr = [49, 38, 65, 97, 76, 13, 27, 49, 55, 04];
var len = arr.length;
for (var fraction = Math.floor(len / 2); fraction > 0; fraction = Math.floor(fraction / 2)) {
    for (var i = fraction; i < len; i++) {
        for (var j = i - fraction; j >= 0 && arr[j] > arr[fraction + j]; j -= fraction) {
            var temp = arr[j];
            arr[j] = arr[fraction + j];
            arr[fraction + j] = temp;
        }
    }
}
console.log(arr);

java

public static void main(String [] args)
{
    int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
        System.out.println("排序之前：");
        for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+" ");
        }
        //希尔排序
        int d=a.length;
            while(true)
            {
                d=d/2;
                for(int x=0;x<d;x++)
                {
                    for(int i=x+d;i<a.length;i=i+d)
                    {
                        int temp=a[i];
                        int j;
                        for(j=i-d;j>=0&&a[j]>temp;j=j-d)
                        {
                            a[j+d]=a[j];
                        }
                        a[j+d]=temp;
                    }
                }
                if(d==1)
                {
                    break;
                }
            }
            System.out.println();
            System.out.println("排序之后：");
                for(int i=0;i<a.length;i++)
                {
                    System.out.print(a[i]+" ");
                }
    }

2.归并算法

基本介绍

　　归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

import java.util.Arrays;

public class GuiBing {


            public static void main(String []args){
                int []arr = {9,8,7,66,5,4,3,2,1};
                sort(arr);
                System.out.println(Arrays.toString(arr));
            }
            public static void sort(int []arr){
                int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
                sort(arr,0,arr.length-1,temp);
            }
            private static void sort(int[] arr,int left,int right,int []temp){
                if(left<right){
                    int mid = (left+right)/2;
                    sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
                    sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
                    merge(arr,left,mid,right,temp);//将两个有序子数组合并操作
                }
            }
            private static void merge(int[] arr,int left,int mid,int right,int[] temp){
                int i = left;//左序列指针
                int j = mid+1;//右序列指针
                int t = 0;//临时数组指针
                while (i<=mid && j<=right){
                    if(arr[i]<=arr[j]){
                        temp[t++] = arr[i++];
                    }else {
                        temp[t++] = arr[j++];
                    }
                }
                while(i<=mid){//将左边剩余元素填充进temp中
                    temp[t++] = arr[i++];
                }
                while(j<=right){//将右序列剩余元素填充进temp中
                    temp[t++] = arr[j++];
                }
                t = 0;
                //将temp中的元素全部拷贝到原数组中
                while(left <= right){
                    arr[left++] = temp[t++];
                }
            }
        }

3.快速排序

public class KuaiSuPaiXu {

    public static void main(String[] args) {

        int [] arr = {1,5,8,6,2,4,7};

        List<Integer> items = new ArrayList<>();


        for (int i = 0; i < arr.length; i++) {
            items.add(arr[i]);
        }
//        System.out.println(items.size());

        sort(items);

        System.out.println(items);

    }

    public static  void sort(List<Integer> items){

        if (items.size()>1){

            List<Integer> smaller = new ArrayList<>();
            List<Integer> small = new ArrayList<>();
            List<Integer> larger = new ArrayList<>();

            Integer chosenItem = items.get(items.size()/2);
            for (Integer i :items){
                if(i<chosenItem){
                    smaller.add(i);
                }else if (i>chosenItem){
                    larger.add(i);
                }else{
                    small.add(i);
                }
            }
            sort(smaller);
            sort(larger);

            items.clear();//把原始集合给清空
            items.addAll(smaller);
            items.addAll(small);
            items.addAll(larger);
        }
    }
}