java排序二

重新再再巩固了一遍排序，上次的排序整理也没有写全，但是上篇文章把思路给整理出来了，详细的想看的点击链接就好了
http://blog.csdn.net/anny_lin/article/details/47046191

下面是算法：

1.冒泡排序：

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

2.选择排序：

/*** * 将i层循环每循环一次记录第一个元素的值（flag），然后再第二层循环中得到比flag小的元素的值，付给a[i];,并记录下下标loc，第二层循环完成后获得最小元素下标，将flag的值给予a[loc]，完成交换* */for(int i=0;i<a.length;i++){    //记录循环第一个元素第一个    int flag=a[i];    //记录j层循环后最小元素的下标    int loc=i;    for(int j=i+1;j<a.length;j++)    {        if (a[j]<a[i]) {        a[i]=a[j];        loc=j;        }    }    a[loc]=flag;}

3.插入排序：
将未排序的元素插入到已经排序完成的元素当中

for(int i=1;i<a.length;i++) {    int temp=a[i];    int loc=i;    for(int j=i-1;j>=0;j--)    {    //记得跟a[j]比较的是temp，假设你写成a[i]就错了，a[i]的值是会变的        if (a[j]>temp)         {            a[j+1]=a[j];            loc=j;        }    }    a[loc]=temp;   }

4.归并排序：

public static int[] sort(int[] nums, int low, int high) {         int mid = (low + high) / 2;         if (low < high) {             // 左边              sort(nums, low, mid);             // 右边              sort(nums, mid + 1, high);             // 左右归并              merge(nums, low, mid, high);         }         return nums;     }     public static void merge(int[] nums, int low, int mid, int high) {         int[] temp = new int[high - low + 1];         int i = low;// 左指针          int j = mid + 1;// 右指针          int k = 0;         // 把较小的数先移到新数组中          while (i <= mid && j <= high) {             if (nums[i] < nums[j]) {                 temp[k++] = nums[i++];             } else {                 temp[k++] = nums[j++];             }         }         // 把左边剩余的数移入数组          while (i <= mid) {             temp[k++] = nums[i++];         }         // 把右边边剩余的数移入数组          while (j <= high) {             temp[k++] = nums[j++];         }         // 把新数组中的数覆盖nums数组          for (int k2 = 0; k2 < temp.length; k2++) {             nums[k2 + low] = temp[k2];         }     }  

5.希尔排序：

static void shellSort( int[] a )     {            int group= a. length/2;            int j;            for(; group>=1; group/=2)           {                 for( int i= group; i< a. length; i++)                {                      int temp= a[ i];                      for( j= i- group; j>=0&& a[ j]> temp; j-= group)                     {                                 a[ j+ group]= a[ j];                     }                      a[ j+ group]= temp;                }           }     }}   

6.快速排序

static void sortDemo(int[] a,int begin,int end){    if (begin<end)    {        int i=quick_sort(a, begin, end);        sortDemo(a, begin, i-1);        sortDemo(a, i+1, end);    }}//进行基点的确定static int quick_sort(int[] a,int begin,int end){    int x=a[begin];    int j=end;    int i=begin;    boolean flag=true;    while (i!=j)    {        if (flag)        {            //从右向左找到比x小的元素，进行填坑操作            for(;j>i;j--)            {                if (a[j]<x)                    {                        //填坑                        a[i++]=a[j];                        //只找一个数，break;跳出                        flag=false;                        break;                    }            }        }else         {            //从左向右找到比x大的元素，进行填坑操作            for(;i<j;i++)            {                if (a[i]>x)                     {                        //填坑                        a[j--]=a[i];                        flag=true;                        break;                    }            }        }    }    a[i]=x;    return i;}

7.堆排序：

 //进行堆生成的关键步骤，即判断是否交换父节点与子节点的值    static void maxheap2(int[] a,int heapsize,int i)    {        //左节点        int left=2*i+1;        //右节点        int right=2*i+2;        //保存i的值        int large=i;        if (left<heapsize&&a[left]>a[i]) {            large=left;        }        //注意，进行比较的是a[right]>a[large],这样就能直接选出父节点下对应孩子节点最大的节点        if (right<heapsize&&a[right]>a[large]) {            large=right;        }        if (large!=i) {            //交换值            ArrayUtils.exchangeElements(a, i, large);            //进行递归，直到生成堆为止            maxheap2(a, heapsize, large);        }    }    //建立堆    static void bulidHeap(int[] a)    {            //从倒数第二排开始进行maxheap操作，当然从a.length-1开始也行，但是浪费不必要的时间        for (int i = a.length/2; i >=0; i--) {            maxheap2(a, a.length, i);        }    }    static void heapSort1(int[] a)    {        if (a.length<=1||a==null) {            return;        }        bulidHeap(a);        for (int i = a.length-1; i >=0; i--) {            //将堆顶元素与最后一个元素交换，同时数组大小将堆大小减一            ArrayUtils.exchangeElements(a, 0, i);            //重新生成堆            maxheap2(a, i, 0);        }    }

下面的过段时间给出，最近实习比较忙

8.基数排序：
来自百度百科

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

第一步

以LSD为例，假设原来有一串数值如下所示：
73, 22, 93, 43, 55, 14, 28, 65, 39, 81
首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：
0
1 81
2 22
3 73 93 43
4 14
5 55 65
6
7
8 28
9 39
第二步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：
81, 22, 73, 93, 43, 14, 55, 65, 28, 39
接着再进行一次分配，这次是根据十位数来分配：
0
1 14
2 22 28
3 39
4 43
5 55
6 65
7 73
8 81
9 93
第三步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：
14, 22, 28, 39, 43, 55, 65, 73, 81, 93
这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。
LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。MSD的方式与LSD相反，是由高位数为基底开始进行分配，但在分配之后并不马上合并回一个数组中，而是在每个“桶子”中建立“子桶”，将每个桶子中的数值按照下一数位的值分配到“子桶”中。在进行完最低位数的分配后再合并回单一的数组中。

package num;import java.util.Arrays;import javax.activation.MailcapCommandMap;public class Test {    public static void main(String[] args) {        int d=1;        int[] data = {56, 22, 101, 43, 55, 14, 28, 65, 39, 81, 33, 132};        d=getMaxd(data);        sort(data, d);        System.out.println(Arrays.toString(data));    }    public static void sort(int[] a,int d)    {        int k=0;        int n=1;        //表示依据哪一位数进行排序        int m=1;        //数组第一维表示可能的余数为0-9        int[][] array=new int[10][a.length];        //save数组表示位数是i的数的个数        int[] save=new int[10];        while (m<=d)         {            //将数字依次放入0-9的桶中            for(int i=0;i<a.length;i++)            {                int lsd=(a[i]/n)%10;                array[lsd][save[lsd]]=a[i];                save[lsd]++;            }            //重新排序            for (int i = 0; i < 10; i++)             {                //表示所代表的位数上的数组有值                if (save[i]!=0)                     for(int j=0;j<save[i];j++)                    {                        a[k]=array[i][j];                        k++;                    }                //进行清零操作                save[i]=0;              }            m++;            k=0;            n*=10;          }    }    //获取数组中最大的位数    public static int getMaxd(int[] a)    {        int temp=a[0];        for(int i=0;i<a.length;i++)        {            if (temp<a[i]) {                temp=a[i];            }        }        int d=0;        while(temp>0)        {            temp/=10;            d++;        }        return d;    }}

9.计数排序：

public static void main(String[] args) {        int d=1;        int[] data = {2,4,2,5,10,21,32,12,11,21,32,11,22,33};        countingSort(data, 33);        System.out.println(Arrays.toString(data));    }    public static void  countingSort(int[] a ,int k) {        //k为最大的数        int[] temp=new int[k+1];        //依次将数字填入数组temp中，temp中的元素相当于排完顺序的        for(int i=0;i<a.length;i++)        {            temp[a[i]]++;        }        int x=0;        for(int i=0;i<k+1;i++)        {            while(temp[i]>0)            {                a[x]=i;                x++;                temp[i]--;            }        }    }

大功告成~