冒泡、插入、选择、快速排序

package com.lee.test;

import java.util.Arrays;

/**
* 常见的排序算法实现
* 1.冒泡排序
* 2.插入排序
* 3.选择排序
* 4.快速排序
* @author 健身小码哥
*
*/
public class SortManager {

private static int time=0;

/**
* 冒泡排序
* 原理：每次遍历，将剩余子数组中的最大值移动到子数组的尾端
* @param array
*/
public static void bubbleSort(int array[]){
if(array == null || array.length < 2){
return;
}

int length = array.length;

for(int i = 0 ; i < array.length ; i++){
for(int j = 0 ; j < length - i -1; j++){
//将较大的元素向后移动
if(array[j] > array[j+1]){
int temp = array[j+1];
array[j+1] = array[j];
array[j] = temp;
}
time ++ ;
}
}
System.out.println(Arrays.toString(array));
}

/**
* 插入排序
* @param array
*/
public static void insertionSort(int array[]){
if(array == null || array.length < 2){
return;
}
for(int i = 1 ; i < array.length ; i++){
for(int j = i ; j > 0 ; j--){
time ++ ;
if(array[j] < array[j-1]){
swap(array,j,j-1);
}
}
}
System.out.println(Arrays.toString(array));
}

/**
* 选择排序
* @param array
*/
public static void selectionSort(int array[]){
if(array == null || array.length < 2){
return;
}

for(int i = 0 ; i < array.length ; i++){
int maxPos = 0;
for(int j = 0 ; j < array.length -i; j++){time ++ ;
maxPos = array[maxPos] > array[j] ? maxPos : j;
}
swap(array , maxPos , array.length - i - 1);System.out.println(Arrays.toString(array));
}
}

/**
* 快速排序，选取最后一个元素作为参考，输出数组的非递减序列
* @param array 待排序的数组
* @param start 要排序数组的开始位置
* @param end 要排序数组的结束位置
*/
public static void quickSort(int array[] , int start , int end){
if(array == null || array.length < 2 || start >= end){
return;
}time ++ ;
//选取最后一个元素作为参考
int flag = array[end];

//记录大于flag的第一个元素位置
int i = start-1;
//标识当前遍历的位置
int j = start ;

while(j < end){
//当元素小于flag时，与++i进行交换
if( array[j] < flag){
i++;
swap(array,i,j);
}
j++;
}
//将flag交换到合适的位置
int mid = i + 1;
System.out.println("交换前数组："+Arrays.toString(array));
swap(array,mid,end);
System.out.println("交换后数组："+Arrays.toString(array));
//对左右子数组进行递归排序
quickSort(array,start,mid -1);
quickSort(array,mid + 1,end);

}

/**
* 快速排序，选取最后一个元素作为关键值，输出数组的非递减序列
* @param array 待排序的数组
* @param start 要排序数组的开始位置
* @param end 要排序数组的结束位置
*/
public static void quickSort2(int array[] , int start , int end){
if(array == null || array.length < 2 || start >= end){
return;
}
int flag = array[end];
//1.从左向右遍历，寻找比flag大的元素left
//2.从右向左遍历，寻找比flag小的元素right
//3.交换元素位置，直到left >= right ， 将参考值交换到合适的位置
int left = start;
int right = end;
while(left < right){
if(array[left] <= flag){
left++;
}else if(array[right] >= flag){
right--;
}else{
System.out.println("交换前数组："+Arrays.toString(array));
swap(array,left,right);
System.out.println("交换后数组："+Arrays.toString(array));
}
}
System.out.println("交换前数组："+Arrays.toString(array));
//将flag交换到合适的位置
swap(array,left,end);
System.out.println("交换后数组："+Arrays.toString(array));

//对左右子数组进行递归排序
quickSort2(array,start,left -1);
quickSort2(array,left + 1,end);
}

/**
* 交换数组中两元素的位置
* @param array
* @param x
* @param y
*/
private static void swap(int array[] , int x , int y){
time++;
int temp = array[x];
array[x] = array[y];
array[y] = temp;
}

public static void main(String[] args){
int[] array = {3,6,9,2,5,8,7,4,1};
quickSort2(array, 0, 8);
System.out.println(time);
}
}