高龄白菜java学习第八十九天（java数据结构和算法（10））
快速排序
代码实现
package Sort;
import java.util.Arrays;
//快速排序
public class QuickSort {
public static void main(String[] args) {
int[] arr = {
-9,78,0,23,-567,70};
quick(arr,0, arr.length-1);
System.out.println(Arrays.toString(arr));
}
//最左边和最右边的索引
public static void quick(int[] arr,int left,int right){
int l =left;
int r = right;
int pivot = arr[(r+l)/2];//中轴值
int temp = 0;
//while循环的目的是把比pivot小的值放在左边
while (l<r){
//在pivot左边一直找
while (arr[l]<pivot){
l++;//如果出现比中轴值大的情况，下标就会卡在这里
}
while (arr[r]>pivot){
r--;
}
if (l>=r){
//如果此条件成立，说明pivot左边的值全是小于等于、右边全是大于等于pivot的值
break;
}
//交换
temp=arr[l];
arr[l]=arr[r];
arr[r]=temp;
//可能中间会有若干个值相同的元素，需要--前移一次再做判断,否则会死循环
if (arr[l]==pivot){
r--;
}
if (arr[r]==pivot){
l++;
}
}
//如果l==r,必须r--,l++，否则会出现栈溢出
if (l==r){
r--;
l++;
}
//左递归
if (left<r){
quick(arr,left,r);
}
//右递归
if (right>l){
quick(arr,l,right);
}
}
}
代码实现
package Sort;
import java.util.Arrays;
//归并排序
public class MergeSort {
public static void main(String[] args) {
int[] arr = {
8, 4, 5, 7, 1, 3, 6, 2};
int[] temp = new int[arr.length];
mergeSort1(arr,0,arr.length - 1,temp);
System.out.println(Arrays.toString(arr));
}
//分+合方法
public static void mergeSort1(int[] arr, int left, int right, int[] temp) {
if (left < right) {
//分到二者重合，即只剩一个数
int mid = (left + right)/2;
//向左递归进行分解
mergeSort1(arr, left, mid, temp);
//右递归
mergeSort1(arr, mid + 1, right, temp);
//到合并
merge(arr, left, mid, right, temp);
}
}
//合并的方法
/**
* @param arr 原始数组
* @param left 初始索引
* @param mid 中间索引
* @param right 右边索引
* @param temp 做中转的数组
*/
public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
int i = left;
int j = mid + 1;
int t = 0;//临时数组的当前索引
//先把左右两边这2个有序数组按规则填充到temp数组中，直到一方处理完毕
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[t] = arr[i];
t+=1;
i++;
} else {
temp[t] = arr[j];
t+=1;
j++;
}
}
//另一方将剩余的元素全部填入temp中
while (i<=mid){
temp[t]=arr[i];
t+=1;
i++;
}
while (j<=right){
temp[t]=arr[j];
t+=1;
j++;
}
//将temp数组中的元素拷贝到arr
//注：不是每次都拷贝所有
t=0;
int tempLeft=left;
while (tempLeft<=right){
//第一次合并tempLeft=0，right=1
arr[tempLeft]=temp[t];
t++;
tempLeft++;
}
}
}
package Sort;
import java.util.Arrays;
//桶排序
public class RadixSort {
public static void main(String[] args) {
int[] arr = {
53, 3, 542, 748, 14, 214};
radix(arr);
System.out.println(Arrays.toString(arr));
}
public static void radix(int[] arr) {
//得到数组中最大数的位数
int max = arr[0];
for (int m = 1; m < arr.length; m++) {
if (arr[m] > max) {
max = arr[m];
}
}
int maxLength = (max + "").length();
//定义一个二维数组，表示10个桶，每个桶代表一个一维数组
//为了防止数组的数据溢出，每个桶的大小定义为arr.length
//因此，桶排序是空间换时间的经典算法
int[][] bucket = new int[10][arr.length];
//为了记录每个桶中实际存放了多少数据，定义一个一维数组
int[] eleCounts = new int[10];
for (int n = 0, o = 1; n < maxLength; n++,o*=10) {
for (int j = 0; j < arr.length; j++) {
int digitEle = arr[j] / o % 10;
//放入对应的桶
bucket[digitEle][eleCounts[digitEle]] = arr[j];
//对应桶数据个数+1
eleCounts[digitEle]++;
}
//按照桶的顺序把数据取回来
int index = 0;
//外层遍历桶、内层遍历桶里的数据
for (int i = 0; i < eleCounts.length; i++) {
//就是10
if (eleCounts[i] != 0) {
for (int j = 0; j < eleCounts[i]; j++) {
arr[index] = bucket[i][j];
index++;
}
}
//重要：一轮结束后，要将计数数组中对应的数据数量重置
eleCounts[i] = 0;
}
}
// //第一轮（针对个位）
// //定义一个二维数组，表示10个桶，每个桶代表一个一维数组
// //为了防止数组的数据溢出，每个桶的大小定义为arr.length
// //因此，桶排序是空间换时间的经典算法
// int[][] bucket = new int[10][arr.length];
// //为了记录每个桶中实际存放了多少数据，定义一个一维数组
// int[] eleCounts = new int[10];
// for (int j = 0; j < arr.length; j++) {
// int digitEle = arr[j] % 10;//个位
// //放入对应的桶
// bucket[digitEle][eleCounts[digitEle]]=arr[j];
// //对应桶数据个数+1
// eleCounts[digitEle]++;
//
// }
// //按照桶的顺序把数据取回来
// int index = 0;
// //外层遍历桶、内层遍历桶里的数据
// for (int i = 0; i < eleCounts.length; i++) {//就是10
// if (eleCounts[i]!=0){
// for (int j = 0; j < eleCounts[i]; j++) {
// arr[index]=bucket[i][j];
// index++;
// }
// }
// }
}
}
