排序算法（Java实现）

最新推荐文章于 2022-12-25 17:28:25 发布
最新推荐文章于 2022-12-25 17:28:25 发布
阅读量231 收藏 1
点赞数
分类专栏： 算法 文章标签： 排序算法 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40804005/article/details/82148164
版权

本文主要讲述八种常见的排序算法，使用Java代码实现
1、冒泡排序
2、选择排序
3、插入排序
4、希尔排序
5、快速排序
6、归并排序
7、堆 排 序
8、桶 排 序
各个排序比较

#1-冒泡排序

1、第一次从0-（lenght-1）两两比较数据，大的沉底到（lenght-1）；
2、第二次从0-（lenght-2）两两比较数据，大的沉底(lenght-2)；
…

public class BubbleSort {
	
	public void sort(int[] arr) {
		int temp = 0;
		int n = arr.length;
		for (int i = 0; i < n - 1; i++) {
			for (int j = 0; j < n - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) 
				{
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
			System.out.println("第"+(i+1)+"趟:");
			System.out.println(Arrays.toString(arr));
		}
	}
	@Test
	public void test() {
		int[] arr={32,69,58,24,12,36,18,54};
		System.out.println("初始数组：");
		System.out.println(Arrays.toString(arr));
		sort(arr);
	}
}

######结果：
初始数组：
[32, 69, 58, 24, 12, 36, 18, 54]
第1趟:
[32, 58, 24, 12, 36, 18, 54, 69]
第2趟:
[32, 24, 12, 36, 18, 54, 58, 69]
第3趟:
[24, 12, 32, 18, 36, 54, 58, 69]
第4趟:
[12, 24, 18, 32, 36, 54, 58, 69]
第5趟:
[12, 18, 24, 32, 36, 54, 58, 69]
第6趟:
[12, 18, 24, 32, 36, 54, 58, 69]
第7趟:
[12, 18, 24, 32, 36, 54, 58, 69]

改进

不难发现上面的结果从第五趟开始数组已经排好序了，后面的几趟都相当于白操作了；对于冒泡排序，其实我们可以设置一个标志，通过标志判断它是否发生了数据交换，在这一趟里如果未发生数据交换，数组其实就已经排好序了，这时我们break退出循环即可。

public class BubbleSort {
	
	public void sort(int[] arr) {
		int temp = 0;
		int n = arr.length;
		boolean flag=true;
		for (int i = 0; i < n - 1; i++) {
			for (int j = 0; j < n - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) 
				{
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					flag=false;
				}
			}
			if(flag){
				break;
			}
			flag=true;
			System.out.println("第"+(i+1)+"趟:");
			System.out.println(Arrays.toString(arr));
		}
	}
	@Test
	public void test() {
		int[] arr1={32,69,58,24,12,36,18,54};
		System.out.println("初始数组：");
		System.out.println(Arrays.toString(arr));
		sort(arr1);
	}
}

######结果：
初始数组：
[12, 18, 24, 32, 36, 54, 58, 69]
第1趟:
[32, 58, 24, 12, 36, 18, 54, 69]
第2趟:
[32, 24, 12, 36, 18, 54, 58, 69]
第3趟:
[24, 12, 32, 18, 36, 54, 58, 69]
第4趟:
[12, 24, 18, 32, 36, 54, 58, 69]
第5趟:
[12, 18, 24, 32, 36, 54, 58, 69]
#2-选择排序
1、第0位设置为标志位，从后遍历（length-1~1）数组选出最小值，与标志位数据交换；
2、第1位设置为标志位，从后遍历（length-1~2）数组选出最小值，与标志位数据交换；
…

public class SelectSort {
	public void sort(int[] arr) {
		int n = arr.length; // 数组长度
		int temp = 0; // 中间变量

		for (int i = 0; i < n-1; i++) {
			int k = i;// 待确定的位置
			// 选择出应该在第i个位置的数
			for (int j = n - 1; j > i; j--) {
				if (arr[j] < arr[k]) {
					k = j;
				}
			}
			// 交换两个数
			temp = arr[i];
			arr[i] = arr[k];
			arr[k] = temp;
			
			System.out.println("第"+(i+1)+"趟:");
			System.out.println(Arrays.toString(arr));
		}
	}
	@Test
	public void test(){
		int[] arr = { 32, 69, 58, 24, 12, 36, 18, 54 };
		System.out.println("初始数组：");
		System.out.println(Arrays.toString(arr));
		sort(arr);
	}
}

######结果：
初始数组：
[32, 69, 58, 24, 12, 36, 18, 54]
第1趟:
[12, 69, 58, 24, 32, 36, 18, 54]
第2趟:
[12, 18, 58, 24, 32, 36, 69, 54]
第3趟:
[12, 18, 24, 58, 32, 36, 69, 54]
第4趟:
[12, 18, 24, 32, 58, 36, 69, 54]
第5趟:
[12, 18, 24, 32, 36, 58, 69, 54]
第6趟:
[12, 18, 24, 32, 36, 54, 69, 58]
第7趟:
[12, 18, 24, 32, 36, 54, 58, 69]
#3-插入排序
从前向后遍历数组，用temp记录当前值，假如temp比前面的值小，则将前面的值后移。

public class InsertSort {
	public void sort(int[] arr) {
		int n = arr.length;
		int temp = 0;
		int j = 0;
		for (int i = 0; i < n; i++) {
			temp = arr[i];
			// 假如temp比前面的值小，则将前面的值后移
			for (j = i; j > 0 && temp < arr[j - 1]; j--) {
				arr[j] = arr[j - 1];
			}
			arr[j] = temp;
			System.out.println("第"+(i+1)+"趟:");
			System.out.println(Arrays.toString(arr));
		}
	}
	@Test
	public void test(){
		int[] arr={32,69,58,24,12,36,18,54};
		System.out.println("初始数组：");
		System.out.println(Arrays.toString(arr));
		sort(arr);
	}
}

######结果：
初始数组：
[32, 69, 58, 24, 12, 36, 18, 54]
第1趟:
[32, 69, 58, 24, 12, 36, 18, 54]
第2趟:
[32, 69, 58, 24, 12, 36, 18, 54]
第3趟:
[32, 58, 69, 24, 12, 36, 18, 54]
第4趟:
[24, 32, 58, 69, 12, 36, 18, 54]
第5趟:
[12, 24, 32, 58, 69, 36, 18, 54]
第6趟:
[12, 24, 32, 36, 58, 69, 18, 54]
第7趟:
[12, 18, 24, 32, 36, 58, 69, 54]
第8趟:
[12, 18, 24, 32, 36, 54, 58, 69]
#4-希尔排序
设置每次比较的间隔，间隔相同的数据，两两比较；
间隔–；
直至间隔为1，排序完成；

public class ShellSort {
	public void sort(int[] arr) {
		int j = 0;
		int temp = 0;
		// 每次将步长缩短为原来的一半
		for (int step = arr.length / 2; step > 0; step /= 2) {
			for (int i = step; i < arr.length; i++) {
				temp = arr[i];
				for (j = i; j >= step; j -= step) {
					if (temp < arr[j - step])// 如想从小到大排只需修改这里
					{
						arr[j] = arr[j - step];
					} else {
						break;
					}
				}
				arr[j] = temp;
			}
			System.out.println("STEP:"+step);
			System.out.println(Arrays.toString(arr));
		}
	}
	
	@Test
	public void test(){
		int[] arr={32,69,58,24,12,36,18,54};
		System.out.println("初始数组：");
		System.out.println(Arrays.toString(arr));
		sort(arr);
	}
}

######结果：
初始数组：
[32, 69, 58, 24, 12, 36, 18, 54]
STEP:4
[12, 36, 18, 24, 32, 69, 58, 54]
STEP:2
[12, 24, 18, 36, 32, 54, 58, 69]
STEP:1
[12, 18, 24, 32, 36, 54, 58, 69]
#5-快速排序
选择一个中轴，比它小的放到左边，比它大的放到右边；
然后左边右边继续递归调用，直至排序完成；

public class QuickSort {
	public int count =1;
	public int getMiddle(int[] numbers, int low, int high) {
		int temp = numbers[low]; // 数组的第一个作为中轴
		while (low < high) {
			while (low < high && numbers[high] > temp) {
				high--;
			}
			numbers[low] = numbers[high];// 比中轴小的记录移到低端
			while (low < high && numbers[low] < temp) {
				low++;
			}
			numbers[high] = numbers[low]; // 比中轴大的记录移到高端
		}
		numbers[low] = temp; // 中轴记录到尾
		return low; // 返回中轴的位置
	}

	public void sort(int[] numbers,int low,int high)
    {
        if(low < high)
        {
        	int middle = getMiddle(numbers,low,high); //将numbers数组进行一分为二
        	System.out.println("第"+(count++)+"趟:");
			System.out.println(Arrays.toString(numbers));
        	sort(numbers, low, middle-1);   //对低字段表进行递归排序
        	sort(numbers, middle+1, high); //对高字段表进行递归排序
        }
    
    }
	@Test
	public void test() {
		int[] arr = { 32, 69, 58, 24, 12, 36, 18, 54 };
		System.out.println("初始数组：");
		System.out.println(Arrays.toString(arr));
		sort(arr, 0, arr.length - 1);
	}
}

######结果：
初始数组：
[32, 69, 58, 24, 12, 36, 18, 54]
第1趟:
[18, 12, 24, 32, 58, 36, 69, 54]
第2趟:
[12, 18, 24, 32, 58, 36, 69, 54]
第3趟:
[12, 18, 24, 32, 54, 36, 58, 69]
第4趟:
[12, 18, 24, 32, 36, 54, 58, 69]
#6-归并排序
递归将数据划分为左右两边，直至长度为1；
然后将数据合并，全部合并完成即数组排好了序。

public class MergeSort {
	public void sort(int[] arr, int low, int high) {
		int mid = (low + high) / 2;
		if (low < high) {
			// 左边
			sort(arr, low, mid);
			// 右边
			sort(arr, mid + 1, high);
			// 左右归并
			merge(arr, low, mid, high);
			System.out.println("归并:");
			System.out.println(Arrays.toString(arr));
		}
	}

	public static void merge(int[] arr, int low, int mid, int high) {
		int[] temp = new int[high - low + 1];
		int i = low; // 左指针
		int j = mid + 1;// 右指针
		int k = 0;
		// 把较小的数先移到新数组中
		while (i <= mid && j <= high) {
			if (arr[i] < arr[j]) {
				temp[k++] = arr[i++];
			} else {
				temp[k++] = arr[j++];
			}
		}
		// 把左边剩余的数移入数组
		while (i <= mid) {
			temp[k++] = arr[i++];
		}
		// 把右边边剩余的数移入数组
		while (j <= high) {
			temp[k++] = arr[j++];
		}
		// 把新数组中的数覆盖arr数组
		for (int k2 = 0; k2 < temp.length; k2++) {
			arr[k2 + low] = temp[k2];
		}
	}

	@Test
	public void test() {
		int[] arr = { 69, 32, 58, 24, 39, 36, 54, 18 };
		System.out.println("初始数组：");
		System.out.println(Arrays.toString(arr));
		sort(arr, 0, arr.length - 1);
	}
}

######结果：
初始数组：
[69, 32, 58, 24, 39, 36, 54, 18]
归并:
[32, 69, 58, 24, 39, 36, 54, 18]
归并:
[32, 69, 24, 58, 39, 36, 54, 18]
归并:
[24, 32, 58, 69, 39, 36, 54, 18]
归并:
[24, 32, 58, 69, 36, 39, 54, 18]
归并:
[24, 32, 58, 69, 36, 39, 18, 54]
归并:
[24, 32, 58, 69, 18, 36, 39, 54]
归并:
[18, 24, 32, 36, 39, 54, 58, 69]
#7-堆排序
构建最大堆

public class HeapSort {
	
	public void sort(int[] arr){
		int n = arr.length;
		// 循环建堆
		for (int i = 0; i < n - 1; i++) {
			// 建堆
			buildMaxHeap(arr, n - 1 - i);
			// 交换堆顶和最后一个元素
			swap(arr, 0, n - 1 - i);
			System.out.println("第"+(i+1)+"趟：");
			System.out.println(Arrays.toString(arr));
		}
	}
	
	// 对data数组从0到lastIndex建大顶堆
	public void buildMaxHeap(int[] data, int lastIndex) {
		// 从lastIndex处节点（最后一个节点）的父节点开始
		for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
			// k保存正在判断的节点
			int k = i;
			// 如果当前k节点的子节点存在
			while (k * 2 + 1 <= lastIndex) {
				// k节点的左子节点的索引
				int biggerIndex = 2 * k + 1;
				// 如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
				if (biggerIndex < lastIndex) {
					// 若果右子节点的值较大
					if (data[biggerIndex] < data[biggerIndex + 1]) {
						// biggerIndex总是记录较大子节点的索引
						biggerIndex++;
					}
				}
				// 如果k节点的值小于其较大的子节点的值
				if (data[k] < data[biggerIndex]) {
					// 交换他们
					swap(data, k, biggerIndex);
					// 将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
					k = biggerIndex;
				} else {
					break;
				}
			}
		}
	}
	// 交换
	public void swap(int[] data, int i, int j) {
		int tmp = data[i];
		data[i] = data[j];
		data[j] = tmp;
	}

	@Test
	public void test() {
		int[] arr = { 32, 69, 58, 24, 39, 36, 54, 18 };
		System.out.println("初始化数据：");
		System.out.println(Arrays.toString(arr));
		sort(arr);
	}
}

######结果：
初始化数据：
[32, 69, 58, 24, 39, 36, 54, 18]
第1趟：
[18, 39, 58, 24, 32, 36, 54, 69]
第2趟：
[18, 39, 54, 24, 32, 36, 58, 69]
第3趟：
[18, 39, 36, 24, 32, 54, 58, 69]
第4趟：
[18, 32, 36, 24, 39, 54, 58, 69]
第5趟：
[24, 32, 18, 36, 39, 54, 58, 69]
第6趟：
[18, 24, 32, 36, 39, 54, 58, 69]
第7趟：
[18, 24, 32, 36, 39, 54, 58, 69]
#8-桶排序
消耗内存大，一般不建议使用。

public class BucketSort {
	public void sort(int[] arr){
        int n = arr.length;
        List<ArrayList<Integer>> Blist = new ArrayList<>(n);
        for(int i = 0; i < n; i++){
            Blist.add(new ArrayList<Integer>());
        }
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int a : arr){
            max = Math.max(max, a);
            min = Math.min(min, a);
        }
        for(int i : arr){
        	int index = (int)((i-min) / (max-min+1.0) * arr.length); 
            Blist.get(index).add(i);
        }
  
        for(int i = 0; i < Blist.size(); i++){
            Collections.sort(Blist.get(i));
        }
        System.out.println(Blist);
        int j = 0;
        for(ArrayList<Integer> list : Blist){
            for(int i : list){
                arr[j++] = i;
            }
        }
	}
	@Test
	public void test(){
        int arr[] = {1,6,6,8,3,5,9,2,1,5};
        System.out.println("初始数组：");
        System.out.println(Arrays.toString(arr));
        sort(arr);
        System.out.println("桶排序：");
        System.out.println(Arrays.toString(arr));
	}
}

######结果：
初始数组：
[1, 6, 6, 8, 3, 5, 9, 2, 1, 5]
[[1, 1], [2], [3], [], [5, 5], [6, 6], [], [8], [9], []]
桶排序：
[1, 1, 2, 3, 5, 5, 6, 6, 8, 9]
#各个排序比较
这里写图片描述

fwhui
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序算法java实现
04-07
主要总结了常用的七大排序算法java实现！
八大常用算法概念及其区别
zzzzzzzzzzxcvbnm的博客
09-17 1586
一、算法思想 （一）递归（recursion） 　直接或间接地调用自身的算法称为递归算法。用函数自身给出定义的函数称为递归函数。每个递归函数都要有非递归定义的初始值。 关键要素：边界条件、递归方程 　典型案例：斐波那契、汉诺塔 （二）分治法（divide and conquer method） 　将一个规模为n的问题分解为k个规模较小的子问题，这些子问题相互独立且与原问题相同。递归的解这些子问题，然后将各个子问题的解合并得到原问题的解。 　典型案例：二分法、归并排序、快速排序、汉诺塔 （三）动态规划法（dy
（一）八大算法思想
weixin_34187822的博客
01-02 794
八大算法 八大算法：枚举、递推、递归、分治、贪心、试探法、动态迭代和模拟算法思想。 一、枚举算法思想（暴力算法） 　　将问题的所有可能答案一一列举，根据判断条件判断此答案是否合适，一般用循环实现。 　　经典运用：百钱买百鸡、填写运算符 二、递推算法思想 　　1.顺推法：从已知条件出发，逐步推算出要解决问题的方法。 　　2.逆推法：从已知结果出发，用迭代表达式逐步推算出问题开始的...
八大算法总结
u012371712的博客
04-30 803
直接上个图，这个图应该你见过很多次了。简单的就是说各个算法的优劣对比。这个其实还是要到代码里去看，去理解了。   排序算法是我们编程中遇到的最多的算法。目前主流的算法有8种。   平均时间复杂度从高到低依次是：   冒泡排序（o(n2)），选择排序（o(n2)），插入排序（o(n2)），堆排序（o(nlogn)），   归并排序（o(nlogn)），快速排序（o(nlogn)）， 希...
【数据结构】 常见的八大排序算法
阿润菜菜的博客
12-25 1万+
​排序有内部排序和外部排序，这里八大排序就是内部排序，指直接插入，希尔，选择，堆排，冒泡，快排，归并，计数。 附有动图解释和思维导图汇总
八大排序算法详解（通俗易懂）
weixin_61661271的博客
08-03 1万+
排序算法很重要，本篇重点讲解它，如果本篇博客对你有所帮助，请给博主一个三连哦！
java实现归并排序算法
09-03
归并排序：是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 本文我们就来详细的探讨下。
各种排序算法java实现
10-23
java实现的多种排序算法，包括冒泡排序，快速排序，选择排序等
排序算法的Java实现
最新发布
07-19
排序算法的Java实现
三种线性排序算法Java实现
08-07
本资源包含桶排序，基数排序与计数排序三种线性排序算法
回顾经典，八大算法。
置身于量子事业的软件开发爱好者
11-23 1万+
ssss其实早在一年前，对于八大算法就能1个多小时全部复现出来，起初没觉得有什么，但什么随着力扣刷题，发现八大排序算法越来越重要，因此，我觉得有必要对其进行总结，或许已经有很多人对其总结了，不过总是不如自己亲身经历一遍，再复现一遍，算法重要，思维更重要。 ssss排序的分类： ssdssss①、内部排序：指将需要处理的所有数据都加载到内部存储器（内存）中进行排序 sdsssss②、外部排序法： 数据量过大，无法全部加载到内存中，需要借助外部存储（文件等）进行排序 ssss而我们所说的方法，都是内部方法。 s
【数据结构与算法 11，互联网大厂面试必问的JVM底层原理
m0_61440508的博客
09-06 696
int min = arr[minIndex]; for(int j = 1 + i;j<arr.length;j++){ if(min > arr[j]){ min = arr[j]; minIndex = j; } } arr[minIndex] = arr[i]; arr[i] = min; } } 4、速度测试 选择排序：120000数...
八大算法基础思想
h21396577548的博客
11-05 6278
八大基础算法思想 算法和数据结构是每个程序员都必须修炼的内功，在面试的时候或多或少都会被问到一些算法相关的问题。 算法的应用不单只体现在编程中。狭义的来讲，算法可看作是数据传递和处理的顺序、方法和组成方式，就像是各种排序算法等。广义的来讲，算法更像是一种事物运行的逻辑和规则。 算法其实是一种思维模式，本文就简单介绍一下八种常用算法思想，分别是枚举、递推、递归、分治、动态规划、贪心、回溯和模拟。 1.枚举算法 最简单的枚举算法，也被称为穷举，顾名思义就是穷尽列举。枚举思想的应用最为广泛，也最是通俗易懂。枚举思
十种常见排序算法
liyongchunscr的博客
11-16 1万+
0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 0.2 算法复杂度 0.3 相关概念 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 .
8种常见的排序算法-----你值得掌握（很细，很全）
一个计算机爱好者学习历程
01-21 3090
一、排序的概念 排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。 例如： 内部排序：数据元素全部放在内存中的排序。 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存
八大经典排序算法
热门推荐
weixin_43164548的博客
03-01 1万+
详细讲解了经典的排序算法的思路和实现过程
八大常见算法
wangxiaojia42121的博客
04-19 463
概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。          当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。    快速排序：是目前基于比较的内部排序中被认为是最好的方法，
常用排序算法
南飞的孤雁
09-12 3415
8种常用排序算法
十种常见的排序算法
weixin_30920091的博客
08-03 4009
1.常见算法分类 十种常见排序算法一般分为以下几种： （1）非线性时间比较类排序：交换类排序（快速排序和冒泡排序）、插入类排序（简单插入排序和希尔排序）、选择类排序（简单选择排序和堆排序）、归并排序（二路归并排序和多路归并排序）； （2）线性时间非比较类排序：计数排序、基数排序和桶排序。 总结： （1）在比较类排序中，归并排序号称最快，其次是快速排序和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值