排序算法

1.直接插入排序

 //直接插入排序
    //基本思想：每次将一个待排序的记录插入到已经排好序的序列中
    //时间复杂度：O(n2)
    //稳定性：稳定的
    public static void insertSort(int array[])
    {
        //第一个数看作排好序的序列，从第二个数开始寻找插入的位置
        for(int i=1;i<array.length;i++)
        {
            //记录下当前待排序记录的值
            int temp = array[i];
            //往前扫描有序的序列，直到找到一个比当前记录值不大的位置
            int j=i-1;
            for(;j>=0&&array[j]>temp;j--)
            {
                //把每个值向后移一位，给待排序的记录腾出位置
                array[j+1]=array[j];
            }
            array[j+1]=temp;
        }
    }

2.简单选择排序

 //选择排序
    //基本思想：在一组待排序的序列中，选择一个最小的数和第一个位置的数交换，再从剩下的部分选择最小的数和第二个位置的交换，以此类推直到最后一个数
    //时间复杂度：O(n2)
    //稳定性：不稳定的
    public static void selectSort(int array[])
    {

        for(int i=0;i<array.length;i++)
        {
            int position=i;
            //从待排序数组中找到最小的数，记录位置
            for(int j=i+1;j<array.length;j++)
            {
                if(array[j]<array[position])
                {
                    position=j;
                }
            }
            //把最小的数交换到待排序数组的最前面去
            int temp = array[i];
            array[i]=array[position];
            array[position]=temp;
        }
    }

3.快速排序

//快速排序
    //基本思想：通过划分基准点，将数组分成两部分，左半部分全部小于基准点的值，右半部份全部大于基准点的值
    //然后分别对两部分递归调用这个划分方法进行排序
    //时间复杂度：O(nlogn)
    //稳定性：不稳定的

    public static void quickSort(int array[],int left,int right)
    {
        if(left<right)
        {
            int keyposition = partition(array,left,right);
            quickSort(array,left,keyposition-1);
            quickSort(array,keyposition+1,right);
        }

    }

    public static int partition(int array[],int left,int right)
    {
        //选取最左边的元素作为基准点
        int standard = array[left];
        while(left<right)
        {
            //从最右边开始扫描，直到找到一个比基准点小的元素
            while(left<right&&array[right]>=standard)
            {
                right--;
            }
            if(left<right)
            {
                array[left]=array[right];
                left++;
            }
            //从左边开始扫描，直到找到一个比基准点大的元素
            while(left<right&&array[left]<=standard)
            {
                left++;
            }
            if(left<right)
            {
                array[right]=array[left];
                right--;
            }

        }
        array[left]=standard;
        return left;
    }

4.冒泡排序

  //冒泡排序
    //基本思想:从第一位开始，与后面的元素两两比较，每一轮把最小的冒到上面去
    //时间复杂度：O(n2)
    //稳定性：稳定

    public static void bubbleSort(int array[])

    {
        for(int i=0;i<array.length;i++)
        {
            for(int j=i;j<array.length;j++)
            {
                if(array[i]>array[j])
                {
                    int temp =array[i];
                    array[i]=array[j];
                    array[j]=temp;
                }
            }
        }
    }

5.归并排序

 //归并排序（二路归并）
    //基本思想：先把待排序的序列分成两部分，两部分各自继续分成两部分，直到分出来的部分只有一个元素，就按顺序合并两个部分
    //时间复杂度：o(nlogn)
    //稳定性：稳定
    public static void mergeSort(int array[],int start,int end,int temp[])
    {
        if(start<end)
        {
            int mid = start+(end-start)/2;
            //递归获取排序好的左半边
            mergeSort(array,start,mid,temp);
            //递归获取排序好的右半边
            mergeSort(array,mid+1,end,temp);
            //左右合并
            merge(array,start,mid,end,temp);
        }
    }
    //合并
    public static void merge(int array[],int start,int mid,int end,int temp[])
    {
        int i=start;
        int j=mid;
        int m=mid+1;
        int n=end;
        int k=0;
        //二路归并
        //当任一半边的数组元素全部放到临时数组后就跳出循环
        while(i<=j&&m<=n)
        {
            if(array[i]<array[m])
            {
                temp[k++]=array[i++];

            }else
            {
                temp[k++]=array[m++];
            }
        }
        //处理剩下的数组元素
        while(i<=j)
        {
            temp[k++]=array[i++];
        }
        while(m<=n)
        {
            temp[k++]=array[m++];
        }
        //把临时数组的元素按顺序拷贝到原目标数组中
        for(i=0;i<k;i++)
        {
            array[start+i]=temp[i];
        }
    }