冒泡排序:
import java.util.Arrays;
/**
* 是将无序a[0],a[1]...a[n],将其升序排序,比较a[0].a[1]的值,若结果为1,则交换两者的值,否则不变,接着继续向下比较.最后比较a[n-1].a[n]的结果,结束后,a[n]的值为当前数组中最大值.接着继续将a[1]~a[n-1]进行比较.一共处理n-1轮后, 就是以升序排列
*
* 优点: 稳定
* 缺点: 耗时长,每次只是移动两个相邻的数据做对比
* @Description Java冒泡排序
* @Author : Dy yimting@yeah.net
* @Date : 2019/3/26,14:06
* @Project : Java_Sort
* @Version : 1.0
**/
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {34, 2, 146, 76, 45, 3, 6, 7};
long start = System.nanoTime();
sort(arr);
long end = System.nanoTime();
System.out.println("排序后 : " + Arrays.toString(arr));
System.out.println("运行时间:" + (end - start) + " ns");
}
/**
* @param arr 传入的数组
* 第一次外层循环 ,和第一层内层循环内部结果
* 34 2 146 76 45 3 6 7
* 2 34 146 76 45 3 6 7
* 2 34 146 76 45 3 6 7
* 2 34 76 146 45 3 6 7
* 2 34 76 45 146 3 6 7
* 2 34 76 45 3 146 6 7
* 2 34 76 45 3 6 146 7
* 2 34 76 45 3 6 7 146
* .....................
*/
public static void sort(int[] arr) {
//外侧循环控制整个循环的次数
for (int i = 0; i < arr.length - 1; i++) {
// 内侧循环对比两个值
for (int j = 0; j < arr.length - 1 - i; j++) {
//如果第一个值比第二个值大
//第一个值就与第二个值进行交换
if (arr[j] > arr[j + 1]) {
arr[j] = arr[j] ^ arr[j + 1];
arr[j + 1] = arr[j] ^ arr[j + 1];
arr[j] = arr[j] ^ arr[j + 1];
}
}
}
}
}
选择排序 :
import java.util.Arrays;
/**
* 从所有序列中先找到最小的，然后放到第一个位置。之后再看剩余元素中最小的，放到第二个位置……以此类推，就可以完成整个的排序工作。
* 选择排序是不稳定的排序方法
*
* @Description Java选择排序
* @Author : Dy yimting@yeah.net
* @Date : 2019/3/26,14:47
* @Project : bigdata
* @Version : 1.0
**/
public class SelectSort {
public static void main(String[] args) {
int[] arr = {34, 2, 146, 76, 45, 3, 6, 7, 6, 6};
long start = System.nanoTime();
sort(arr);
long end = System.nanoTime();
System.out.println("排序后 : " + Arrays.toString(arr));
System.out.println("运行时间:" + (end - start) + " ns");
}
public static void sort(int[] arr) {
//第一轮循环
for (int i = 0; i < arr.length - 1; i++) {
int small = i;
//取出数组中的最小值
for (int j = small + 1; j < arr.length; j++) {
//判断循环到的值进行对比, 取出最小值的下标
if (arr[small] > arr[j]) {
small = j;
}
}
//最小值与循环到的值的位置进行交换
if (i != small) {
arr[small] = arr[small] ^ arr[i];
arr[i] = arr[small] ^ arr[i];
arr[small] = arr[small] ^ arr[i];
}
}
}
}
快速排序 :
import java.util.Arrays;
/**
* @Description 经典快排: 拿出一个值作为基准值, 与基准值做比较
* @Author : Dy yimting@yeah.net
* @Date : 2019-03-08 10:01:48
* @Project : Java_Sort
* @Version : 1.0
**/
public class QuickSort {
public static void main(String[] args) {
int[] arr = {12, 4, 2, 5, 79, 6, 6, 6};
long start = System.nanoTime();
sort(arr, 0, arr.length - 1);
System.out.println("排序结果 :" + Arrays.toString(arr));
long end = System.nanoTime();
System.out.println("运行时间:" + (end - start) / 100000 + " ms");
}
/**
* 对arr[first] - arr[last] 进行排序
*
* @param arr 需要排序的数组
* @param first 数组中的起始值
* @param last 数组中的最后
*/
private static void sort(int[] arr, int first, int last) {
//判断下标是否存在有问题
if (first >= last) {
return;
}
//赋予变量, 接收,便于更改
int i = first;
int j = last;
while (i < j) {
//取出第一个元素作为基准值
int one = arr[i];
/*-----------右侧的轮询------------*/
//如果 最后一个值大于等于基准值 或者 i坐标 小于 j坐标 (防止坐标冲突)
while (arr[j] >= one && i < j) {
//如果满足条件的话, 需要将指针,向左移动
j--;
}
//进行交换
swap(arr, i, j);
/*-----------左侧的轮询------------*/
//如果 第一个值 小于等于基准值或者 i坐标 小于 j坐标 (防止坐标冲突)
while (arr[i] <= one && i < j) {
//如果满足条件的话, 需要将指针,向右移动
i++;
}
//进行交换
swap(arr, i, j);
}
/*-----------进行递归操作------------*/
//对于基准左侧的集合 重复操作
sort(arr, first, i - 1);
//对于基准右侧的集合 重复操作
sort(arr, i + 1, last);
}
/**
* 单独提出一个方法用来进行数值的交换
* 这个方式会使运行速度降低
*
* @param arr 调用方法时需要进行交换的数组
* @param i 坐标
* @param j 坐标
*/
static void swap(int[] arr, int i, int j) {
if (i < j) {
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
}
}
