目录
定义通用方法
生成指定长度的数组
java
/**
* 生成数据，指定大小
*/
public static int[] getData(int size) {
if (size <= 0) {
// 默认10个元素
size = 10;
}
int[] result = new int[size];
// 随机生成[0,1000)范围的数据放入数组中
Random random = new Random();
for (int i = 0; i < size; i++) {
result[i] = random.nextInt(1000);
}
return result;
}交换数组中两个位置上的元素
java
/**
* 交换数组中两索引位置的值
*/
public static void swap(int[] data, int i, int j) {
// 前置校验
if (data == null || data.length < 2)
return;
if (i < 0 || j < 0)
return;
if (i == j)
return;
// 实现交换的逻辑
data[i] = data[i] ^ data[j];
data[j] = data[i] ^ data[j];
data[i] = data[i] ^ data[j];
}打印数组中的所有元素
java
/**
* 打印元素
*/
public static void printData(int[] data) {
System.out.println(Arrays.toString(data));
}冒泡排序
思路
- 相邻两个元素进行比较，比较一轮之后，最右边为最大值或者最小值
- 若一共有 n 个元素进行排序，则需要比较 n-1 轮，将所有元素实现排序
具体实现
java
import java.util.Arrays;
import java.util.Random;
public class App {
// ------------定义排序方式------------
// 升序
private static final int SORT_TYPE_UP = 1;
// 降序
private static final int SORT_TYPE_DOWN = -1;
// ----------------------------------
public static void main(String[] args) {
// 需要排序的数组
int[] data = getData(20);
// 打印排序前的数组元素
printData(data);
// 调用冒泡排序算法将其进行升序排列
bubbleSort(data, SORT_TYPE_UP);
// 打印升序后的数组元素
printData(data);
// 调用冒泡排序算法将其进行降序排列
bubbleSort(data, SORT_TYPE_DOWN);
// 打印降序后的数组元素
printData(data);
}
/**
* 实现冒泡排序
*/
private static void bubbleSort(int[] data, int sortType) {
// 前置校验
if (data == null) return;
int size = data.length;
if (size < 2) return;
// 比较size-1轮
for (int i = 0; i < size - 1; i++) {
// 每一轮比较
for (int j = 0; j < size - 1 - i; j++) {
// 若当前元素大于其后一个元素，则交换元素
if (SORT_TYPE_UP == sortType ? data[j] > data[j + 1] : data[j] < data[j + 1]) {
swap(data, j, j + 1);
}
}
}
}
}选择排序
思路
- 从 0 索引开始，将其和之后的每个元素进行比较
- 根据排序方式，将大的或者小的放前面
具体实现
java
import java.util.Arrays;
import java.util.Random;
public class App {
// ------------定义排序方式------------
// 升序
private static final int SORT_TYPE_UP = 1;
// 降序
private static final int SORT_TYPE_DOWN = -1;
// ----------------------------------
public static void main(String[] args) {
// 需要排序的数组
int[] data = getData(20);
// 打印排序前的数组元素
printData(data);
// 调用选择排序算法将其进行升序排列
selectSort(data, SORT_TYPE_UP);
// 打印升序后的数组元素
printData(data);
// 调用选择排序算法将其进行降序排列
selectSort(data, SORT_TYPE_DOWN);
// 打印降序后的数组元素
printData(data);
}
/**
* 实现选择排序
*/
private static void selectSort(int[] data, int sortType) {
// 前置校验
if (data == null) return;
int size = data.length;
if (size < 2) return;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (SORT_TYPE_UP == sortType ? data[i] > data[j] : data[i] < data[j]) {
swap(data, i, j);
}
}
}
}
}插入排序
思路
- 将数据看作是分为有序和无序两组
- 遍历无序那一组数据，分别将其插入到有序那一组数据中
具体实现
java
import java.util.Arrays;
import java.util.Random;
public class App {
// ------------定义排序方式------------
// 升序
private static final int SORT_TYPE_UP = 1;
// 降序
private static final int SORT_TYPE_DOWN = -1;
// ----------------------------------
public static void main(String[] args) {
// 需要排序的数组
int[] data = getData(20);
// 打印排序前的数组元素
printData(data);
// 调用插入排序算法将其进行升序排列
insertSort(data, SORT_TYPE_UP);
// 打印升序后的数组元素
printData(data);
// 调用插入排序算法将其进行降序排列
insertSort(data, SORT_TYPE_DOWN);
// 打印降序后的数组元素
printData(data);
}
/**
* 实现插入排序
*/
private static void insertSort(int[] data, int sortType) {
// 前置校验
if (data == null) return;
int size = data.length;
if (size < 2) return;
// 默认有序的那一组数据为0索引元素，从1索引到最后都为无序的那一组
for (int i = 0; i < size - 1; i++) {
// j记录的是无序那组元素的开始下标，从这里的开始下标依次向前比较，将其放入有序那组合适位置上
for (int j = i + 1; j > 0 && (SORT_TYPE_UP == sortType ? data[j - 1] > data[j] : data[j - 1] < data[j]); j--) {
swap(data, j - 1, j);
}
}
}
}快速排序
思路
- 将索引 0 位置的元素看作基准数
- 基准数归位
具体实现
java
import java.util.Arrays;
import java.util.Random;
public class App {
// ------------定义排序方式------------
// 升序
private static final int SORT_TYPE_UP = 1;
// 降序
private static final int SORT_TYPE_DOWN = -1;
// ----------------------------------
public static void main(String[] args) {
// 需要排序的数组
int[] data = getData(20);
// 打印排序前的数组元素
printData(data);
// 调用快速排序算法将其进行升序排列
quickSort(data, 0, data.length - 1, SORT_TYPE_UP);
// 打印升序后的数组元素
printData(data);
// 调用快速排序算法将其进行降序排列
quickSort(data, 0, data.length - 1, SORT_TYPE_DOWN);
// 打印降序后的数组元素
printData(data);
}
/**
* 实现快速排序
*/
private static void quickSort(int[] data, int low, int high, int sortType) {
// 参数校验
if (data == null || data.length < 2)
return;
if (low >= high)
return;
// 定义基准数
int base = data[low];
// 定义双指针
int start = low;
int end = high;
// 只要start不等于end指针
while (start < end) {
// 只要end指针指向的元素比基准数大(具体要看排序方式)，就往前移动该指针
while (start < end && (SORT_TYPE_UP == sortType ? data[end] >= base : data[end] <= base))
end--;
// 只要start指针指向的元素比基准数小(具体要看排序方式)，就往后移动该指针
while (start < end && (SORT_TYPE_UP == sortType ? data[start] <= base : data[start] >= base))
start++;
// 交换两位置的值
swap(data, start, end);
}
// 到这里，start等于end
// 交换基准数和start指针指向的值
swap(data, low, start);
// 递归缩小范围
quickSort(data, low, start - 1, sortType);
quickSort(data, start + 1, high, sortType);
}
}归并排序
思路
- 分-治-合思想的体现
- 每次找到中间位置，使开始到中间范围有序，使中间到结束范围有序
- 不断缩小范围，使得最终所有的元素有序
具体实现
java
import java.util.Arrays;
import java.util.Random;
public class App {
// ------------定义排序方式------------
// 升序
private static final int SORT_TYPE_UP = 1;
// 降序
private static final int SORT_TYPE_DOWN = -1;
// ----------------------------------
public static void main(String[] args) {
// 需要排序的数组
int[] data = getData(20);
// 打印排序前的数组元素
printData(data);
// 调用归并排序算法将其进行升序排列
mergeSort(data, 0, data.length - 1, SORT_TYPE_UP);
// 打印升序后的数组元素
printData(data);
// 调用归并排序算法将其进行降序排列
mergeSort(data, 0, data.length - 1, SORT_TYPE_DOWN);
// 打印降序后的数组元素
printData(data);
}
/**
* 实现归并排序
*/
private static void mergeSort(int[] data, int low, int high, int sortType) {
// 参数校验
if (data == null || data.length < 2)
return;
if (low >= high)
return;
// 中间索引
int mid = (low + high) >>> 1;
// 前半部分
mergeSort(data, low, mid, sortType);
// 后半部分
mergeSort(data, mid + 1, high, sortType);
// 使其有序
merge(data, low, mid, high, sortType);
}
private static void merge(int[] data, int low, int mid, int high, int sortType) {
// 协助数组
int[] help = new int[high - low + 1];
// 定义一个辅助变量
int i = 0;
// 定义双指针
int p1 = low;
int p2 = mid + 1;
// 慢指针不超过mid，快指针不超过high
if (SORT_TYPE_UP == sortType) {
while (p1 <= mid && p2 <= high)
help[i++] = data[p1] < data[p2] ? data[p1++] : data[p2++];
} else {
while (p1 <= mid && p2 <= high)
help[i++] = data[p1] > data[p2] ? data[p1++] : data[p2++];
}
// 处理剩余数据
while (p1 <= mid)
help[i++] = data[p1++];
while (p2 <= high)
help[i++] = data[p2++];
// 将结果有序
for (i = 0; i < help.length; i++)
data[low + i] = help[i];
}
}