import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
/*
* 快速排序：对冒泡排序的一种改进
* 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小
* 再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到有序序列
*
* 快速排序过程
* 原始：-9，78，0，23，-567，70
* 设置左右索引，与中间值比较 (left + right)/2=5/2=2，即arr[2] = 0为中间值
* 交换后：-9，-567，0，23，78，70
* 向左递归：-567,-9,0,23,78,70
* 向右递归：-567,-9,0,23,70,78
*/
public class QuickSorting_ {
public static void main(String[] args) {
int[] arr = {-9,78,0,23,-567,70};
System.out.println("排序前");
System.out.println(Arrays.toString(arr));
quickSort(arr, 0, arr.length-1);
System.out.println("排序后");
System.out.println(Arrays.toString(arr));
//测试快速排序的速度
int[] arr2 = new int[80000];
for(int i = 0;i < 80000;i++) {
arr2[i] = (int)(Math.random() * 80000);
}
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间=" + date1Str);
quickSort(arr2, 0, arr2.length-1);
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间=" + date2Str);
}
public static void quickSort(int[] arr,int left,int right) {
int l = left;//左下标
int r = right;//右下标
int pivot = arr[(left + right) / 2];//中间值
int temp = 0;//辅助变量
//while循环的目的是让 比pivot值小的放左边，比pivot值大的放右边
while(l < r) {
//在pivot的左边一直找，找到大于等于pivot值才退出
while(arr[l] < pivot) {
l += 1;
}
//在pivot的右边一直找，找到小于等于pivot值才退出
while(arr[r] > pivot) {
r -= 1;
}
//如果成立，说明已经达到目的：比pivot值小的放左边，比pivot值大的放右边
if (l >= r) {
break;
}
//交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//如果交换完后，发现arr[l] == pivot，前移r--
if (arr[l] == pivot) {
r -= 1;
}
//如果交换完后，发现arr[r] == pivot,后移l++
if (arr[r] == pivot) {
l += 1;
}
}
//如果l == r,必须l++,r--,否则出现栈溢出
if (l == r) {
l += 1;
r -= 1;
}
//向左递归
if (left < r) {
quickSort(arr, left, r);
}
//向右递归
if (right > l) {
quickSort(arr, l, right);
}
}
}
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
/*
* 归并排序
* 利用归并的思想实现排序，采用经典的分治策略
* （分治：将问题分成一些小问题后递归求解，治即将分阶段得到的各个答案“修补”在一起，即分而治之）
*
* 归并排序过程
* 原始：8，4，5，7，1，3，6，2
* 分：
* （8，4，5，7），（1，3，6，2）
* (8，4),(5,7),(1,3),(6,2)
* (8)(4)(5)(7)(1)(3)(6)(2)
* 治:将两个已经有序的子序列合并成一个有序序列，合并了7次
* (4,8)(5,7)(1,3)(2,6)
* (4,5,7,8),(1,2,3,6)
* (1,2,3,4,5,6,7,8)
*/
public class MergeSorting_ {
public static void main(String[] args) {
int[] arr = {8,4,5,7,1,3,6,2};
int[] temp = new int[arr.length];//需要一个额外空间
System.out.println("排序前");
System.out.println(Arrays.toString(arr));
mergeSort(arr, 0, arr.length - 1, temp);
System.out.println("排序后");
System.out.println(Arrays.toString(arr));
//测试归并排序的速度
int[] arr2 = new int[80000];
for(int i = 0;i < 80000;i++) {
arr2[i] = (int)(Math.random() * 80000);
}
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间=" + date1Str);
mergeSort(arr2, 0, arr.length - 1, temp);
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间=" + date2Str);
}
//分+合方法
public static void mergeSort(int[] arr,int left,int right,int[] temp) {
if (left < right) {
int mid = (left + right) / 2;//中间索引
//向左递归进行分解
mergeSort(arr, left, mid, temp);
//向右递归进行分解
mergeSort(arr, mid + 1, right, temp);
//每分解一次就合并一次
merge(arr, left, mid, right, temp);
}
}
//合并的方法
//arr：排序的原始数组，left：左边有序序列的初始索引，mid：中间索引，right：右边索引，temp：临时数组
public static void merge(int[] arr,int left,int mid,int right,int[] temp) {
int i = left;//初始化i，表示左边有序序列的初始索引
int j = mid + 1;//初始化j，表示右边有序序列的初始索引
int t = 0;//指向temp数组的索引
//1.先把左右两边的有序序列按照规则填充到temp数组，直到有一方的有序序列处理完毕
while(i <= mid && j <= right) {
//如果左边有序序列的当前元素 小于 右边有序序列的当前元素，将左边的当前元素拷贝到temp数组，同时后移t,i
if (arr[i] <= arr[j]) {
temp[t] = arr[i];
t += 1;
i += 1;
}else {//反之将右边的当前元素拷贝到temp数组
temp[t] = arr[j];
t += 1;
j += 1;
}
}
//2.把剩余的数据依次全部填充到temp
while(i <= mid) {//左边有序序列还有剩余元素
temp[t] = arr[i];
t += 1;
i += 1;
}
while(j <= right) {//右边有序序列还有剩余元素
temp[t] = arr[j];
t += 1;
j += 1;
}
//3.将temp数组元素拷贝到arr
//注：并不是每次都拷贝所有元素
t = 0;
int tempLeft = left;
//第一次合并：tempLeft = 0，right = 1
//第二次合并：tempLeft = 2,right = 3
//第三次合并：tempLeft = 0,right = 3
//......
//最后：tempLeft = 0,right = 7
//System.out.println("tempLeft=" + tempLeft + "\tright=" + right);
while(tempLeft <= right) {
arr[tempLeft] = temp[t];
t += 1;
tempLeft += 1;
}
}
}
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
/*
* 基数排序
* 通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序作用
* 基数排序是典型的空间换时间，占用内存很大，当对海量数据排序时，容易造成OutOfMemoryError
*
* 将所有待比较数值统一为同样的数位长度，数位较短的数前面补零，从最低为开始，依次进行一次排序
* 这样从最低位排序一直到最高位排序完成后，就变成了有序序列
*
* 基数排序过程
* 原始：53,3,542,748,14,214
* 第一轮排序
* 1.将每个元素的个位数取出，看这个数应放在哪个桶（一个一维数组，共十个桶[0，1，2，3...9]）中
* 第二个桶：542
* 第三个桶：53，3
* 第四个桶：14，214
* 第八个桶：748
* 2.按照桶的顺序（一维数组的下标）依次取出数据，放入原来数组
* 取出后：542，53，3，14，214，748
*
* 第二轮排序
* 1.将每个元素的十位数取出，看这个数应放在哪个桶（一个一维数组，共十个桶[0，1，2，3...9]）中
* 第0个桶：3
* 第一个桶：14，214
* 第四个桶：542，748
* 第五个桶：53
* 2.按照桶的顺序（一维数组的下标）依次取出数据，放入原来数组
* 取出后：3,14,214,542,748,53
*
* 第三轮排序
* 1.将每个元素的百位数取出，看这个数应放在哪个桶（一个一维数组，共十个桶[0，1，2，3...9]）中
* 第0个桶：3，14，53
* 第二个桶：214
* 第五个桶：542
* 第七个桶：748
* 2.按照桶的顺序（一维数组的下标）依次取出数据，放入原来数组
* 取出后：3，14，53，214，542，748
*
* 采取几轮排序取决于最大数的位数
*
*/
public class RadixSorting_ {
public static void main(String[] args) {
int[] arr = {53,3,542,748,14,214};
System.out.println("排序前");
System.out.println(Arrays.toString(arr));
radixSort(arr);
System.out.println("排序后");
System.out.println(Arrays.toString(arr));
//测试基数排序的速度
int[] arr2 = new int[80000];
for(int i = 0;i < 80000;i++) {
arr2[i] = (int)(Math.random() * 80000);
}
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间=" + date1Str);
radixSort(arr2);
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间=" + date2Str);
}
//基数排序方法
public static void radixSort(int[] arr) {
//定义一个二维数组，表示10个桶，每个桶是一个一维数组
//为了防止数据溢出，每个一维数组大小定为arr.length
int[][] bucket = new int[10][arr.length];
//为了记录桶中实际存放了多少个数据，定义一个一维数组来记录各个桶的每次放入数据个数
//即bucketElementCounts[0]，记录的是bucket[0]的桶的数据个数
int[] bucketElementCounts = new int[10];
/* //第1轮（个位）
for(int j = 0;j < arr.length;j++) {
//1.取出每个元素的个位值
int digitOfElement = arr[j] / 1 % 10;
//放入对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//2.按照桶的顺序（一维数组的下标）依次取出数据，放入原来数组
int index = 0;
//遍历每一个桶，将桶中数据放入原数组
for(int k = 0;k < bucketElementCounts.length;k++) {
//如果桶中有数据，就放入到原数组
if(bucketElementCounts[k] != 0) {
//循环该桶（即第k个一维数组），放入
for(int l = 0;l < bucketElementCounts[k];l++) {
//取出元素放入arr
arr[index] = bucket[k][l];
index++;
}
}
//处理完毕后，需要将每个bucketElementCounts[k]置零
bucketElementCounts[k] = 0;
}
System.out.println("第一轮排序" + Arrays.toString(arr));
//===========================================================================
//第2轮（十位）
for(int j = 0;j < arr.length;j++) {
//1.取出每个元素的十位值
int digitOfElement = arr[j] / 10 % 10;
//放入对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//2.按照桶的顺序（一维数组的下标）依次取出数据，放入原来数组
index = 0;
//遍历每一个桶，将桶中数据放入原数组
for(int k = 0;k < bucketElementCounts.length;k++) {
//如果桶中有数据，就放入到原数组
if(bucketElementCounts[k] != 0) {
//循环该桶（即第k个一维数组），放入
for(int l = 0;l < bucketElementCounts[k];l++) {
//取出元素放入arr
arr[index] = bucket[k][l];
index++;
}
}
//处理完毕后，需要将每个bucketElementCounts[k]置零
bucketElementCounts[k] = 0;
}
System.out.println("第二轮排序" + Arrays.toString(arr));
//===========================================================================
//第3轮（百位）
for(int j = 0;j < arr.length;j++) {
//1.取出每个元素的百位值
int digitOfElement = arr[j] /100 % 10;
//放入对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//2.按照桶的顺序（一维数组的下标）依次取出数据，放入原来数组
index = 0;
//遍历每一个桶，将桶中数据放入原数组
for(int k = 0;k < bucketElementCounts.length;k++) {
//如果桶中有数据，就放入到原数组
if(bucketElementCounts[k] != 0) {
//循环该桶（即第k个一维数组），放入
for(int l = 0;l < bucketElementCounts[k];l++) {
//取出元素放入arr
arr[index] = bucket[k][l];
index++;
}
}
//处理完毕后，需要将每个bucketElementCounts[k]置零
bucketElementCounts[k] = 0;
}
System.out.println("第三轮排序" + Arrays.toString(arr));
*/
//根据上述推到过程，优化代码
//得到数组中最大数的位数
int max = arr[0];//假定第一个数为最大数
for(int i = 1;i < arr.length;i++) {
if (arr[i] > max) {
max = arr[i];
}
}
//得到位数
int maxLength = (max + "").length();
for(int i = 0,n = 1;i < maxLength;i++,n*=10) {
//个位、十位、百位...
for(int j = 0;j < arr.length;j++) {
//1.取出每个元素的位值
int digitOfElement = arr[j] / n % 10;
//放入对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
//2.按照桶的顺序（一维数组的下标）依次取出数据，放入原来数组
int index = 0;
//遍历每一个桶，将桶中数据放入原数组
for(int k = 0;k < bucketElementCounts.length;k++) {
//如果桶中有数据，就放入到原数组
if(bucketElementCounts[k] != 0) {
//循环该桶（即第k个一维数组），放入
for(int l = 0;l < bucketElementCounts[k];l++) {
//取出元素放入arr
arr[index] = bucket[k][l];
index++;
}
}
//处理完毕后，需要将每个bucketElementCounts[k]置零
bucketElementCounts[k] = 0;
}
//System.out.println("第"+(i+1)+"轮排序" + Arrays.toString(arr));
}
}
}
/*
* 常用排序算法总结与比较
*
* 相关术语
* 1.稳定：如果a原本排在b前面，且a=b,排序之后a仍然排在b前面
* 2.不稳定：如果a原本排在b前面，且a=b,排序之后a可能排在b后面
* 3.内排序：所有排序操作都在内存中完成
* 4.外排序：由于数据过大，把数据放在磁盘中，排序通过磁盘和内存完成
* 5.时间复杂度：一个算法执行所耗费的时间
* 6.空间复杂度：运行完程序所需内存的大小
* 7.n:数据规模
* 8.k: "桶"的个数
* 9.In-place:不占用额外内存
* 10.Out-place:占用额外内存
*/
5993
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
