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");
    }
 
     
 
     
 
}