*时间复杂度和空间复杂度
一、冒泡排序
1.工作原理：
（1）比较相邻的两个元素，如果前面的元素大于后面的元素，则交换他们的位置。
（2）对每一对相邻的元素进行同样的操作，从前两个元素到最后两个元素，一趟比较后，最大的元素跑到了最后一位。
（3）针对所有的元素重复以上的步骤，除了最后一个。
2.代码：
java
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {5, 2, 9, 1, 5, 6};
bubbleSort(arr);
System.out.println("\n排序后的数组：");
for (int num : arr) {
System.out.print(num + " ");
}
}
public static void bubbleSort(int[] arr) {
int n = arr.length;
boolean swapped;
for (int i = 0; i < n - 1; i++) {
swapped = false;
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// 交换 arr[j] 和 arr[j + 1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = true;
}
}
// 如果没有发生交换，说明数组已经有序
if (!swapped) {
break;
}
}
}
}二、插入排序
1.工作原理：
（1）从第一个元素开始，该元素可以被认为是已经排序的元素。
（2）取出下一个元素，在已经排序的元素序列中从后向前扫描
（3）如果索引元素大于新的元素，将索引元素移至前一个位置。
（4）重复步骤3，直到找到已排序地元素小于或者等于新元素的位置，将新元素插入到该位置。
（5）重复2-5步骤，遍历n-1次
2.代码：
java
public class InsertionSort {
// 插入排序算法实现
public static void insertionSort(int[] array) {
int n = array.length;
// 从第二个元素开始遍历数组
for (int i = 1; i < n; i++) {
int key = array[i]; // 当前要插入的值
int j = i - 1; // 已排序部分的最后一个元素的下标
// 在已排序部分中寻找合适的位置插入key
while (j >= 0 && array[j] > key) {
array[j + 1] = array[j]; // 向后移动元素
j--;
}
array[j + 1] = key; // 将key插入合适的位置
}
}
public static void main(String[] args) {
int[] arr = {12, 11, 13, 5, 6};
insertionSort(arr);
System.out.print("Sorted array: ");
for (int i : arr) {
System.out.print(i + " ");
}
}
}三、选择排序
1.工作原理：
（1）首先，从未排序的元素中找到最小（或者最大）的元素。
（2）将其放到已排序序列的末尾（或者放到另一个数组的开头）
（3）然后，再从剩余的未排序元素中，找到最小（最大）的元素，放到已排序序列的末尾。
（4）重复（2）（3）步骤，直至所有元素都已排序
2.代码：
java
function selectionSort(array)
n = array.length
for i from 0 to n-1
minIndex = i
for j from i+1 to n-1
if array[j] < array[minIndex]
minIndex = j
swap array[i] and array[minIndex]
end for
end function
//外层循环遍历数组，
//内层循环找到未排序部分中的最小元素，并将其与当前外层循环位置的元素交换，
//这样就不断地将最小元素放到已排序部分的末尾，直到整个数组都排序完成四、归并排序
1.工作原理：
（1）分解：将待排序的数组不断地二分，直到每个子序列只有一个元素为止。
（2）排序：对每个元素进行排序，可以采用递归的方式来实现。
（3）合并：将排序好的子序列再合并为一个整体有序的数组。
2.代码：
java
public class MergeSort {
// 归并排序的主函数，对数组array进行归并排序
public static void mergeSort(int[] array, int left, int right) {
if (left < right) {
// 计算中间位置
int middle = (left + right) / 2;
// 递归地对左半部分进行归并排序
mergeSort(array, left, middle);
// 递归地对右半部分进行归并排序
mergeSort(array, middle + 1, right);
// 合并左右两部分
merge(array, left, middle, right);
}
}
// 将两个已经排序的数组段 array[left...middle] 和 array[middle+1...right] 合并成一个有序数组
public static void merge(int[] array, int left, int middle, int right) {
// 计算左右两部分数组段的长度
int n1 = middle - left + 1;
int n2 = right - middle;
// 创建临时数组存储左右两部分的数据
int[] leftArray = new int[n1];
int[] rightArray = new int[n2];
// 将数据拷贝到临时数组
for (int i = 0; i < n1; i++) {
leftArray[i] = array[left + i];
}
for (int i = 0; i < n2; i++) {
rightArray[i] = array[middle + i + 1];
}
// 合并左右两部分数组段
int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (leftArray[i] <= rightArray[j]) {
array[k] = leftArray[i];
i++;
} else {
array[k] = rightArray[j];
j++;
}
k++;
}
// 将剩余的元素拷贝到数组中
while (i < n1) {
array[k] = leftArray[i];
i++;
k++;
}
while (j < n2) {
array[k] = rightArray[j];
j++;
k++;
}
}
}五、快速排序
1.工作原理：
选取一个基准元素（通常为第一个元素），将序列分为两个子序列；
将小于基准元素的放在基准元素的左边，大于的放在基准元素的右边；
对左右子序列分别进行递归快速排序；
合并左右子序列。
2.代码：
java
public class QuickSort {
public static void main(String[] args) {
int[] arr = {5, 2, 9, 3, 7, 6, 1, 8, 4};
quickSort(arr, 0, arr.length - 1); // 调用快速排序算法
for (int i : arr) {
System.out.print(i + " "); // 输出排序后的数组
}
}
public static void quickSort(int[] arr, int low, int high) {
if (arr == null || arr.length == 0 || low >= high) {
return; // 如果数组为空或者low大于等于high，直接返回
}
int middle = low + (high - low) / 2; // 计算中间值的索引
int pivot = arr[middle]; // 取得中间值作为基准值
int i = low, j = high; // 初始化i和j作为左右指针
while (i <= j) { // 当i小于等于j时循环
while (arr[i] < pivot) { // 在左半部分找到第一个大于等于基准值的元素
i++;
}
while (arr[j] > pivot) { // 在右半部分找到第一个小于等于基准值的元素
j--;
}
if (i <= j) { // 如果左指针小于等于右指针
int temp = arr[i]; // 交换arr[i]和arr[j]
arr[i] = arr[j];
arr[j] = temp;
i++;
j--;
}
}
if (low < j) { // 递归处理左半部分
quickSort(arr, low, j);
}
if (high > i) { // 递归处理右半部分
quickSort(arr, i, high);
}
}
}六、堆排序
1.工作原理：
构建堆：首先将待排序的数据构建成一个二叉堆，可以是最大堆或最小堆。这个步骤可以使用从下往上的循环方式，从最后一个非叶子节点开始，逐个向前调整节点使得以当前节点为根的子树满足堆的性质。
排序：将堆顶元素（最大值或最小值）与堆的最后一个元素交换位置，并将堆的大小减一。接着调整交换后的堆，使其满足堆的性质。重复以上步骤，直到整个数组排序完成。
2.代码：
java
public class HeapSort {
// 堆排序的主要入口方法，用于对整个数组进行排序
public static void sort(int[] arr) {
// 构建最大堆
buildMaxHeap(arr);
// 从最后一个非叶子节点开始，依次将根节点与末尾元素交换，并重新调整堆
for (int i = arr.length - 1; i > 0; i--) {
swap(arr, 0, i); // 将根节点与末尾元素交换
adjustHeap(arr, 0, i); // 重新调整堆
}
}
// 构建最大堆的方法
private static void buildMaxHeap(int[] arr) {
int lastIndex = arr.length - 1;
int parentIndex = (lastIndex - 1) / 2; // 最后一个非叶子节点的下标
for (int i = parentIndex; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
}
// 调整堆的方法，使其满足最大堆的性质
private static void adjustHeap(int[] arr, int index, int length) {
int temp = arr[index]; // 当前父节点
for (int k = 2 * index + 1; k < length; k = 2 * k + 1) { // 从index结点的左子结点开始，也就是2*index+1处开始
if (k + 1 < length && arr[k] < arr[k + 1]) { // 如果左子结点小于右子结点，k指向右子结点
k++;
}
if (arr[k] > temp) { // 如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
arr[index] = arr[k];
index = k;
} else {
break;
}
}
arr[index] = temp; // 将temp值放到最终的位置
}
// 交换数组中两个元素的方法
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// 测试方法
public static void main(String[] args) {
int[] arr = {4, 6, 8, 5, 9, 1, 2, 3, 7};
sort(arr);
for (int num : arr) {
System.out.print(num + " ");
}
}
}七、计数排序
1.工作原理：
（1）统计每个元素出现的次数，遍历待排序的数组，统计每个元素出现的次数，可以使用额外的辅助数组来保存结果。
（2）根据元素的计数信息，确定元素在排序后的位置；根据元素值和它在计数数组中的计数位置，确定元素在排序后的位置。
（3）将元素放置到正确的位置；遍历待排序的数组，根据元素值在计数数组中的位置，将元素放置到正确的位置上。
（4）输出排序后的结果；将排序后的结果一次输出，即得到排序好的数组、
2.代码：
java
public class CountingSortExample {
public static void countingSort(int[] array, int max) {
int[] count = new int[max + 1]; // 创建计数数组，并初始化为 0
for (int num : array) {
count[num]++; // 统计每个元素的个数
}
int k = 0;
for (int i = 0; i < count.length; i++) {
while (count[i] > 0) {
array[k] = i; // 将计数数组中的元素按顺序填充到原始数组中
k++;
count[i]--;
}
}
}
public static void main(String[] args) {
int[] array = {4, 2, 2, 8, 3, 3, 1};
int max = 8; // 数组中的最大值
System.out.println("Before sorting: " + Arrays.toString(array));
countingSort(array, max);
System.out.println("After sorting: " + Arrays.toString(array));
}
}八、桶排序
1.工作原理：
遍历待排序的数组，根据预设的规则将元素分配到对应的桶中；
对每个桶内的元素进行排序，可以使用插入排序、快速排序等方法；
将各个桶内的元素按顺序进行合并，得到最终的有序数组
2.代码：
java
import java.util.ArrayList;
import java.util.Collections;
public class BucketSort {
public static void bucketSort(int[] nums) {
int bucketSize = 5; // 设置桶的大小
int maxValue = Integer.MIN_VALUE;
int minValue = Integer.MAX_VALUE;
for (int num : nums) {
maxValue = Math.max(maxValue, num); // 找到待排序数组的最大值
minValue = Math.min(minValue, num); // 找到待排序数组的最小值
}
int bucketCount = (maxValue - minValue) / bucketSize + 1; // 计算桶的个数
ArrayList<ArrayList<Integer>> buckets = new ArrayList<>(bucketCount);
for (int i = 0; i < bucketCount; i++) {
buckets.add(new ArrayList<>()); // 初始化桶
}
for (int num : nums) {
int bucketIndex = (num - minValue) / bucketSize; // 计算元素应该放入的桶的索引
buckets.get(bucketIndex).add(num); // 将元素放入对应的桶中
}
int index = 0;
for (ArrayList<Integer> bucket : buckets) {
Collections.sort(bucket); // 对每个桶内的元素进行排序
for (int num : bucket) {
nums[index++] = num; // 将排序好的元素放回原数组
}
}
}
public static void main(String[] args) {
int[] arr = {29, 25, 3, 49, 9, 37, 21, 43};
bucketSort(arr);
for (int num : arr) {
System.out.print(num + " ");
}
}
}九、基数排序
1.工作原理：
首先，将待排序的整数按照个位数的数值，进行分配到"桶"中、
其次，按照个位数的顺序将桶中的数字依次取出，组成一个新的序列、
然后，再以十位数的数值进行分配到对应的桶中，并按照顺序取出，形成新的顺序、
最后，以此类推，直到所有位数都分配完毕，得到有序的序列。
2.代码：
java
import java.util.ArrayList;
public class RadixSort {
// 获取数字的指定位数的数字
public static int getDigit(int number, int digitPlace) {
return (number / digitPlace) % 10;
}
// 基数排序函数
public static void radixSort(int[] arr) {
// 找出数组中的最大值，以确定需要多少位数
int max = arr[0];
for (int num : arr) {
if (num > max) {
max = num;
}
}
// 计算最大值的位数
int numDigits = 1;
while (max > 9) {
max /= 10;
numDigits++;
}
// 创建 10 个桶
ArrayList<ArrayList<Integer>> buckets = new ArrayList<>();
for (int i = 0; i < 10; i++) {
buckets.add(new ArrayList<>());
}
// 进行排序
for (int digit = 1; digit <= Math.pow(10, numDigits - 1); digit *= 10) {
// 将数字分配到对应的桶中
for (int num : arr) {
int digitVal = getDigit(num, digit);
buckets.get(digitVal).add(num);
}
// 从桶中取出数字，并按顺序放回原数组
int index = 0;
for (int i = 0; i < 10; i++) {
for (int num : buckets.get(i)) {
arr[index++] = num;
}
buckets.get(i).clear(); // 清空桶，以便下一轮排序使用
}
}
}
// 测试
public static void main(String[] args) {
int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};
radixSort(arr);
System.out.print("排序后的数组：");
for (int num : arr) {
System.out.print(num + " ");
}
}
}十、希尔排序
1.工作原理：
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所 有记录分成个 组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后 取, 重复上述分组和排序的工 作。当到达=1时，所有记录在统一组内排好序。
2.代码：
java
void ShellSort(int* a, int n)
{
//n:待排序数字的个数;n=sizeof(a)/sizeof(int);
// 多次预排序(gap > 1) +直接插入 (gap == 1)
int gap = n;
while (gap > 1)
{
//gap = gap / 2;
gap = gap / 3 + 1;
// 多组并排
for (int i = 0; i < n - gap; ++i)
{
int end = i;
int x = a[end + gap];
while (end >= 0)
{
if (a[end] > x)
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = x;
}
}
}###案例
1023：【编程入门】选择排序：
题目描述
用选择法对10个整数从小到大排序。
输入格式
输入10个无序的数字
输出格式
排序好的10个整数
样例输入
4 85 3 234 45 345 345 122 30 12
样例输出
3
4
12
30
45
85
122
234
345
345
java
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int[] array=new int[10];
for(int i=0;i<10;i++) {
array[i]=scanner.nextInt();
}
selectionSort(array);
}
public static void selectionSort(int[] array) {
for(int i=0;i<array.length;i++) {
int minIndex=i;
for(int j=i+1;j<array.length;j++) {//从未排序的元素中找到最小的元素
if(array[j]<array[minIndex]) {
minIndex=j;//更新最小元素的下标
}
}
//将其放到已排序序列的末尾(0到i为已排序，j到n-1为未排序)
int temp=array[i];
array[i]=array[minIndex];
array[minIndex]=temp;
}
for(int i=0;i<10;i++) {
System.out.println(array[i]);
}
}
}
java
package day2;
import java.util.Scanner;
public class SelectionSort {
public static void main(String[] args) {
Scanner scanner= new Scanner(System.in);
int[] arr=new int[10];
for (int i = 0; i < 10; i++) {
arr[i]=scanner.nextInt();
}
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
printArr(arr);
}
private static void printArr(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
System.out.println();
}
}