十大排序算法(Java源码)

已于 2024-07-31 22:35:36 修改
阅读量699 收藏 2
点赞数 1
分类专栏： Java数据结构与算法 文章标签： 排序算法
于 2022-04-17 20:18:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63526467/article/details/124235360
版权

文章目录

十大排序算法(java源码)：

在这里插入图片描述

1.选择排序：

package testTenSort;

import java.util.Arrays;

public class SelectSort {
	public static void main(String[] args) {
		int[] arr = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		selectSort(arr);
	}

	static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			int minPos = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[j] < arr[minPos]) {
					minPos = j;
					swap(arr, i, minPos);
				}
			}

		}
		print(arr);
		System.out.println();
		// 以数组的形式返回
		System.out.println(Arrays.toString(arr));
	}

	// 实现数组中两个位置的数作交换
	static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	// 实现数组的打印
	static void print(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "  ");
		}
	}

}

2.冒泡排序：

package testTenSort;

import java.util.Arrays;

public class BubbleSort {
	public static void main(String[] args) {
		int[] arr = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		bubbleSort(arr);
	}

	// 实现冒泡排序：
	static void bubbleSort(int[] arr) {
		// 分析循环要由内往外看
		// 外层循环：数组中有多少个数就需要多少次循环
		for (int i = arr.length - 1; i >= 0; i--) {
			// 内层循环：如果前面那个数大于它后面的那个数，两数交换
			for (int j = 1; j <= i; j++) {
				if (arr[j] < arr[j - 1])
					swap(arr, j, j - 1);
			}
		}
		// 以数组的形式返回
		System.out.println(Arrays.toString(arr));
	}

	// 实现数组中两个位置的数作交换
	static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

3.插入排序：

package testTenSort;

import java.util.Arrays;

public class InsertSort {
	public static void main(String[] args) {
		int[] arr = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		insertSort(arr);
	}

	// 实现插入排序：
	static void insertSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			for (int j = i; j > 0; j--) {
				if (arr[j] < arr[j - 1])
					swap(arr, j, j - 1);
			}
		}
		// 以数组的形式返回
		System.out.println(Arrays.toString(arr));
	}

	static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

4.希尔排序：

package testTenSort;

import java.util.Arrays;

public class ShellSort {
	public static void main(String[] args) {
		int[] arr = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		shellSort(arr);
		KnuthShellSort(arr);
	}

	// 实现希尔排序：升级版的插入排序
	static void shellSort(int[] arr) {
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			for (int i = gap; i < arr.length; i++) {
				for (int j = i; j >= gap; j -= gap) {
					if (arr[j] < arr[j - gap])
						swap(arr, j, j - gap);
				}
			}
		}
		// 以数组的形式返回
		System.out.println(Arrays.toString(arr));
	}

	// Knuth序列实现希尔排序：
	static void KnuthShellSort(int[] arr) {
		// Knuth序列
		int h = 0;
		while (h <= arr.length) {
			h = h * 3 + 1;
		}
		for (int gap = h; gap > 0; gap = (gap - 1) / 3) {
			for (int i = gap; i < arr.length; i++) {
				for (int j = i; j > gap - 1; j -= gap) {
					if (arr[j] < arr[j - gap])
						swap(arr, j, j - gap);
				}
			}
		}
		// 以数组的形式返回
		System.out.println(Arrays.toString(arr));
	}

	static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

5.堆排序：

package testTenSort;

import java.util.Arrays;

public class HeapSort {
	public static void main(String[] args) {
		int[] arr = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		heapSort(arr);
	}

	// 实现堆排序：
	static void heapSort(int[] arr) {
		// 初始建堆
		// 最后一个非叶子节点的下标为：(arr.length-1-1)/2即arr.length / 2 - 1
		for (int i = arr.length / 2 - 1; i >= 0; i--)
			heapify(arr, i, arr.length - 1);
		// 堆排序过程
		// 倒序遍历堆，堆中有多少个数就需要多少次循环
		for (int i = arr.length - 1; i >= 0; i--) {
			// 将根节点的值与本次循环的最后一个元素进行交换
			swap(arr, 0, i);
			// 每次交换后，从根节点开始调整堆结构使其重新变为大根堆
			heapify(arr, 0, i - 1);
		}
		// 以数组的形式返回
		System.out.println(Arrays.toString(arr));

	}

	// 调整堆结构使其重新变为大根堆：
	static void heapify(int[] arr, int i, int last_index) {
		// 令当前非叶子节点的下标为最大值下标
		int max = i;
		if (2 * i + 1 <= last_index && arr[2 * i + 1] > arr[max])
			// 记左子节点的下标为最大值下标
			max = 2 * i + 1;
		if (2 * i + 2 <= last_index && arr[2 * i + 2] > arr[max])
			// 记右子节点的下标为最大值下标
			max = 2 * i + 2;
		// 若最大值下标不等于当前非叶子节点的下标
		if (max != i) {
			// 将当前非叶子节点的值与当前最大值进行交换
			swap(arr, i, max);
			// 从最大值下标开始继续调整堆结构
			heapify(arr, max, last_index);
		}

	}

	static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

6.快速排序：

package testTenSort;

import java.util.Arrays;

public class QuickSort {
	public static void main(String[] args) {
		int[] arr = { 7, 3, 2, 10, 8, 1, 9, 5, 4, 6 };
		quickSort(arr, 0, arr.length - 1);
		// 以数组的形式返回
		System.out.println(Arrays.toString(arr));

	}
    //实现快速排序：
	static void quickSort(int[] arr, int leftBound, int rightBound) {
		if (leftBound >= rightBound)
			return;
		int mid = partition(arr, leftBound, rightBound);
		quickSort(arr, leftBound, mid - 1);
		quickSort(arr, mid + 1, rightBound);

	}
    //实现分区：
	static int partition(int[] arr, int leftBound, int rightBound) {
		int pivot = arr[rightBound];
		int left = leftBound;
		int right = rightBound - 1;
		while (left <= right) {
			while (left <= right && arr[left] <= pivot)
				left++;
			while (left <= right && arr[right] > pivot)
				right--;
			if (left <= right)
				swap(arr, left, right);
		}
		swap(arr, left, rightBound);
		return left;

	}

	static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

7.归并排序：

package testTenSort;

import java.util.Arrays;

public class MergeSort {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 4, 7, 8, 3, 5, 6, 9 };
		mergeSort(arr, 0, arr.length - 1);
		// 以数组的形式返回
		System.out.println(Arrays.toString(arr));
	}

	// 实现归并排序：
	static void mergeSort(int[] arr, int left, int right) {
		if (left == right)
			return;
		// 分成两半
		int mid = (left + right) / 2;
		// 左边排序
		mergeSort(arr, left, mid);
		// 右边排序
		mergeSort(arr, mid + 1, right);
		// 左右归并
		merge(arr, left, mid + 1, right);
	}

	// 实现左右归并：
	// leftPtr指向左排序的第一位
	// rightPtr指向右排序的第一位
	// righeBound指向右边界
	static void merge(int[] arr, int leftPtr, int rightPtr, int righeBound) {
		int mid = rightPtr - 1;
		int[] temp = new int[righeBound - leftPtr + 1];
		int i = leftPtr;
		int j = rightPtr;
		int k = 0;
		while (i <= mid && j <= righeBound) {
			temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
		}
		while (i <= mid)
			temp[k++] = arr[i++];
		while (j <= righeBound)
			temp[k++] = arr[j++];
		for (int m = 0; m < temp.length; m++)
			arr[leftPtr + m] = temp[m];
	}
}

8.桶排序：

package testTenSort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

public class BucketSort {
	public static void main(String[] args) {
		int[] arr = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
		bucketSort(arr);
	}

	// 实现桶排序：
	static void bucketSort(int[] arr) {
		// 先找到最大值和最小值
		int max = arr[0];
		int min = arr[0];
		for (int i = 1; i < arr.length; i++) {
			max = arr[i] > max ? arr[i] : arr[0];
			min = arr[i] < min ? arr[i] : arr[0];
		}
		// 确定桶的数量:固定用法
		int count = (max - min) / arr.length + 1;
		// 定义一个泛型为数组的数组，外层数组用于盛放桶的数量，内层数组用于盛放桶中的数据
		ArrayList<ArrayList<Integer>> buckets = new ArrayList<>();
		for (int i = 0; i < count; i++)
			buckets.add(new ArrayList<Integer>());
		// 遍历arr，把数据放在对应的桶里：固定用法
		for (int i = 0; i < arr.length; i++)
			buckets.get((arr[i] - min) / arr.length).add(arr[i]);
		// 对每个桶分别排序：桶排序的稳定性取决于此处的排序是否稳定
		for (int i = 0; i < buckets.size(); i++)
			// 此处可使用任意排序方法，为了方便此处使用了集合封装的排序方法
			Collections.sort(buckets.get(i));
		// 把每桶里的内容输出即完成排序
		int k = 0;
		// 外层循环：遍历桶的数量
		for (int i = 0; i < buckets.size(); i++) {
			// 得到第i个桶
			ArrayList<Integer> list = buckets.get(i);
			// 遍历每个桶中的数据拷贝给arr数组
			for (int j = 0; j < list.size(); j++)
				arr[k++] = list.get(j);
		}
		System.out.println(Arrays.toString(arr));
	}

	// 实现数组中两个位置的数作交换
	static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

9.计数排序：

package testTenSort;

import java.util.Arrays;

public class CountSort {
	public static void main(String[] args) {
		int[] arr = { 2, 4, 2, 3, 7, 1, 1, 0, 0, 5, 6, 9, 8, 5, 7, 4, 0, 9 };
		countSort(arr);
	}

	// 实现计数排序：
	static void countSort(int[] arr) {
		// 定义结果数组
		int[] result = new int[arr.length];
		// 找最大值
		int max = arr[0];
		for (int i = 1; i < arr.length; i++)
			max = arr[i] > max ? arr[i] : arr[0];
		// 定义计数数组：计数数组的大小为arr数组中的最大值+1(包含0)
		int[] count = new int[max + 1];
		// 遍历arr，把数据放在计数数组里,数的大小与数组下标相同，下标所对应的数值表示该数值在arr数组中出现的次数
		for (int i = 0; i < arr.length; i++) {
			count[arr[i]]++;
		}
		// System.out.println(Arrays.toString(count));
		// 将计数数组转化为次数累加数组：记录最后一个重复元素所在的位置
		for (int i = 1; i < count.length; i++) {
			count[i] = count[i] + count[i - 1];
		}
		// System.out.println(Arrays.toString(count));
		// 倒序遍历arr数组，结合次数累加数组记录的坐标，保证了计数排序的稳定性
		// 将arr数组中的值拷贝到结果数组result中
		for (int i = arr.length - 1; i >= 0; i--) {
			// 最后一个重复元素所在的位置为count[arr[i]]-1
			result[count[arr[i]] - 1] = arr[i];
			count[arr[i]]--;
		}
		// 以数组的形式返回
		System.out.println(Arrays.toString(result));
	}
}

10.基数排序：

package testTenSort;

import java.util.Arrays;

public class RadixSort {
	public static void main(String[] args) {
		int[] arr = { 2, 4, 2, 3, 7, 1, 1, 0, 0, 5, 6, 9, 8, 5, 7, 4, 0, 9 };
		radixSort(arr);
	}

	// 实现基数排序：
	static void radixSort(int[] arr) {
		// 找最大值
		int max = arr[0];
		for (int i = 1; i < arr.length; i++)
			max = arr[i] > max ? arr[i] : arr[0];
		// 分解数字：value/exp%10
		for (int exp = 1; max / exp > 0; exp *= 10) {
			// 创建桶数组，里面有10个桶
			int[] buckets = new int[10];
			// 创建temp数组
			int[] temp = new int[arr.length];
			// 计算每个桶中数据的个数
			for (int i = 0; i < arr.length; i++)
				buckets[arr[i] / exp % 10]++;
			// 计算每个桶中的累加数据
			for (int i = 1; i < buckets.length; i++)
				buckets[i] += buckets[i - 1];
			// 倒序遍历arr数组，结合次数累加数组记录的坐标，保证了基数排序的稳定性
			// 将arr数组中的值拷贝到临时数组temp中
			// 此处之所以将arr数组中的值拷贝到临时数组temp中而不是像计数排序一样直接拷贝到result数组中
			// 是因为在基数排序中本次操作位于循环中
			for (int i = arr.length - 1; i >= 0; i--) {
				temp[buckets[arr[i]] - 1] = arr[i];
				buckets[arr[i]]--;
			}
			// 将temp数组中的值拷贝到arr数组中
			for (int i = 0; i < temp.length; i++)
				arr[i] = temp[i];
		}
		// 以数组的形式返回
		System.out.println(Arrays.toString(arr));
	}
}
程序猿陌名！
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
十大经典排序算法（Java版本）
m0_64354070的博客
12-08 1027
排序算法的重要性不言而喻，为了加深对这十种算法的理解，固写此文。 目录 1、冒泡排序（Bubble Sort） 2、选择排序（Selection Sort） 3、插入排序（Insertion Sort） 4、希尔排序（Shell Sort） 5、归并排序（Merge Sort） 6、快速排序（Quick Sort） 7、堆排序（Heap Sort） 8、计数排序（Counting Sort） 9、桶排序（Bucket Sort） 10、基数排序（Radix Sort） 首先可用如下表来
十大经典排序算法（java实现、配图解，附源码)
pythonxxoo的博客
03-03 2046
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 前言： 本文章主要是讲解我个人在学习Java开发环境的排序算法时做的一些准备，以及个人的心得体会，汇集成本篇文章，作为自己对排序算法理解的总结与笔记。 内容主要是关于十大经典排序算法的简介、原理、动静态图解和源码实现的分析。 对于一名程序员来讲，我们都知道数据结构与算法起初是用
经典排序总结
gjq5464的博客
07-16 128
package sort; import java.util.ArrayList; import java.util.Arrays; public class Sort { public static void main(String[] args) { int[] arr = new int[20]; int index = 0; for (int i = 20; i > 0; i--)// 从大到小构建数组 arr[index++] = i; System.out.p.
十大排序算法(Java版)
small_engineer的博客
05-06 1010
十大排序算法总览冒泡排序流程图Java代码复杂度分析选择排序流程图Java代码复杂度分析直接插入排序流程图Java代码复杂度分析 总览 冒泡排序 流程图 Java代码 //冒泡排序 public void bubleSort(int arr[]){ int len=arr.length; for(int i=1;i<arr.length;++i){ for(int j=0;j<len-i;++j){
十大排序算法Java
SEMHAQ的博客
03-20 1349
十大排序算法Java
java十大排序算法
bjw1999的博客
11-15 1211
一、插入算法
十大经典排序算法(java源码)
04-19
这些排序算法的Java源码实现提供了直观的学习材料，可以帮助开发者深入理解每种算法的工作原理，提升编程技能。在实际应用中，应根据数据特性、性能要求和资源限制选择合适的排序算法。例如，快速排序在大多数情况下...
Java常见排序算法源码集.rar
07-10
通过阅读和理解这些Java源码，开发者不仅可以提升编程技巧，还能更深入地理解数据结构和算法，这对于任何程序员的事业发展都是非常有益的。此外，源码分析和调试也能帮助初学者提高问题解决能力，锻炼编程思维。在...
十大排序算法代码（Java）
10-08
十大排序算法十大排序算法源码，自己整理的，可以直接运行，Java版本
java二分法排序源码-Article:十大经典排序算法动画，看我就够了！
06-05
十大经典排序算法动画与解析，看我就够了！（配代码完全版） 欢迎关注 公众号 五分钟学算法，一起学习一起交流进步！ 排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序。 内部...
十大常用排序算法（java实现）
11-01
十大常用排序算法（java实现）,冒泡排序，简单选择排序等
排序算法源码
08-02
排序算法源码（C/C++），欢迎交流，在linux下运行正常。
基于java语言十大经典排序算法
10-22
本文档描述了基于JAVA的十大经典排序算法，各个算法都有详细介绍，配有java程序以及图形解释
排序算法过程演示程序源码
10-11
以前帮别人写的一个课程设计，里面提供了四种常用排序算法：冒泡排序、选择排序、插入排序、交换排序。 由于是动画演示，可以清楚看到各种不同排序的比较、交换的过程。 本代码供VS2013以后的环境使用，因为代码中用到了yield。
java算法大全源码 java算法大全源码
06-02
java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码
十大排序算法(Java实现)
BlooM_的博客
07-09 1059
1.冒泡排序(Bubble Sort) 1.1 冒泡排序意指经过层层排序后，较小的数会慢慢浮到最前面。冒泡排序是一种简单且稳定的排序算法。 1.2 算法描述 比较相邻的元素，如果第一个比第二个数据大，就交换第二个元素的位置； 对每一对相邻元素做相同的工作，从开始第一对到结尾的最后一对，这样结束一轮比较后最后一个元素是此序列最大的元素； 针对所有的元素重复以上的步骤，除了最后已确定顺序的元素； 重复步骤1~3，直到排序完成。 1.3 代码实现 public class BubbleSort { p
十大排序算法总结（Java）
渔舟的博客
09-22 163
十大排序算法总结（Java）
Java实现十大排序算法
最新发布
galaxyou的博客
03-19 1380
十大排序算法：插入、冒泡、选择、快速、归并、堆、基数、希尔、计数、桶、
十大经典排序算法(Java版本)
星月情缘的博客
04-22 323
排序算法(Python版本):最常见的排序算法（Python版）,很多读者反馈，需要一份Java版本的，所以才有这篇文章 。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图...
Java归并排序源码解析
"这是一个Java代码示例，展示了如何使用归并排序算法对整数数组进行排序。这段代码可以作为学习归并排序算法的参考资料。" 在Java编程中，归并排序是一种常用的排序算法，它采用了分治策略。归并排序将一个大问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿陌名！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值