文章介绍了几种基本的排序算法在Java中的实现，包括直接插入排序、希尔排序、冒泡排序、快速排序和选择排序，详细展示了每种算法的代码示例及运行结果，并提到了时间复杂度和排序过程的关键点。
直接插入排序
public class Insertion_sort {
public static void main(String[] args) {
int arr[] ={49,38,65,97,76,13,27,49};
System.out.println("待排数组：");
System.out.println(Arrays.toString(arr));
System.out.println("--------");
for (int i = 1; i < arr.length; i++) { //外层循环，从38开始，共循环7次，所以i为1，
int tmp = arr[i]; //例：先将38取出来，tmp进行存储
int j; //j为i位置的前一个数，所以j=i-1 （例：38前面为49）
for (j = i - 1; j >= 0 ; j--) { //使i位置前的值依次与tmp进行比较
if (tmp < arr[j]){
arr[j+1] = arr[j];
}else{
break;
}
}
//此时的j已经为-1
arr[j+1] = tmp; //指向最终插入位置
System.out.println(Arrays.toString(arr));
}
}
}
运行结果：
待排数组：
[49, 38, 65, 97, 76, 13, 27, 49]
--------
[38, 49, 65, 97, 76, 13, 27, 49]
[38, 49, 65, 97, 76, 13, 27, 49]
[38, 49, 65, 97, 76, 13, 27, 49]
[38, 49, 65, 76, 97, 13, 27, 49]
[13, 38, 49, 65, 76, 97, 27, 49]
[13, 27, 38, 49, 65, 76, 97, 49]
[13, 27, 38, 49, 49, 65, 76, 97]
补充：
如果想要把数组中的内容打印出来，直接打印数组或直接使用toString方法都只会打印出数组的地址，因此需要使用Arrays的toString方法来打印数组中的数据。
该方法支持long，float，double，int，boolean，byte，object型的数组。
System.out.println(arr);
System.out.println(arr.toString());
System.out.println(Arrays.toString(arr));
打印结果：
[I@776ec8df
[I@776ec8df
[13, 27, 38, 49, 49, 65, 76, 97]
希尔排序
希尔排序即为对每个子表进行直接插入排序。
希尔排序是对直接插入排序的优化。
package com.算法.排序;
import java.util.Arrays;
public class Shell_sort {
public static void main(String[] args) {
int arr[] ={49,38,65,97,76,13,27,49};
System.out.println("待排数组：");
System.out.println(Arrays.toString(arr));
int count = 0;//比较次数
int gap = arr.length / 2; //gap为步长，一般题目上会给，如果题目没有，即为数组的长度/2
while(gap >= 1){
int k = 0;
while(k < gap){ //k的取值为0——gap-1
for (int i = gap + k; i < arr.length; i+=gap) {
int temp = arr[i];
int j;
for (j = i-gap; j >= 0 ; j-=gap) {
if (arr[j] > temp){
arr[j+gap] =arr[j];
}else{
break;
}
}
j = j + gap; //指向最终插入位置
arr[j] = temp;
}
k++;
}
System.out.println("步长为："+gap);
System.out.println(Arrays.toString(arr));
gap = gap/2;
}
}
}
运行结果：
待排数组：
[49, 38, 65, 97, 76, 13, 27, 49]
步长为：4
[49, 13, 27, 49, 76, 38, 65, 97]
步长为：2
[27, 13, 49, 38, 65, 49, 76, 97]
步长为：1
[13, 27, 38, 49, 49, 65, 76, 97]
排序结果：
[13, 27, 38, 49, 49, 65, 76, 97]
冒泡排序
时间复杂度： O(n²)
public class Bubble_sort {
public static void main(String[] args) {
int count = 0; //记录比较次数
int arr[] = {49,38,65,97,76,13,27,49};
for (int i = 0; i < arr.length-1; i++) { //外层循环
for (int j = 0; j < arr.length-1-i; j++) { //内层循环
if (arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
count++;
}
}
System.out.println(Arrays.toString(arr));
System.out.println("一共比较了"+count+"次");
}
}
快速排序
快速排序即为在待排序数组找到一个基准值，将待排序数组分成左右两段，左边的值全小于这个基准值，右边的值全大于这个基准值。然后递归重复这个操作直到整个数组都变得有序。
时间复杂度：O(n²）
public class Quick_sort {
public static void main(String[] args) {
int arr[] ={49,38,65,97,76,13,27,49};
//快速排序
quickSort(arr);
System.out.println(Arrays.toString(arr));
}
public static int partition(int[] arr,int low,int high){
//指定左指针left和右指针right
int left = low;
int right = high;
//将第一个数作为基准值
int axis = arr[left];
while(left < right){
//从右向左移动right指针，找到第一个小于基准值的值arr[right]
while (arr[right] >= axis && left < right){
right--;
}
//将右侧找到的小于基准值的值填入到左边left的位置，left指针向右移动一位
if (left < right){
arr[left] = arr[right];
System.out.println(Arrays.toString(arr));
left++;
}
//从左向右移动left指针，找到第一个大于基准值的值arr[left]
while(arr[left] < axis && left < right){
left++;
}
将左侧找到的大于基准值的值填入到右边right的位置，right指针向左移动一位
if (left<right){
arr[right] =arr[left];
System.out.println(Arrays.toString(arr));
right--;
}
}
//当right和left指针同时指向同一个坑位时，此坑即为基准值的最终位置
arr[left] = axis;//arr[right] = axis;
//返回基准值的位置索引
return left;//return right;
}
//递归
public static void quickSort(int[] arr,int low,int high){
if (low < high){
//分区操作，将一个数组分成两个分区，返回分区界限索引
int index = partition(arr, low, high);
//对左分区进行快排
quickSort(arr,low,index-1);
//对右分区进行快排
quickSort(arr,index+1,high);
}
}
public static void quickSort(int[] arr){
int low = 0;
int high = arr.length - 1;
quickSort(arr,low,high);
}
}
选择排序
public class Select_sort {
public static void main(String[] args) {
int[] arr ={49,38,65,97,76,13,27,49};
for (int i = 0; i < arr.length; i++) {
int index = i; //标记第一个为待比较的数
for (int j = i+1; j < arr.length; j++) {//然后从后面遍历与第一个数相比较
if(arr[j] < arr[index]){
index = j; //保存最小元素的下标
}
}
//找到最小值后，将最小的值放到第一的位置，进行下一遍循环
int temp = arr[index];
arr[index] = arr[i];
arr[i] = temp;
System.out.println(Arrays.toString(arr));
}
System.out.println("排序结果"); System.out.println(Arrays.toString(arr));
}
}
运行结果：
[13, 38, 65, 97, 76, 49, 27, 49]
[13, 27, 65, 97, 76, 49, 38, 49]
[13, 27, 38, 97, 76, 49, 65, 49]
[13, 27, 38, 49, 76, 97, 65, 49]
[13, 27, 38, 49, 49, 97, 65, 76]
[13, 27, 38, 49, 49, 65, 97, 76]
[13, 27, 38, 49, 49, 65, 76, 97]
[13, 27, 38, 49, 49, 65, 76, 97]
排序结果
[13, 27, 38, 49, 49, 65, 76, 97]
为方便更直观的展现算法流程，图中排序动画引用的是其他博主的动画图。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
