选择排序
class Demo {
public static void main(String[] args) {
int[] arr = new int[6];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) (Math.random() * 20);
}
System.out.println("排序前:");
for (int item : arr) {
System.out.println(item);
}
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) { // 找到最小元素的下标
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
swap(arr, i, minIndex); // 将当前最小的元素放到正确位置
}
System.out.println("排序后:");
for (int item : arr) {
System.out.println(item);
}
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
冒泡排序
class Demo {
public static void main(String[] args) {
int[] arr = new int[10];
boolean isSort = true; // 是否还需要排序
geneArr(arr);
System.out.println("排序前:");
listArr(arr);
for (int i = 0; i < arr.length - 1; i++) { // 排序逻辑
isSort = false;
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
isSort = true;
swap(arr, j, j + 1);
}
}
if (!isSort) { // isSort为false,说明本次内循环没有产生元素交换,则后面的元素已经有序
break;
}
}
System.out.println("排序后:");
listArr(arr);
}
/**
* 生成数组
*
* @param arr
*/
private static void geneArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) (Math.random() * 20);
}
}
/**
* 遍历输出数组中每个元素
*
* @param arr
*/
private static void listArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
/**
* 交换数组中元素位置
*
* @param arr
* @param i
* @param j
*/
private static void swap(int[] arr, int i, int j) {
// 异或运算还可以理解为“无进位相加”
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
}
注意:若a[i]==a[j],则不能用异或预算,否则会洗成零
归并排序
package p3;
import utils.ArrUtil;
class MergeSort {
public static void main(String[] args) {
int[] arr = new int[6];
ArrUtil.geneArr(arr, 10);
if (arr == null || arr.length < 2) {
return;
}
System.out.println("排序前");
ArrUtil.listArr(arr);
process(arr, 0, arr.length - 1);
System.out.println("排序后");
ArrUtil.listArr(arr);
}
private static void process(int arr[], int left, int right) {
if (left == right) {
return;
}
int mid = left + ((right - left) >> 1);
process(arr, left, mid);
process(arr, mid + 1, right);
merge(arr, left, mid, right);
}
private static void merge(int[] arr, int left, int mid, int right) {
int[] temp = new int[right - left + 1]; // 归并排序需要开辟一个新的数组空间
int tempIndex = 0;
int leftIndex = left;
int rightIndex = mid + 1;
while (leftIndex <= mid && rightIndex <= right) { // leftIndex、rightIndex只会向后移动,故都不能超出自己的右边界
if (arr[leftIndex] <= arr[rightIndex]) {
temp[tempIndex++] = arr[leftIndex++];
} else {
temp[tempIndex++] = arr[rightIndex++];
}
}
while (leftIndex <= mid) {
temp[tempIndex++] = arr[leftIndex++];
}
while (rightIndex <= right) {
temp[tempIndex++] = arr[rightIndex++];
}
for (int i = 0; i < temp.length; i++) {
arr[left + i] = temp[i];
}
}
}
快速排序
package p3;
import utils.ArrUtil;
class QuickSortClass {
public static void main(String[] args) {
int[] arr = new int[5];
ArrUtil.geneArr(arr, 10);
if (arr == null || arr.length < 2) {
return;
}
System.out.println("排序前:");
ArrUtil.listArr(arr);
quickSort(arr, 0, arr.length - 1);
System.out.println("排序后");
ArrUtil.listArr(arr);
}
private static void quickSort(int[] arr, int left, int right) {
if (left < right) {
// 快排每次开始的时候随机选取一个数,与最后一个数交换,减少最坏情况发生次数
swap(arr, left + (int) (Math.random() * (right - left + 1)), right);
// 返回的是最靠近小于区域的枢轴与最靠近大于区域的枢轴的下标
int[] boundary = partition(arr, left, right);
quickSort(arr, left, boundary[0] - 1); // 进行小于区域排序
quickSort(arr, boundary[1] + 1, right); // 进行大于区域排序
}
}
private static int[] partition(int[] arr, int left, int right) {
int lessBoundary = left - 1; // 小于区边界
int moreBoundary = right; // 大于区边界
while (left < moreBoundary) {
// 这里的right是不变动的,充当枢轴的下标
if (arr[left] < arr[right]) { // 当目前的left对应的元素小于枢轴的时候,将当前left对应的元素与小于区域边界的后一个元素交换,left接着往后走
swap(arr, ++lessBoundary, left++);
} else if (arr[left] > arr[right]) { // 当目前的left对应的元素大于枢轴的时候,将当前left对应的元素与大于区域边界前一个元素交互,left不动
swap(arr, left, --moreBoundary);
} else { // 当前值等于枢轴值,只有left往后走,没有交互操作
left++;
}
}
swap(arr, moreBoundary, right);
return new int[] { lessBoundary + 1, moreBoundary };
}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}