Java排序代码

public class Sort {
    public static void main(String[] args) {
        int[] data={3,6,8,3,2,45,7,567,5,12,234,3465,75,543,2,25,3,4,57,8,78,33,7,43,86,444};
        int[] outData = quickSort(data,0,data.length-1);
        showData(outData);
    }

    //冒泡排序
    public static int[] bubbleSort(int[] data){
        int temp;
        for (int i=0;ii;j--){  //注意j--
                if (data[j]data[i+1]){
                temp=data[i+1];
                for (j=i;j>=0 && data[j]>temp ;j--){    //j--的原因在于从后往前挪移数据
                    data[j+1]=data[j];
                }
                data[j+1]=temp;     //注意上一个for循环最后j--，所以j+1
            }
        }
        return data;
    }

    //希尔排序
    public static int[] shellSort(int[] data){
        int temp;
        int jump=data.length/2;     //jump作为一个阶段
        while (jump!=0){
            for (int i=jump;i=0 && data[j]>temp;j-=jump){
                        data[j+jump]=data[j];
                    }
                    data[j+jump]=temp;
                }
            }
            jump=jump/2;
        }
        return data;
    }

    //堆排序1
    public static int[] headSort(int[] data){
        //此循环的目的是将非叶节点排序成完整的大顶堆（data.length/2正好为非叶节点的数量）
        for (int i = data.length / 2;i > 0; i--){   //循环从data.length/2到1
            headAdjust(data,i,data.length);         //i和data.length为二叉树编号（不为0）
        }
        //此循环的目的是将data[0]与data[i]交换保证data[i]是最大的
        for (int i = data.length - 1; i > 0; i--){
            int tmp = data[i];      //将data[0]与data[i]交换，把最大的移动到数组最后一个位置
            data[i] = data[0];
            data[0] = tmp;
            headAdjust(data,1,i);   //1和i为二叉树编号（不为0）
        }
        return data;
    }

    //堆排序2
    public static void headAdjust(int[] data,int start,int end){
        int tmp = data[start - 1];      //实际的数组下标为：二叉树编号 - 1
        for (int j = start * 2; j <= end;j *= 2){   //j也为二叉树编号
            if (j < end && data[j-1] < data[j]){    //此步骤为寻找子节点的最大值的编号（在涉及数组时，编号一定要-1）
                j++;
            }
            if (data[j-1] < tmp){       //比较子节点最大值和父节点的大小，如果父节点大，则不交换
                break;
            }
            data[start - 1] = data[j - 1];
            start = j;
            data[j - 1] = tmp;
        }
    }

    //归并排序1
    public static int[] mergeSort(int[] data,int low,int high){ //low与high都为数组下标
        int[] resData;
        if (low < high){
            int mid = (low+high)/2;
            mergeSort(data,low,mid);        //使逐渐其分为1个数/组
            mergeSort(data,mid+1,high);
            merge(data,low,mid,high);       //合并零散的分组
        }
        return data;
    }

    //归并排序2
    private static void merge(int[] data, int low, int mid, int high) {
        int[] resData = new int[high-low+1];    //保存数据的中间值，注意high-low+1
        int i = low;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= high){
            if (data[i] < data[j]){     //把较小的数先移到新数组中
                resData[k++] = data[i++];
            } else {
                resData[k++] = data[j++];
            }
        }
        while (i <= mid){           // 把左边剩余的数移入数组
            resData[k++] = data[i++];
        }
        while (j <= high){          // 把右边剩余的数移入数组
            resData[k++] = data[j++];
        }
        for (int o = 0;o < resData.length; o++){    //把新数组中的数覆盖data数组
            data[o+low] = resData[o];
        }
    }

    //快速排序1
    public static int[] quickSort(int[] data,int low,int high){
        if (low=high
            quickSort(data,partition+1,high);
        }
        return data;
    }

    //快速排序2
    public static int quickSortPartition(int[] data,int low,int high){
        int pivot=data[low];       //将data[low]作为默认的枢纽记录
        while (low=pivot)   //注意此节点是while循环，
                high--;     //在data[high]>=pivot时是正确的排序，所以移动high的值
            swap(data, low, high);
            while (low