码迷,mamicode.com
首页 > 编程语言 > 详细

java 各类排序数组实现

时间:2017-10-08 14:11:16      阅读:187      评论:0      收藏:0      [点我收藏+]

标签:数据   and   重复   shell排序   中间   math   bubble   ble   数字   

 代码来源:好像叫《java常用算法手册》

 

package sort;
 
/*堆排序:堆排序的关键是构造堆结构,即是构造一个完全二叉树。每个节点应满足条件:若升序,则父节点大于或等于左右子节点
 * 的数据,若降序则反之。在这里选择升序,则根节点为最大值。堆排序需要反复两个步骤:构造堆结构和堆排序输出。
 *“筛”运算来调整节点数据,以满足堆结构条件。
 *“筛”运算:从最底层的父节点开始,比较其左右子节点,选取较大的值与父节点比较,若大于父节点,则该子节点与父节点交换。其他
 *节点也是如此,   知道所有父节点均大于子节点的值。
 *排序输出:构造堆结构完成后,取最底层的节点,替换出根节点(最大值),将根节点保存至数组的最后位置。再进行构造堆结构,
 *排序输出。如此反复,知道最后两个数据比较完毕。排序也完成了。
 * 
 */
 
public class HeapSort {
     
    static final int SIZE = 10;
     
    static void heapSort(int a[],int n){
         
        int i,j,h,k;
        int t;
         
        for(i=n/2-1;i>=0;i--){
             
            while(2*i+1<n){
                 
                j=2*i+1;
                 
                if((j+1)<n){
                     
                    if(a[j]<a[j+1])
                        j++;
                }
                if(a[i]<a[j]){
                    t= a[i];
                    a[i] = a[j];
                    a[j] = t;
                    i=j;
                }
                else{
                    break;
                }
            }
        }
         
        System.out.print("原数据构成的堆:");
        for(h=0;h<n;h++){
            System.out.print(" " + a[h]);
        }
        System.out.print("\n");
             
        for(i=n-1;i>0;i--){
                 
            t = a[0];
            a[0] = a[i];
            a[i] = t;
            k = 0;
            while(2*k+1<i){
                j=2*k+1;
                if((j+1)<i){
                    if(a[j]<a[j+1]){
                        j++;
                    }
                }
                if(a[k] < a[j]){
                         
                    t = a[k];
                    a[k] = a[j];
                    a[j] = t;
                    k=j;
                }
                else{
                    break;
                }
            }
                 
            System.out.print("第" + (n-i) + "步排序结果:");
            for(h=0;h<n;h++){
                System.out.print(" " + a[h]);
            }
            System.out.print("\n");
        }
     
}
         
    public static void main(String[] args) {
        int[] shuzu = new int[SIZE];
        int i;
         
        for(i=0;i<SIZE;i++){
            shuzu[i] = (int) (100+Math.random()*(100+1));
        }
         
        System.out.println("排序前的数组为:");
         
        for(i=0;i<SIZE;i++){
            System.out.print(shuzu[i] + " ");
        }
         
        System.out.print("\n");
         
        heapSort(shuzu, SIZE);
         
        System.out.println("排序后的数组为:");
         
        for(i=0;i<SIZE;i++){
            System.out.print(shuzu[i] + " ");
        }
         
        System.out.print("\n");
    }
}

 

 

package sort;
 
/*
 * 冒泡排序:对数组中的数据,依次比较相邻两个元素的大小,如1 2 比较 2 3 比较,依据升序或者降序,取大或小,交换位置
 * 对N个数据进行排序,都需要进行N-1次中间排序。冒泡排序缺点:效率不高。
 */
public class BubbleSort {
    static final int SIZE = 10;
     
    public static void bubbleSort(int[] a){
        int temp;
        for(int i=1;i<a.length;i++){
            for(int j = 0; j<a.length-i;j++){
                if(a[j] > a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] =temp;
                }
            }
            System.out.println("第" + i + "步排序结果:");
            for(int k = 0;k<a.length;k++){
                System.out.print( " " + a[k]);
            }
            System.out.println("\n");
        }
    }
 
    public static void main(String[] args) {
        int[] m = new int[SIZE];
        int i;
        for(i=0;i<SIZE;i++){
            m[i]=(int) (100 + Math.random()*(100+1));//产生随机数初始化数组
        }
        System.out.println("排序前数组为:");
        for(i=0;i<SIZE;i++){
            System.out.print(m[i]+" ");
        }
        System.out.println("\n");
         
        bubbleSort(m);
        System.out.println("排序后数组为:");
        for(i=0;i<SIZE;i++){
            System.out.print(m[i]+ " ");
        }
        System.out.println("\n");
    }
 
}

 

 

package sort;
 
/*
 * 选择排序:先从原始数组中选出一个最小的数据,将其与第一个位置的数据交换。然后接着从剩下的n-1中找出最小的,与第二
 * 个位置的数据交换。依次类推不断重复,直到最后两个数据完成交换。
 * 缺点:效率不高  都要执行N-1步
 */
public class SelectionSort {
    static final int SIZE = 10;
     
    public static void selectionSort(int[] m) {
        int temp;
        int index;
         
        for(int i = 0; i<m.length;i++){
            index = i;
             
            for(int j = i+1;j<m.length;j++){//找出最小数的index
                if(m[j]<m[index]){
                    index = j;
                }
                 
            }
            if(index !=i){//交换位置
                temp = m[i];
                m[i]=m[index];
                m[index] = temp;
            }
            System.out.println("第" + (i+1) + "步排序结果:");
            for(int k = 0;k<m.length;k++){
                System.out.print( " " + m[k]);
            }
            System.out.println("\n");
        }
         
    }
     
    public static void main(String[] args) {
        int[] m = new int[SIZE];
        int i;
        for(i=0;i<SIZE;i++){
            m[i]=(int) (100 + Math.random()*(100+1));//产生随机数初始化数组
        }
        System.out.println("排序前数组为:");
        for(i=0;i<SIZE;i++){
            System.out.print(m[i]+" ");
        }
        System.out.println("\n");
         
        selectionSort(m);
        System.out.println("排序后数组为:");
        for(i=0;i<SIZE;i++){
            System.out.print(m[i]+ " ");
        }
        System.out.println("\n");
 
    }
 
     
 
}

 

 

package sort;
/*
 * Shell排序:
 * 1.将有n个元素的数组分成n/2个数字序列,第一个数据和第n/2+1个数据为一对.....
 * 2.一次循环使每个序列对排好序
 * 3.然后,再变为n/4个序列,再次排序
 * 4.不断重复上述过程,随着序列减少为最后一个,就完成了整个排序。
 * 具有较高的效率。
 */
public class ShellSort {
    static final int SIZE = 10;
     
    public static void shellSort(int[] m) {
        int i,j,h;
        int r,temp;
        int x = 0;
         
        for(r=m.length/2;r>=1;r/=2){
             
            for(i=r;i<m.length;i++){
                temp=m[i];
                j=i-r;
                while(j>=0&&temp<m[j]){
                    m[j+r]=m[j];
                    j-=r;
                }
                m[j+r]=temp;
            }
            x++;
            System.out.println("第" + x + "步排序结果:");
            for( h = 0;h<m.length;h++){
                System.out.print( " " + m[h]);
            }
            System.out.println("\n");
        }
    }
     
    public static void main(String[] args) {
        int[] m = new int[SIZE];
        int i;
        for(i=0;i<SIZE;i++){
            m[i]=(int) (100 + Math.random()*(100+1));//产生随机数初始化数组
        }
        System.out.println("排序前数组为:");
        for(i=0;i<SIZE;i++){
            System.out.print(m[i]+" ");
        }
        System.out.println("\n");
         
        shellSort(m);
        System.out.println("排序后数组为:");
        for(i=0;i<SIZE;i++){
            System.out.print(m[i]+ " ");
        }
        System.out.println("\n");
    }
 
     
 
}

 

package sort;
 
/*
 * 快速排序(quicksort)流程:
 * 1.首先设定一个分界值,通过该分界值将数组分成左右两部分。
 * 2.将大于等于分界值的数据集中到数组右边,小于分界值的数据集中到数组的左边。此时,左边部分的所有元素都小于分界值,
 * 右边部分的所有元素都大于等于分界值。
 * 3.然后,左边和右边的数据可以独立排序。对于左侧的数组数据,又可以取一个分界值,将该部分数据分成左右两部分,同样,
 * 左边放置小值,右边放置大值。右侧数组数据同上。
 * 4.重复上述过程,可以看出,这是一个递归定义。通过递归将左侧数据排好序后,再递归排后右侧部分的顺序。当左右两个部分
 * 各个数据排序好后,整个数组的排序也就完成了。
 */
public class QuickSort {
     
    static final int SIZE = 18;
    static void quickSort(int[] arr,int left,int right){
         
        int f, t ;
        int rtemp,ltemp;
         
        rtemp = right;//
        ltemp = left;
        f= arr[(left+right)/2];
        while(ltemp < rtemp){
             
            while(arr[ltemp] < f){
                ++ltemp;
            }
            while(arr[rtemp] > f){
                --rtemp;
            }
            if(ltemp<=rtemp){
                t=arr[ltemp];
                arr[ltemp] = arr[rtemp];
                    arr[rtemp] = t;
                --rtemp;
                    ++ltemp;
            }
        }
        if(ltemp == rtemp){
            ltemp++;
        }
         
        if(left < rtemp){
            quickSort(arr,left,ltemp-1);
        }
        if(ltemp < right){
            quickSort(arr,rtemp+1,right);
        }
    }
     
    public static void main(String[] args) {
        int[] shuzu = new int[SIZE];
        int i;
         
        for(i=0;i<SIZE;i++){
            shuzu[i] = (int) (100+Math.random()*(100+1));
        }
         
        System.out.println("排序前的数组为:");
         
        for(i=0;i<SIZE;i++){
            System.out.print(shuzu[i] + " ");
        }
         
        System.out.print("\n");
         
        quickSort(shuzu, 0, SIZE-1);
         
        System.out.println("排序后的数组为:");
         
        for(i=0;i<SIZE;i++){
            System.out.print(shuzu[i] + " ");
        }
         
        System.out.print("\n");
    }
 
}

 

 

package sort;
 
/*
 * 插入排序:首先对数组的前两个数据进行比较,接着将第三个数据域排好序的两个数据比较,将第三个数据插入到合适的位置。
 * 然后,将第四个数据插入到已排好寻的三个数据中;不断重复以上步骤,直到把最后一个数据插入到合适的位置。
 * 
 * 
 */
public class InsertionSort {
    static final int SIZE = 10;
     
    public static void insertionSort(int[] m) {
        int i,j,t;
        for(i=1;i<m.length;i++){
            t=m[i];//保存要插入的数据
            j=i-1;
            while(j>=0&&t<m[j]){
                m[j+1]=m[j];//要插入的数据比当前位置的数据小,当前位置的数据向后移一位。
                j--;//继续向前查找是否有比要插入的数据大的数
            }
            m[j+1]=t;//跳出while循环表示t>=m[j],则要插入的位置为j+1;
             
            System.out.println("第" + i + "步排序结果:");
            for(int k = 0;k<m.length;k++){
                System.out.print( " " + m[k]);
            }
            System.out.println("\n");
        }
         
    }
 
    public static void main(String[] args) {
        int[] m = new int[SIZE];
        int i;
        for(i=0;i<SIZE;i++){
            m[i]=(int) (100 + Math.random()*(100+1));//产生随机数初始化数组
        }
        System.out.println("排序前数组为:");
        for(i=0;i<SIZE;i++){
            System.out.print(m[i]+" ");
        }
        System.out.println("\n");
         
        insertionSort(m);
        System.out.println("排序后数组为:");
        for(i=0;i<SIZE;i++){
            System.out.print(m[i]+ " ");
        }
        System.out.println("\n");
    }
 
     
 
     
 
}

 

java 各类排序数组实现

标签:数据   and   重复   shell排序   中间   math   bubble   ble   数字   

原文地址:http://www.cnblogs.com/Binblink/p/7637136.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!