数据结构之排序算法

public class Bubble_Sort {

public static void Bubble_Sort(int [] arr ,int n){

for(int i = 0; i < n-1;i++){  //记录循环的次数
boolean flag = false;  //哨兵，判断元素是否已经有顺序了
for(int j = 0;j < n - i-1;j++){
if(arr[j+1] < arr[j]){
//交换位置
swap(arr,j,j+1);
flag = true;
}
}
if(!flag){
break;
}
}
}

private static void swap(int[] arr, int j, int i) {

int tmp = arr[j];
arr[j] = arr[i];
arr[i] = tmp;
}
}

public class Insert_Sort {

public static void insert_Sort(int [] arr,int n){
for(int i =1;i<n;i++){
int j = i - 1;
int tmp = arr[i];
while(j>=0 && arr[j] > tmp){
arr[j+1] = arr[j];
j--;
}
arr[j+1] = tmp;
}
}
}

public class Quick_Sort {

private static int cutOff = 2;  //设置元素个数，进行切换排序
//对外提供的接口
public static void quick_Sort(int arr[], int n) {
quick_Sort(arr, 0, n - 1);
}

//内部实现排序
private static void quick_Sort(int arr[], int left, int right) {

if (cutOff <= right - left) {  //元素个数大于阈值时候，进行快速排序
// 使用快速排序
int pivot = median(arr, left, right);  //获取中间位置元素
int i = left;
int j = right - 1;
for (;;) {
while (arr[++i] < pivot) {  //从左到右寻找大于pivot的元素位置

}
while (arr[--j] > pivot) { //从右到左寻找小于pivot的元素位置

}
if (i < j) {  //进行元素交换
swap(arr, i, j);
} else {  //没有这样的元素对，结束循环
break;
}
}
swap(arr, i, right - 1);
quick_Sort(arr, left, i - 1);  //进行左边分组递归
quick_Sort(arr, i + 1, right); //进行右边分组递归
} else {
// 使用直接插入排序
insert_Sort(arr, left, right - left + 1);
}
}

public static void insert_Sort(int arr[], int start, int n) {

for (int i = start + 1; i <= n + start - 1; i++) {
int j = i - 1;
int tmp = arr[i];
while (j >= start && arr[j] > tmp) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = tmp;
}
}

private static int median(int arr[], int left, int right) {
int mid = (left + right) >> 1;
// 获取中间的位置
if (arr[left] > arr[mid]) {
swap(arr, left, mid);
}
if (arr[left] > arr[right]) {
swap(arr, left, right);
}
if (arr[mid] > arr[right]) {
swap(arr, mid, right);
}
swap(arr, mid, right - 1);
return arr[right - 1];
}

private static void swap(int arr[], int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}

选择排序

public class Select_Sort {

public static void selectSort(int arr[],int n){
for(int i = 0; i < n-1;i++){
int k = i;
//找到最小值====选择排序的瓶颈之处，寻找最小值的时间复杂度为O(n)  ===进行改进利用堆，实现最小堆，时间复杂度为O(log n)
for(int j = i;j< n;j++){
if(arr[k] > arr[j]){
k = j;
}
}
//交换数据
if(k != i){
int tmp = arr[i];
arr[i] = arr[k];
arr[k] = tmp;
}
}
}
}

希尔排序

public class Shell_Sort {

public static void shellSort(int [] arr,int n){
int gap = n / 2;
int tmp  = 0;
int j = 0;
while(gap > 0){
for(int i = gap;i < n;i++){
j = i - gap;
tmp = arr[i];
//分组比较
while(j>=0 && arr[j] > tmp){
//实现交换
arr[j+gap] = arr[j];
j = j - gap;
}
arr[j+gap] = tmp;
j = j - gap;
}
gap /= 2;
}
}

}