排序算法重要性
- 学习java必不可少要学习一下排序算法。
- 在处理数据时，想要排序也必不可少要知道那种算法更好，处理数据的时间更快。
这是我在某站找的一个图片，权当学习借鉴一下了。
到这里不得不说一下 java 的Arrays.sort()所用的排序方法了
Arrays.sort
到这里可以看出来java底层用的也是快排，但是是经过改良的。
- 经典的快排把数组分成两段，但是这个改良的是将数组分成三段
- 改良的算法是考虑到cpu的运算
快速排序
/**
* ----升序---- 快排：以第一个数为基数， 先从后往前比较：
* 小于基数则换位置，换完位置则以基数的位置为指针，以原来的位置为头指针
* 从前往后比较 大于则尾指针向前移动一位
*
* 从前往后比较： 头指针数小于基数，则位置不变，头指针向前移动 大于时
* 与基数换位置，基数指针位置为换完的位置，然后从后往前比较
*
* 直到头指针位置大于或等于尾指针位置(第一个比较完成)
*
* 将数组分成两边 在做快排，直到左右不可分
*
* @param arr
* 数组
* @param start
* 开始时间
* @param begin
* 头指针位置
* @param last
* 尾指针位置
* @return
*/
public static void sort(int[] arr, int begin, int last) {
int start = begin;
int end = last;
// 头大于等于尾 则结束
if (begin >= last) {
return;
}
// 确认基数
int x = arr[begin];
// 循环
while (begin < last) {
// 从后往前找
while (begin < last && arr[last] >= x) {
last--;
}
// 如果是在范围之内找到 则交换位置
if (begin < last) {
arr[begin] = arr[last];
// 头指针位置前进一位
begin++;
}
// 从前往后找
while (begin < last && arr[begin] <= x) {
begin++;
}
// 头指针所指的数大于基数
if (begin < last) {
arr[last] = arr[begin];
// 尾指针回退一位
last--;
}
}
// 最后begin >= last 将基数赋予begin 或 last 都可以
// 因为最后begin会在等于last时候退出循环
arr[begin] = x;
// 循环结束 表示一个数已经排序完 递归排序左右两边
// 左边递归排序
sort(arr, start, begin - 1);
// 右边递归排序
sort(arr, begin + 1, end);
}
1.快排在不改变jvm参数的情况下，最大只能排序1w-2w的值，超出会堆栈溢出。
2. 设置堆栈内存
插入排序
/**
*
* 需要插入的数与前一个数比较，
* 大于则不动，小于则与前一个数互换，然后再与前一个数比较
* 如下去一直到大于前一个数的位置
*
* @param a 传入的需排序的数组
* @param start 开始时间
* @param end 运行结束时间
* @return
*/
public static long sort(int[] arr, long start, long end) {
System.out.println("----------插入--------------");
start = System.currentTimeMillis();
//比较次数为数组长度-1(第一个数不用比较)
for(int i = 0; i < arr.length - 1; i++){
//获取当前比较数的位置
int j = i;
//获取需要插入的数
int x = arr[j+1];
//循环比较 如果 后者小于前者 则换位置
while (j >= 0 && arr[j] > x){
//换位置 将大的值放后面
arr[j+1] = arr[j];
//继续与前一个数比较
j--;
}
//比较完 将值放入前一个位置
arr[j+1] = x;
}
end = System.currentTimeMillis();
return (end - start) / 1000;
}
冒泡排序
/**
* 冒泡排序：a[i] > a[i+1] 则a[i]与a[i+1]的数据交换，否则不变
* 每一轮都会选择出一个最值，有i个数字则有i-1轮比较
* @param a 传入需要排序的数组
* @return
*/
public static long sort(int[] a, long start, long end) {
start = System.currentTimeMillis();
for (int i = 0; i < a.length; i++) { // 第一层 要比较的轮数
for (int j = 0; j < a.length - i - 1; j++) { // 第二层 每个数比较几次
if (a[j] > a[j + 1]) { // 自己不用和自己比 所以减一
int temp = a[j]; // 每一轮比较完都有一个最值出现，所以减去i
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
end = System.currentTimeMillis();
return (end - start);
}
选择排序
/**
* 选择：从数组中选择最小的数与第一个交换
* 重复步骤选择出第二第三...
* @param arr 数组
* @param start 开始时间
* @param end 结束时间
* @return
*/
public static long sort(int[] arr, long start, long end) {
start = System.currentTimeMillis();
//定义一个交互变量
int temp;
//每个位置都要选出最小的 所以有几个数 就有几轮
for (int i = 0; i < arr.length-1; i++) {
//获取地址
int min = i;
//自身不用比,i之前的数据都已经排序完，顾也不用比
for (int j = i+1; j < arr.length - 1; j++) {
//如果有比当前小的
if (arr[j] < arr[min]){
//最小的索引变化
min = j;
}
}
//有变化过
if (min != i){
temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
end = System.currentTimeMillis();
return (end - start);
}
归并排序
/**
* 归并： 将数组分为两个等长的子数组，一直分
* 直到每个数组中只有一个数，最后合并
* 左边的第一个和右边的第一个比较 小的放入temp数组的第一个
* 然后小的第二个再个另一个第一个比较，小的移过去，这就是合并
* @param a
* @param start
* @param end
*/
public static void sort(int[] arr, int start, int end) {
int mid ;
if( start < end) {
//划分子数组
mid = (start+end)/2;
//左边子数组再划分
sort(arr, start, mid);
//右边子数组再划分
sort(arr, mid+1, end);
//归并
merge(arr, start, mid, end);
}
}
public static void merge(int[] arr, int start, int mid, int end) {
//初始化数组来存放合并的数据
int[] temp = new int[end-start+1];
//左边数据的起始点
int left = start;
//右边数据的起始点
int right = mid+1;
//temp数组索引
int i = 0;
//左右边的数组已经排序完成，合并
while (left <= mid && right <= end) {
//如果在范围内 且 数小的则放入数组
if (arr[left] < arr[right]) {
temp[i++] = arr[left++];
} else {
temp[i++] = arr[right++];
}
}
//循环结束后 将剩余数据放入数组
while (left <= mid) {
temp[i++] = arr[left++];
}
while (right <= end) {
temp[i++] = arr[right++];
}
//将数组覆盖原来的数组
for (int j = 0; j < temp.length; j++) {
arr[start+j] = temp[j];
}
}
比较各种算法
public class Main {
//数组大小
static int size = 100000;
//运行开始时间
static long start;
//运行结束时间
static long end;
//初始化数组
static int[] arr;
//各种排序的时间(ms)
public static void main(String[] args) {
//Arrays.sort 默认使用快排，但是会根据数据的长度在使用升级版快排 dualpivotquicksort
System.out.println("-----------Arrays.sort-------------------");
giveNum(size);
start = System.currentTimeMillis();
Arrays.sort(arr);
end = System.currentTimeMillis();
System.out.println(end-start);
System.out.println("-----------归并---------------------------");
giveNum(size);
start = System.currentTimeMillis();
GuiBing.sort(arr, 0, arr.length-1);
end = System.currentTimeMillis();
System.out.println(end-start);
System.out.println("-----------快排---------------------------");
giveNum(size);
start = System.currentTimeMillis();
KuaiPai.sort(arr, 0, arr.length-1);
end = System.currentTimeMillis();
System.out.println(end-start);
System.out.println("-----------选择---------------------------");
giveNum(size);
System.out.println(XuanZe.sort(arr, start, end));
System.out.println("-----------冒泡---------------------------");
giveNum(size);
System.out.println(MaoPao.sort(arr, start, end));
System.out.println("-----------插入---------------------------");
giveNum(size);
System.out.println(ChaRu.sort(arr, start, end));
}
// 赋值
public static void giveNum(int size) {
arr = new int[size];
Random random = new Random();
for (int i = 0; i < arr.length; i++) {
arr[i] = random.nextInt(100);
}
}
}
当size为10w时
由此可见jdk自带的排序还是非常好的。我看了一下底层实现，它在不同的长度会用不同的排序方法以达到最佳的效果。
扫一扫
190
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
