package datastructure;
import java.util.Arrays;
import java.util.Scanner;
public class Sort {
static int len; //声明全局变量，用于记录arr的长度
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
String s[] = str.split(" ");
int arr[] = new int[s.length];
for (int i=0; i<s.length; i++) {
arr[i] = Integer.parseInt(s[i]);
}
len = arr.length;
System.out.println(Arrays.toString(arr));
// bubbleSort(arr);
// selectSort(arr);
// insertSort(arr);
// quickSort(arr, 0, arr.length-1);
// shellSort(arr);
heapSort(arr);
System.out.println(Arrays.toString(arr));
}
/**
* 冒泡排序（稳定）
*
* 每次比较相邻元素，如果第一个比第二个大，则交换。
* 对每一对相邻元素作同样工作，从第一对到最后一对。
* 每轮之后最后的元素是最大值。
*
* 时间复杂度 O(n^2)
* 空间复杂度 O(1)
* @param arr
* @return
*/
public static int[] bubbleSort(int[] arr) {
if (len == 0) {
return arr;
}
for (int i=0; i<len-1; i++) {
for (int j=0; j<len-1-i; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
}
/**
* 选择排序（不稳定）
*
* 1、从第一个元素开始，该元素可以认为已经被排序（最小/最大）
* 2、在未排序的元素序列中从前向后扫描，找比该元素（已排序）小的最小值
* 3、如果找到，两者互换。
* 4、以此类推，直到所有元素均排序完毕。
*
* 时间复杂度为 O(n^2)。
* 空间复杂度 O(1)
*
* @param arr
* @return
*/
public static int[] selectSort(int[] arr) {
if (len == 0) {
return arr;
}
for (int i=0; i<len; i++) {
int minIndex = i;
for (int j=i; j<len; j++) {
if (arr[j] < arr[minIndex])
minIndex = j;
}
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
return arr;
}
/**
* 直接插入排序（稳定）
* 1、从第一个元素开始，该元素可以认为已经被排序；
* 2、取出下一个元素，在已经排序的元素序列中从后向前扫描；
* 3、如果该元素（已排序）大于新元素，将该元素移到下一位置；
* 4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
* 5、将新元素插入到该位置后；
* 6、重复步骤2~5。
*
* 时间复杂度 O(n^2)
* 空间复杂度 O(1)
* @param arr
* @return
*/
public static int[] insertSort(int[] arr) {
if (len == 0) {
return arr;
}
for (int i=0; i<len-1; i++) {
for (int j=i+1; j>0; j--) {
if (arr[j] < arr[j-1]) {
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
}
}
return arr;
}
/**
* 希尔排序[缩小增量排序]（不稳定）
* 将待排序数组按照步长gap进行分组，
* 然后将每组的元素利用直接插入排序的方法进行排序；
* 每次再将gap折半减小，循环上述操作；
* 当gap=1时，利用直接插入，完成排序。
*
* 时间复杂度：O(nlogn)
* 空间复杂度 O(1)
* @param arr
* @return
*/
public static int[] shellSort(int[] arr) {
if (len == 0) {
return arr;
}
int temp, gap = len / 2;
while (gap > 0) {
for (int i=gap; i < len; i++) {
temp = arr[i];
int preIndex = i - gap;
while (preIndex >= 0 && arr[preIndex] > temp) {
arr[preIndex + gap] = arr[preIndex];
preIndex -= gap;
}
arr[preIndex + gap] = temp;
}
gap /= 2;
}
return arr;
}
/**
* 快速排序（不稳定）
* 【https://www.bilibili.com/video/BV1at411T75o】
* 1、从数列中挑出一个元素，称为"基准"（pivot）
* 2、重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面
* 3、递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。
*
* 时间复杂度 O(nlogn)
* 空间复杂度 O(logn)
* @param arr
* @param L
* @param R
*/
public static void quickSort(int[] arr, int L, int R) {
if (L >= R) {
return ;
}
int left = L;
int right = R;
int pivot = arr[left];
while (left < right) {
// 从后向前找到比pivot小的元素
while (left<right && arr[right]>=pivot){
right--;
}
arr[left] = arr[right];
// 从前向后找到比pivot大的元素
while (left<right && arr[left]<=pivot){
left++;
}
arr[right] = arr[left];
}
// 放置基准值，准备分治递归快排
arr[left] = pivot;
quickSort(arr, L, right-1);
quickSort(arr, right+1, R);
}
/**
* 堆排序 （不稳定）
*
* 时间复杂度：O(nlogn)
* 空间复杂度 O(1)
* @param arr
* @return
*/
public static int[] heapSort(int[] arr) {
if (len == 0) {
return arr;
}
for (int i=len-1; i>0; i--) {
buildMaxHeap(arr, i);
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
}
return arr;
}
/**
* 建立最大堆
* @param arr
*/
public static void buildMaxHeap(int[] arr, int n) {
int child;
for (int i=(n-1)/2; i>=0; i--) {
//左节点
child = 2 * i + 1;
//右节点存在且大于左节点,child变为右节点
if (child !=n && arr[child] < arr[child+1]) {
child++;
}
//交换父节点与左右子节点中的最大值
if (arr[i] < arr[child]) {
int temp = arr[i];
arr[i] = arr[child];
arr[child] = temp;
}
}
}
}
