排序算法

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];        }    }