本文详细介绍了冒泡排序、快速排序、插入排序、希尔排序（包括交换式和移位法）、选择排序、堆排序（大顶堆）、基数排序（两阶段排序）以及归并排序的过程和实现代码，帮助读者理解各种排序算法的工作原理和应用场景。
1，冒泡排序
public static void BubbleSort(int[] arr) {
boolean flag = false;
for (int i = 0; i < arr.length - 1; i++) {
int temp = 0;
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
flag = true;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
if (flag == false) {
break;
}
System.out.println(Arrays.toString(arr));
flag = false;
}
}
2，快速排序
// 写一个递归调用方法扫描左右两边
public static void quickSort(int arr[], int left, int right) {
if (left < right) {// 这个判断一定要加 不然就一直扫描左侧
int mid = get_mid(arr, left, right);
quickSort(arr, left, mid - 1);// 扫描左侧
quickSort(arr, mid + 1, right);// 扫描右侧
}
}
// 对那个中间数进行分组，小于中间数的放在左边 大于的放在右边
public static int get_mid(int arr[], int left, int right) {
int p = arr[left];// 定义最左边的那个数为中间数
while (left < right) {
// 从右边找第一个小于p的值
while (arr[right] >= p && left < right) {
right--;
}
// 找到则放到p的左边
if (arr[right] < p) {
arr[left] = arr[right];
}
// 从左边找第一个大于p的值
while (arr[left] <= p && left < right) {
left++;
}
// 找到则放在p的右边
if (arr[left] > p) {
arr[right] = arr[left];
}
}
// left=right说明左右指针相遇 扫描完毕
if (left >= right) {
arr[left] = p;
}
return left;// 返回中间数
}
3，插入排序
不断i++，增加有序表的长度，不断维护有序表（把新元素插入到该插入的位置），直到有序表和数组一样长，则数组完成排序
//第一轮
//定义待插入的数
int insertVal = arr[1];
int insertIndex=1-1;//arr[1]前面这个数的下标
//1，给insertVal找插入的位置
//2，说明待插入的数还没有找到插入位置
//3，需要将arr[insertIndex]后移
while(insertIndex >= 0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1]=arr[insertIndex];
insertIndex--;
}
//当退出while循环时，说明插入位置找到了，insertIndex + 1
arr[insertIndex + 1]=insertVal;
System.out.println(Arrays.toString(arr));
//第二轮
insertVal = arr[2];
insertIndex=2-1;//arr[1]前面这个数的下标
//1，给insertVal找插入的位置
//2，说明待插入的数还没有找到插入位置
//3，需要将arr[insertIndex]后移
while(insertIndex >= 0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1]=arr[insertIndex];
insertIndex--;
}
//当退出while循环时，说明插入位置找到了，insertIndex + 1
arr[insertIndex + 1]=insertVal;
System.out.println(Arrays.toString(arr));
//插入排序
public static void insertSort(int[] arr){
for(int i=1;i<arr.length;i++){
//定义待插入的数
int insertVal = arr[i];
int insertIndex=i - 1;//arr[1]前面这个数的下标
//1，给insertVal找插入的位置
//2，说明待插入的数还没有找到插入位置
//3，需要将arr[insertIndex]后移
while(insertIndex >= 0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1]=arr[insertIndex];
insertIndex--;
}
//当退出while循环时，说明插入位置找到了，insertIndex + 1
//判断是否需要赋值
if(insertIndex + 1 != i){
arr[insertIndex + 1]=insertVal;
}
}
}
4，希尔排序
希尔排序是非稳定排序算法
// 对交换式的希尔排序进行优化-》移位法
//每组使用简单插入排序
public static void shellSort2(int[] arr) {
// 增量gap，并逐步的减小增量
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
// 从第gap个元素，逐个对其所在组进行直接插入排序
for (int i = gap; i < arr.length; i++) {
int j = i;
int temp = arr[j];
if (temp < arr[j - gap]) {
while (j - gap >= 0 && temp < arr[j - gap]) {
// 移动
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
}
}
}
// 希尔排序 交换法
public static void shellSort(int[] arr) {
int temp = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
// 遍历各组中所有的元素（共5组，每组有两个元素），步长为5
for (int j = i; j - gap >= 0; j -= gap) {
// 如果当前元素大于加上步长后的那个元素，说明交换
if (arr[j - gap] > arr[j]) {
temp = arr[j];
arr[j] = arr[j - gap];
arr[j - gap] = temp;
}
}
}
// System.out.println(Arrays.toString(arr));
}
-----------------------------------------------------------------------
// 第一轮 // 因为第一轮是将10个数据分为5组
for (int i = 5; i < arr.length; i++) {
// 遍历各组中所有的元素（共5组，每组有两个元素），步长为5
for (int j = i; j - 5 >= 0; j -= 5) {
// 如果当前元素大于加上步长后的那个元素，说明交换
if (arr[j - 5] > arr[j]) {
temp = arr[j];
arr[j] = arr[j - 5];
arr[j - 5] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
// 第二轮 // 因为第一轮是将10个数据分为5/2=2组
for (int i = 2; i < arr.length; i++) {
// 遍历各组中所有的元素（共5组，每组有两个元素），步长为5
for (int j = i; j - 2 >= 0; j -= 2) {
// 如果当前元素大于加上步长后的那个元素，说明交换
if (arr[j - 2] > arr[j]) {
temp = arr[j];
arr[j] = arr[j - 2];
arr[j - 2] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
// 第三轮 // 因为第一轮是将10个数据分为2/2=1组
for (int i = 1; i < arr.length; i++) {
// 遍历各组中所有的元素（共5组，每组有两个元素），步长为5
for (int j = i; j - 1 >= 0; j -= 1) {
// 如果当前元素大于加上步长后的那个元素，说明交换
if (arr[j - 1] > arr[j]) {
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
5，选择排序
不断从右边的数组中找出最小值
// 选择排序
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
// 第一轮
int minIndex = i;
int min = arr[i];
for (int j = i + 1; j < arr.length; j++) {
if (min > arr[j]) {
min = arr[j];
minIndex = j;
}
}
// 将最小值与arrp[0]交换
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
System.out.println(Arrays.toString(arr));
}
}
6，堆排序
此时我们从最后一个非叶子节点开始，从左至右，从下至上进行调整。（第一个非叶子节点arr.length/2-1=5/2-1=1,也就是值是6的节点）
交换9和4
// 编写一个堆排序
public static void heapSort(int[] arr) {
int temp=0;
//将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
for(int i=arr.length/2-1;i>=0;i--){
adjustHeap(arr, i, arr.length);
}
/**
* 2.将堆顶元素与末尾元素交换，将最大元素“沉”到数组末端
* 3.重新调整结构，使其满足堆定义，
* 然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序
*/
for(int j=arr.length-1;j>0;j--){
//交换
temp=arr[j];
arr[j]=arr[0];
arr[0]=temp;
adjustHeap(arr, 0,j);
}
System.out.println(Arrays.toString(arr));
}
/**
* 功能：完成将以i对于的非叶子节点的树调整成大顶堆 arr待调整的数组 i表示非叶子节点在数组中的索引
* length表示对多少个元素继续调整，length是在逐渐的减少
*/
// 将一个数组（二叉树），调整成一个大顶堆
public static void adjustHeap(int arr[], int i, int length) {
// 先取出当前元素的值，保存在临时变量
int temp = arr[i];
// 开始调整
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
// 说明左子节点的值小于右子节点的值
if (k + 1 < length && arr[k] < arr[k + 1]) {
k++;// k指向右子节点
}
// 子节点大于父节点
if (arr[k] > temp) {
arr[i] = arr[k];
i = k;
} else {
// 较难理解
break;
}
}
// for循环结束后，我们已经将以i为父节点的树的最大值，放在了最顶上（局部）
arr[i] = temp;
}
7，基数排序
基数排序是桶排序的扩展
// 基数排序方法
public static void radixSort(int[] arr) {
// 1.得到数组中最大值的位数
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
// 最大是几位
int maxLength = (max + "").length();
// （针对每一个元素的个位进行排序处理）
// 定义一个二位数组，表示10个桶，每个桶就是一个一维数组
// 1 二维数组包含10个一维数组
// 2 为防止在放入数的时候，数据溢出，则每个一维数组（桶），大小定为arr.length
// 3 名明确，基数排序是使用空间换时间的经典算法
int[][] bucket = new int[10][arr.length];
// 为了记录每个桶中，实际存放了多少给数据，我们定义一个一维数组来记录各个桶的每次放入的数据个数
// 记录的是bucket[i]桶的放入数据个数
int[] bucketElementCounts = new int[10];
for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
for (int j = 0; j < arr.length; j++) {
// 取出每个元素的个位的值
int digitOfElement = arr[j] / n % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
// 按照这个桶的顺序（一维数组的下标依次取出数据，放入原来）
int index = 0;
// 遍历每一个桶，并将桶中的数据放入到原数组
for (int k = 0; k < bucketElementCounts.length; k++) {
// 如果桶中，有数据，我们才放入到原数组
if (bucketElementCounts[k] != 0) {
// 循环该桶即第k个桶（即第k个一维数组），放入
for (int l = 0; l < bucketElementCounts[k]; l++) {
// 取出元素放入到arr
arr[index++] = bucket[k][l];
}
bucketElementCounts[k] = 0;
}
}
System.out.println(Arrays.toString(arr));
}
}
// 基数排序方法
public static void radixSort(int[] arr) {
// （针对每一个元素的个位进行排序处理）
// 定义一个二位数组，表示10个桶，每个桶就是一个一维数组
// 1 二维数组包含10个一维数组
// 2 为防止在放入数的时候，数据溢出，则每个一维数组（桶），大小定为arr.length
// 3 名明确，基数排序是使用空间换时间的经典算法
int[][] bucket = new int[10][arr.length];
// 为了记录每个桶中，实际存放了多少给数据，我们定义一个一维数组来记录各个桶的每次放入的数据个数
// 记录的是bucket[i]桶的放入数据个数
int[] bucketElementCounts = new int[10];
// 第1轮（针对每个数据的个位进行排序处理）
for (int j = 0; j < arr.length; j++) {
// 取出每个元素的个位的值
int digitOfElement = arr[j] % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
// 按照这个桶的顺序（一维数组的下标依次取出数据，放入原来）
int index = 0;
// 遍历每一个桶，并将桶中的数据放入到原数组
for (int k = 0; k < bucketElementCounts.length; k++) {
// 如果桶中，有数据，我们才放入到原数组
if (bucketElementCounts[k] != 0) {
// 循环该桶即第k个桶（即第k个一维数组），放入
for (int l = 0; l < bucketElementCounts[k]; l++) {
// 取出元素放入到arr
arr[index++] = bucket[k][l];
}
bucketElementCounts[k]=0;
}
}
System.out.println(Arrays.toString(arr));
//===============================================
// 第2轮（针对每个数据的个位进行排序处理）
for (int j = 0; j < arr.length; j++) {
// 取出每个元素的个位的值
int digitOfElement = arr[j] /10 % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
// 按照这个桶的顺序（一维数组的下标依次取出数据，放入原来）
index = 0;
// 遍历每一个桶，并将桶中的数据放入到原数组
for (int k = 0; k < bucketElementCounts.length; k++) {
// 如果桶中，有数据，我们才放入到原数组
if (bucketElementCounts[k] != 0) {
// 循环该桶即第k个桶（即第k个一维数组），放入
for (int l = 0; l < bucketElementCounts[k]; l++) {
// 取出元素放入到arr
arr[index++] = bucket[k][l];
}
bucketElementCounts[k]=0;
}
}
System.out.println(Arrays.toString(arr));
//===============================================
// 第3轮（针对每个数据的个位进行排序处理）
for (int j = 0; j < arr.length; j++) {
// 取出每个元素的个位的值
int digitOfElement = arr[j] /100 % 10;
// 放入到对应的桶中
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
// 按照这个桶的顺序（一维数组的下标依次取出数据，放入原来）
index = 0;
// 遍历每一个桶，并将桶中的数据放入到原数组
for (int k = 0; k < bucketElementCounts.length; k++) {
// 如果桶中，有数据，我们才放入到原数组
if (bucketElementCounts[k] != 0) {
// 循环该桶即第k个桶（即第k个一维数组），放入
for (int l = 0; l < bucketElementCounts[k]; l++) {
// 取出元素放入到arr
arr[index++] = bucket[k][l];
}
bucketElementCounts[k]=0;
}
}
System.out.println(Arrays.toString(arr));
}
8，归并排序
public class MergeSort {
public static void main(String[] args) {
int[] arr = { 8, 7, 6, 5, 4, 3, 2, 1 };
int[] temp = new int[arr.length];
mergeSort(arr, 0, arr.length - 1, temp);
System.out.println(Arrays.toString(arr));
}
// 分+合方法
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);
}
}
// 合并方法
/**
*
* @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; // 初始化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++;
i++;
} else {// 反之，将右边有序序列当前元素，填充到temp数组
temp[t] = arr[j];
t++;
j++;
}
}
// （2）
// 把有剩余数据的一边的数据一次全部填充到temp
while (i <= mid) { // 左边的有序序列还有剩余的元素，就全部填充到temp
temp[t] = arr[i];
t++;
i++;
}
while (j <= right) { // 右边的有序序列还有剩余的元素，就全部填充到temp
temp[t] = arr[j];
t++;
j++;
}
// （3）
// 将temp数组拷贝到arr
// 注意，并不是每次都拷贝所有
t = 0;
int tempLeft = left;
System.out.println(Arrays.toString(temp));
while (tempLeft <= right) {
// 第一次合并 tempLeft=0,right=1
// 第二次合并 tempLeft=2,right=3
// 第三次合并 tempLeft=0,right=3
// 最后一次 tempLeft=0 right=7
arr[tempLeft] = temp[t];
t++;
tempLeft++;
}
}
}
136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
