java常见排序算法

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

/**
 * 插入排序
 *
 * 从第一个元素开始，该元素可以认为已经被排序
 * 取出下一个元素，在已经排序的元素序列中从后向前扫描
 * 如果该元素（已排序）大于新元素，将该元素移到下一位置
 * 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
 * 将新元素插入到该位置中
 * 重复步骤2
 * @param numbers  待排序数组
 */

    // 插入排序
    public static void insertSort(int[] str) {
        int length = str.length;
        int temp;
        for(int i = 0; i < length; i++) {
            for (int j = i ; j > 0; j--) {
                if(str[j] < str[j - 1]) {
                    temp = str[j];
                    str[j] = str[j - 1];
                    str[j - 1] = temp;
                }
            }
        }
    }
}

/**
 * 选择排序算法
 * 在未排序序列中找到最小元素，存放到排序序列的起始位置
 * 再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。
 * 以此类推，直到所有元素均排序完毕。
 * @param numbers
 */

// 选择排序
public static void selectSort(int str[]) {
    int length = str.length;
    int temp;
    for ( int i = 0; i < length - 1; i++) {
        int index = i;
        for(int j = i + 1; j < length; j++) {
            if(str[index] > str[j]) {
                index = j;
            }
        }
        if (index != i) {
            temp = str[i];
            str[i] = str[index];
            str[index] = temp;
        }
    }
}

/**
 * 归并排序
 * 简介:将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列
 * 时间复杂度为O(nlogn)
 * 稳定排序方式
 * @param nums 待排序数组
 * @return 输出有序数组
 */

// 归并排序
public static void mergeSort(int[] arr) {
    // 新建一个等长的数组
    int[] temp = new int[arr.length];
    sort(arr, 0, arr.length - 1, temp);
}

private static void sort(int[] arr, int left, int right, int[] temp) {
    if(left < right) {
        int mid = (left + right)/2;
        // 左边归并排序，使得左子序列有序
        sort(arr, left, mid, temp);
        // 右边归并排序，使得右子序列有序
        sort(arr, mid + 1, right, temp);
        // 将两个有序子数组合并操作
        merge(arr, left, mid, right, temp);
    }
}

/**
 * 查找出中轴（默认是最低位low）的在numbers数组排序后所在位置
 *
 * @param numbers 带查找数组
 * @param low   开始位置
 * @param high  结束位置
 * @return  中轴所在位置
 */

// 快速排序
public static void quickSort(int[] str, int left, int right) {
    int mid;
    if (left < right) {
        mid = partition(str, left, right);
        quickSort(str, left, mid - 1);
        quickSort(str, mid + 1, right);
    }
}

public static int

partition(int arr[],int left,int right) {
    // 待排元素
    int key = arr[left];
    while (left < right) {
        while (right > left && arr[right] >= key) {
            //从右往左扫描，找到第一个比基准值小的元素
            right--;
        }

        //找到这种元素将arr[right]放入arr[left]中
        arr[left] = arr[right];

        while (left < right && arr[left] <= key) {
            //从左往右扫描，找到第一个比基准值大的元素
            left++;
        }

        //找到这种元素将arr[left]放入arr[right]中
        arr[right] = arr[left];
    }
　　 // 元素归位
    arr[left] = key;
    return left;
}

//**希尔排序的原理:根据需求，如果你想要结果从大到小排列，它会首先将数组进行分组，然后将较大值移到前面，较小值
/* 移到后面，最后将整个数组进行插入排序，这样比起一开始就用插入排序减少了数据交换和移动的次数，可以说希尔排序是加强
        * 版的插入排序
        * 拿数组5, 2, 8, 9, 1, 3，4来说，数组长度为7，当increment为3时，数组分为两个序列
        * 5，2，8和9，1，3，4，第一次排序，9和5比较，1和2比较，3和8比较，4和比其下标值小increment的数组值相比较
        * 此例子是按照从大到小排列，所以大的会排在前面，第一次排序后数组为9, 2, 8, 5, 1, 3，4
        * 第一次后increment的值变为3/2=1,此时对数组进行插入排序，
        *实现数组从大到小排
        */

// 希尔排序
public static void shellSort(int[] str) {
    // 设置步长，默认为数组长度的一半
    int step = str.length / 2;
    while (step >= 1) {
        for (int i = step; i < str.length; i += step) {
            int tmp = str[i];
            int j;
            for (j = i; j > 0 && str[j - step] > tmp; j -= step) {
                str[j] = str[j - step];//元素后移
            }
            str[j] = tmp;//插入的位置，注意此时j在for循环中已经进行了一次--
        }
        step /= 2;
    }
}

/**
 * 堆排序是一种树形选择排序，是对直接选择排序的有效改进。

 　　堆的定义下：具有n个元素的序列 （h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1） (i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。
     完全二 叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。

 　　思想:初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个 堆，
     这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。
     依此类推，直到只有两个节点的堆，并对 它们作交换，最后得到有n个节点的有序序列。从算法描述来看，
     堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。
    一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
 */

// 堆排序
public static void heapSort(int[] arr) {
    // 1、构建大顶堆
    for(int i = arr.length/2-1; i>=0;i--) {
        // 从第一个非叶子节点从下至上，从右至左调整结构
        adjustHeap(arr, i, arr.length);
    }
    // 2、调整堆结构+交换堆顶元素和末尾元素
    for(int j = arr.length-1; j > 0; j--) {
        //将堆顶元素与末尾元素进行交换
        int temp = arr[0];
        arr[0] = arr[j];
        arr[j] = temp;
        //重新对堆进行调整
        adjustHeap(arr, 0, j);
    }
}

private static void adjustHeap(int[] arr, int i, int length) {
    int temp = arr[i];
    for(int k = 2*i +1; k < length; k = 2*k +1) {
        if(k + 1 < length && arr[k] < arr[k + 1]) {
            k++;
        }
        if(temp < arr[k]) {
            arr[i] = arr[k];
            i = k;
        } else {
            break;
        }
    }
    arr[i] = temp;
}