八大排序算法

八种排序算法

package sortdemo;

import java.util.Arrays;


public class sortTest {
     
    //1.冒泡排序
    public void bubbleSort(int[] array) {
     
        int t = 0;
        for (int i = 0; i < array.length - 1; i++) {
     
            for (int j = 0; j < array.length - 1 - i; j++)
                if (array[j] > array[j + 1]) {
     
                    t = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = t;
                }
        }
    }


    //2.选择排序
    public void selectSort(int[] array) {
     
        int t = 0;
        for (int i = 0; i < array.length - 1; i++) {
     
            int index = i;
            for (int j = i + 1; j < array.length; j++)
                if (array[index] > array[j])
                    index = j;
            if (index != i) {
     //找到了比array[i]小的则与array[i]交换位置
                t = array[i];
                array[i] = array[index];
                array[index] = t;
            }
        }
    }

    //3.插入排序
    public void insertionSort(int[] array) {
     
        int i, j, t = 0;
        for (i = 1; i < array.length; i++) {
     
            if (array[i] < array[i - 1]) {
     
                t = array[i];
                for (j = i - 1; j >= 0 && t < array[j]; j--)
                    array[j + 1] = array[j];
                array[j + 1] = t;
            }
        }
    }


    //4.分治法快速排序
    public void quickSort(int[] array, int low, int high) {
     //传入low=0,high=array.length-1;
        int pivot, p_pos, i, t;//pivot->位索引；p_pos->轴值。
        if (low < high) {
     
            p_pos = low;
            pivot = array[p_pos];
            for (i = low + 1; i <= high; i++)
                if (array[i] > pivot) {
     
                    p_pos++;
                    t = array[p_pos];
                    array[p_pos] = array[i];
                    array[i] = t;
                }
            t = array[low];
            array[low] = array[p_pos];
            array[p_pos] = t;
            //分而治之
            quickSort(array, low, p_pos - 1);// 排序左半部分
            quickSort(array, p_pos + 1, high);// 排序右半部分
        }

    }

    //5.希尔排序
    public void sheelSort(int[] a) {
     
        int d = a.length;
        while (d != 0) {
     
            d = d / 2;
            for (int x = 0; x < d; x++) {
     //分的组数
                for (int i = x + d; i < a.length; i += d) {
     //组中的元素，从第二个数开始
                    int j = i - d;//j为有序序列最后一位的位数
                    int temp = a[i];//要插入的元素
                    for (; j >= 0 && temp < a[j]; j -= d) {
     //从后往前遍历。
                        a[j + d] = a[j];//向后移动d位
                    }
                    a[j + d] = temp;
                }
            }
        }
    }

    //6.堆排序
    public void heapSort(int[] array) {
     
        System.out.println("开始排序");
        int arrayLength = array.length;
        //循环建堆
        for (int i = 0; i < array.length - 1; i++) {
     
            //建堆

            buildMaxHeap(array, arrayLength - 1 - i);
            //交换堆顶和最后一个元素
            swap(array, 0, arrayLength - 1 - i);
            System.out.println(Arrays.toString(array));
        }
    }

    private void swap(int[] data, int i, int j) {
     
        // TODO Auto-generated method stub
        int tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;
    }

    //对data数组从0到lastIndex建大顶堆
    private void buildMaxHeap(int[] data, int lastIndex) {
     
        // TODO Auto-generated method stub
        //从lastIndex处节点（最后一个节点）的父节点开始
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
     
            //k保存正在判断的节点
            int k = i;
            //如果当前k节点的子节点存在
            while (k * 2 + 1 <= lastIndex) {
     
                //k节点的左子节点的索引
                int biggerIndex = 2 * k + 1;
                //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
                if (biggerIndex < lastIndex) {
     
                    //若果右子节点的值较大
                    if (data[biggerIndex] < data[biggerIndex + 1]) {
     
                        //biggerIndex总是记录较大子节点的索引
                        biggerIndex++;
                    }
                }
                //如果k节点的值小于其较大的子节点的值
                if (data[k] < data[biggerIndex]) {
     
                    //交换他们
                    swap(data, k, biggerIndex);
                    //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
                    k = biggerIndex;
                } else {
     
                    break;
                }
            }
        }
    }

    //7.归并排序
    public static void mergeSort(int[] numbers, int left, int right) {
     
        int t = 1;// 每组元素个数
        int size = right - left + 1;
        while (t < size) {
     
            int s = t;// 本次循环每组元素个数
            t = 2 * s;
            int i = left;
            while (i + (t - 1) < size) {
     
                merge(numbers, i, i + (s - 1), i + (t - 1));
                i += t;
            }
            if (i + (s - 1) < right)
                merge(numbers, i, i + (s - 1), right);
        }
    }

    private static void merge(int[] data, int p, int q, int r) {
     
        int[] B = new int[data.length];
        int s = p;
        int t = q + 1;
        int k = p;
        while (s <= q && t <= r) {
     
            if (data[s] <= data[t]) {
     
                B[k] = data[s];
                s++;
            } else {
     
                B[k] = data[t];
                t++;
            }
            k++;
        }
        if (s == q + 1)
            B[k++] = data[t++];
        else
            B[k++] = data[s++];
        for (int i = p; i <= r; i++)
            data[i] = B[i];
    }

    //8.基数排序
    /*
    private static void radixSort(int[] array, int d) {
        int n = 1;//代表位数对应的数：1,10,100...
        int k = 0;//保存每一位排序后的结果用于下一位的排序输入
        int length = array.length;
        int[][] bucket = new int[10][length];//排序桶用于保存每次排序后的结果，这一位上排序结果相同的数字放在同一个桶里
        int[] order = new int[length];//用于保存每个桶里有多少个数字
        while (n < d) {
            for (int num : array) //将数组array里的每个数字放在相应的桶里
            {
                int digit = (num / n) % 10;
                bucket[digit][order[digit]] = num;
                order[digit]++;
            }
            for (int i = 0; i < length; i++)//将前一个循环生成的桶里的数据覆盖到原数组中用于保存这一位的排序结果
            {
                if (order[i] != 0)//这个桶里有数据，从上到下遍历这个桶并将数据保存到原数组中
                {
                    for (int j = 0; j < order[i]; j++) {
                        array[k] = bucket[i][j];
                        k++;
                    }
                }
                order[i] = 0;//将桶里计数器置0，用于下一次位排序
            }
            n *= 10;
            k = 0;//将k置0，用于下一轮保存位排序结果
        }

    }

     */


    public static void main(String[] args) {
     
        int[] array = {
     37, 47, 23, 100, 19, 56, 56, 99, 9};
        int i,j;
        sortTest st = new sortTest();
        //st.bubbleSort(array);
        //st.selectSort(array);
        //st.insertionSort(array);
        //st.quickSort(array,0,array.length-1);
        //st.sheelSort(array);
        //st.heapSort(array);
        //mergeSort(array,0,8);
        //radixSort(array,2);


        System.out.println("排序后：" + Arrays.toString(array));
    }

}