Java_排序

via: http://flycars001.iteye.com/blog/2007081

 

选择排序（Selection Sort ）分为两种 简单选择排序（Simple Selection Sort） 和树形选择排序。

　　简单选择排序(Simple Selection Sort)：

　　简单选择排序类似于冒泡排序（Bubble Sort） ，每次都会在剩下的元素集合中选择出一个最值出来填充到当前位置。唯一的区别是，冒泡排序在每次发现比当前值小于（或大于）时，都会交换元素的位置， 而 简单选择排序是选择剩余元素中的最值和当前位置交换数据。

　　比如对于元素集合R={37, 40, 38, 42, 461, 5,  7, 9, 12}

　　在第一趟排序中：37直接和5交换， 形成新的序列 R1={5,40,38,42,461,37,7,9,12}

　　在第二趟排序中：40直接和7交换， 形成新的序列 R2={5,7,38,42,461,37,40,9,12}

　　以此类推，直到最后一个元素（注意：在第二趟排序中，38比42小，但是他们并没有交换数据）。

　　以下是简单选择排序的一个Java实现版本：

 

public static void selectionSort(int[] data) {  

if (data == null || data.length <= 1)  

return;  

int i, j, value, minPos, len = data.length;  

int outer = len - 1, tmp;  

for (i = 0; i < outer; i++) {  

value = data[i];  

minPos = -1;  

for (j = i + 1; j < len; j++) {  

if (data[j] < value) {  

minPos = j;  

value = data[j];  

}  

}  

if (minPos != -1) {  

tmp = data[i];  

data[i] = value;  

data[minPos] = tmp;  

}  

//            for (int k = 0; k < len; k++) {  

//                System.out.print(data[k] + " , ");  

//            }  

//            System.out.println();  

}  

}  

public static void main(String[] args) {  

int[] coll = {  

37, 40, 38, 42, 461, 5,  7, 9, 12  

};  

selectionSort(coll);  

for (int i = 0; i < coll.length; i++) {  

System.out.print(coll[i] + " , ");  

}  

}  

 

 

树选择排序（Tree Selection Sort）

　　树选择排序算法相对于简单选择排序来说是典型的以空间换时间的算法。其思想是对待排序的 N 个元素 ， 构造出相对较小的 (n+1)/2个数，然后再构造出相对较小的[n+1]/4个数，直到只有一个元素为止。构造成一个完全二叉树。

　　排序的时候，那个元素就是最小的，取出该最小元素，将该元素替换为"最大值"，再调整完全二叉树。

　　下面是树形选择排序的一个Java实现版：

 

 

public static void treeSelectionSort(int[] data) {  

if (data == null || data.length <= 1)  

return;  

int len = data.length , low = 0 , i , j;  

// add Auxiliary Space  

int[] tmp = new int[2*len -1];  

int tSize = tmp.length;  

//construct a tree  

for(i =len-1 , j=tmp.length-1;i >=0 ;i--,j--){  

tmp[j]=data[i];  

}  

for(i = tSize -1 ; i > 0 ; i-=2){  

tmp[(i-1)/2] = tmp[i] > tmp[i-1]? tmp[i-1]:tmp[i];  

}  

//end  

//remove the minimum node.  

while(low < len){  

data[low++] = tmp[0];  

for(j=tSize-1;tmp[j]!=tmp[0];j--);  

tmp[j] = Integer.MAX_VALUE;  

while(j > 0){  

if(j%2 == 0){  //如果是右节点  

tmp[(j-1)/2] = tmp[j] > tmp[j-1]?tmp[j-1]:tmp[j];  

j = (j-1)/2;  

}else{  //如果是左节点  

tmp[j/2]=tmp[j] > tmp[j+1]? tmp[j+1]:tmp[j];  

j = j/2;  

}  

}  

}  

}  

 

在构造完全二叉树的时候对 N 个元素的集合， 需要 2*N -1 个辅助空间。

 

while(j > 0){  

if(j%2 == 0){  //如果是右节点  

tmp[(j-1)/2] = tmp[j] > tmp[j-1]?tmp[j-1]:tmp[j];  

j = (j-1)/2;  

}else{  //如果是左节点  

tmp[j/2]=tmp[j] > tmp[j+1]? tmp[j+1]:tmp[j];  

j = j/2;  

}  

} 

 

-----------------------------------------------------------

Java 常用4种排序方法

class zyfsort {

    public static void main (String[] args) {

        int gohome[] = new int[]{12,7,54,21,1,4,65,76,34,9,3,6};    

        System.out.println("插入排序算法");

//        InsertionSort(gohome);

//        SelectSort(gohome);

//        BubbleSort(gohome);

        gohome =QuickSort(gohome);

        

        for (int t=0; t<gohome.length;t++)

        {

            System.out.print(gohome[t]+"--");

        } 

    }

    

    //插入排序算法

    public static void InsertionSort(int[] goal)

    {    

        for (int i = 1; i<goal.length; i++)

        {    int now = i;

            int frank = goal[i];            

            while (now>0 && goal[now-1] <= frank)

            {

                goal[now]=goal[now-1];

                now--;            

            }

            goal[now]=frank;

            

        

        }    

        

        for (int t=0; t<goal.length;t++)

        {

            System.out.print(goal[t]+"--");

        }

    }

    

    //选择排序算法    

    public static void SelectSort(int[] goal)

    {        

        int max;

        int stmp;    

        for (int i = 0; i<goal.length-1; i++)

        {

            max=i;

            for (int j = i+1; j<goal.length; j++)

                if(goal[j]>goal[max])

                    max=j;

                                    

            stmp = goal[i];

            goal[i]=goal[max];

            goal[max]=stmp;            

        

        }    

        for (int t=0; t<goal.length;t++)

        {

            System.out.print(goal[t]+"--");

        }

            

    

    }

    

    //冒泡排序算法    

    public static void BubbleSort(int[] goal)

    {    int stmp;

        for (int i = 1; i< goal.length; i++)

        {

            for(int j=0; j<i;j++)

            {

                if(goal[i]>goal[j])

                {

                    stmp=goal[i];

                    goal[i]=goal[j];

                    goal[j]=stmp;    

                }    

            }    

    

        }

        for (int t=0; t<goal.length;t++)

        {

            System.out.print(goal[t]+"--");

        }

    }

    

    //快速排序算法

    public static int[] QuickSort(int[] number) {

      QuickSort(number, 0, number.length-1);

      return number ;

      }

    private static void QuickSort(int[] number,int left, int right) {

        int stmp;

      if(left < right) {

          System.out.println(left+" | "+right+" | "+(left+right)/2);

          int s = number[(left+right)/2];

          int i = left - 1;

          int j = right + 1;

          while(true) {

                // 向右找

                while(number[++i] > s) ;

                  // 向左找

                while(number[--j] < s) ;

                  if(i >= j)

                      break;             

                stmp = number[i];

                  number[i] = number[j];

                  number[j] = stmp;              

              }

          QuickSort(number, left, i-1); // 对左边进行递回

          QuickSort(number, j+1, right); // 对右边进行递回

      }     

      }

 }