// 冒泡排序
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 str[],int left,int right) {
while (left < right) {
int temp;
if (str[left] > str[right]) {
temp = str[left];
str[left] = str[right];
str[right] = temp;
left++;
} else if (str[left] > str[right]) {
temp = str[left];
str[left] = str[right];
str[right] = temp;
right--;
} else {
right--;
continue;
}
}
System.out.println(left+":"+right);
return right;
}
//**希尔排序的原理:根据需求，若是你想要结果从大到小排列，它会首先将数组进行分组，而后将较大值移到前面，较小值
/* 移到后面，最后将整个数组进行插入排序，这样比起一开始就用插入排序减小了数据交换和移动的次数，能够说希尔排序是增强
* 版的插入排序
* 拿数组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) { // 一、构建大顶堆 for(int i = arr.length/2-1; i>=0;i--) { // 从第一个非叶子节点从下至上，从右至左调整结构 adjustHeap(arr, i, arr.length); } // 二、调整堆结构+交换堆顶元素和末尾元素 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;}