Java数据结构_7.排序算法(冒泡排序、快速排序、插入排序、希尔排序、选择排序、归并排序、基数排序、队列实现基数排序)

最新推荐文章于 2024-04-19 18:47:27 发布
最新推荐文章于 2024-04-19 18:47:27 发布
阅读量181 收藏
点赞数
分类专栏： java数据结构 文章标签： 队列 算法 数据结构 排序算法 快速排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45316053/article/details/107798759
版权

一、冒泡排序

package com.paixu;

import java.util.Arrays;

public class BubbleSort {

	public static void main(String[] args) {
		int[] arr = new int[] { 5, 7, 2, 15, 6, 9, 7, 3, 6, 8 };
		System.out.println("排序前:" + Arrays.toString(arr));
		bubbleSort(arr);
		System.out.println("排序后：" + Arrays.toString(arr));
	}

	// 冒泡排序
	// 5, 7, 2, 15, 6, 9, 7, 3, 6, 8
	// 共需要比较length-1轮
	// 第一轮比完找到最大值放在最后 5, 7, 2, 6, 9, 7, 3, 6, 8, 15
	public static void bubbleSort(int[] arr) {
		int k = 1;
		// 共比较多少轮
		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;
				}
			}
			System.out.println("第" + k + "次排列结果为:" + Arrays.toString(arr));
			k++;
		}
	}

}

二、快速排序

package com.paixu;

import java.util.Arrays;

public class QuickSort {

	public static void main(String[] args) {
		int[] arr = new int[] { 5, 7, 2, 15, 6, 9, 7, 3, 6, 8, 3, 5, 6, 4, 11, 22, 31, 0, 2, 5, 14 };
		System.out.println("排序前:" + Arrays.toString(arr));
		quickSort(arr, 0, arr.length - 1);
		System.out.println("排序后:" + Arrays.toString(arr));
	}

	// 快速排序
	public static void quickSort(int[] arr, int start, int end) {
		int k = 1;
		if (start < end) {
			// 把数组中第0个数字作为标准数
			int stard = arr[start];
			// 记录需要排序的下标
			int low = start;
			int high = end;
			// 循环找比标准数大的数和比标准数小的数
			while (low < high) {
				// 右边的数字比标准数大，右标准左移
				while (low < high && stard <= arr[high]) {
					high--;
				}
				// 右边数字比标准数小，使用右边的数替换左边的数
				arr[low] = arr[high];
				// 左边的数比标准数小，左标准右移
				while (low < high && arr[low] <= stard) {
					low++;
				}
				// 左边数字比标准数小，使用左边的数替换右边的数
				arr[high] = arr[low];
			}
			// 最后把标准数赋给到最终剩下的一个数
			arr[low] = stard;
			// 处理所有左边数，处理所有右边数
			quickSort(arr, start, low);
			quickSort(arr, low + 1, end);
		}
	}
}

三、插入排序

package com.paixu;

import java.util.Arrays;

public class InsertSort {

	public static void main(String[] args) {
		int arr[] = new int[] { 5, 3, 6, 7, 8, 9, 5, 1, 1, 21, 23, 51, 41, 17, 4 };
		System.out.println("排序前:" + Arrays.toString(arr));
		insertSort(arr);
		System.out.println("排序后:" + Arrays.toString(arr));
	}

	// 插入排序
	public static void insertSort(int arr[]) {
		int k = 1;
		// 遍历所有的数字
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] < arr[i - 1]) {
				int temp = arr[i];
				int j;
				// 遍历当前数组前面的数字
				for (j = i - 1; j >= 0 && arr[j] > temp; j--) {
					arr[j + 1] = arr[j];
				}
				arr[j + 1] = temp;
			}
			System.out.println("第" + k + "次排列结果为:" + Arrays.toString(arr));
			k++;
		}
	}
}

四、希尔排序

package com.paixu;

import java.util.Arrays;

public class ShellSort {

	public static void main(String[] args) {
		int arr[] = new int[] { 5, 3, 6, 7, 8, 9, 5, 1, 1, 21, 23, 51, 41, 17, 4 };
		System.out.println("排序前:" + Arrays.toString(arr));
		shellSort(arr);
		System.out.println("排序后:" + Arrays.toString(arr));
	}

	// 希尔排序(比直接插入排序效率更高)
	public static void shellSort(int[] arr) {
		int k = 1;
		// 遍历所有的步长(增量)
		for (int d = arr.length / 2; d > 0; d /= 2) {
			// 遍历所有元素
			for (int i = d; i < arr.length; i++) {
				// 遍历本组中所有元素
				for (int j = i - d; j >= 0; j -= d) {
					if (arr[j] > arr[j + d]) {
						int temp = arr[j];
						arr[j] = arr[j + d];
						arr[j + d] = temp;
					}
				}
			}
			System.out.println("第" + k + "次排列结果为:" + Arrays.toString(arr));
			k++;
		}
	}

}

五、选择排序

package com.paixu;

import java.util.Arrays;

public class SelectSort {

	public static void main(String[] args) {
		int arr[] = new int[] { 5, 3, 6, 7, 8, 9, 5, 1, 1, 21, 23, 51, 41, 17, 4 };
		System.out.println("排序前:" + Arrays.toString(arr));
		selectSort(arr);
		System.out.println("排序后:" + Arrays.toString(arr));
	}

	// 选择排序
	public static void selectSort(int[] arr) {
		int k = 1;
		for (int i = 0; i < arr.length; i++) {
			int minIndex = i;
			// 把当前遍历的数和后面的所有数依次比较，并记录最小的数下标
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[minIndex] > arr[j]) {
					minIndex = j;
				}
			}
			// 如果最小的数和当前遍历的数不一致,交换
			if (i != minIndex) {
				int temp = arr[i];
				arr[i] = arr[minIndex];
				arr[minIndex] = temp;
			}
			System.out.println("第" + k + "次排列结果为:" + Arrays.toString(arr));
			k++;
		}
	}

}

六、归并排序

package com.paixu;

import java.util.Arrays;

public class MergeSort {

	public static void main(String[] args) {
		int arr[] = new int[] { 5, 3, 6, 7, 8, 9, 5, 1, 1, 21, 23, 51, 41, 17, 4 };
		System.out.println("排序前:" + Arrays.toString(arr));
		mergeSort(arr, 0, arr.length - 1);
		System.out.println("排序后:" + Arrays.toString(arr));
	}

	// 归并排序
	public static void mergeSort(int[] arr, int low, int high) {
		int middle = (high + low) / 2;
		if (low < high) {
			mergeSort(arr, low, middle);
			mergeSort(arr, middle + 1, high);
			merge(arr, low, middle, high);
		}
	}

	public static void merge(int[] arr, int low, int middle, int high) {
		// 用于存储归并后的临时数组
		int[] temp = new int[high - low + 1];
		// 用于记录第一个数组中需要遍历的下标
		int i = low;
		// 用于记录第一个数组中需要遍历的下标
		int j = middle + 1;
		// 用于记录在临时数组中存放的下标
		int index = 0;
		// 遍历两个数组，取出小的数字放入临时数组中
		while (i <= middle && j <= high) {
			if (arr[i] <= arr[j]) {
				temp[index] = arr[i];
				i++;
			} else {
				temp[index] = arr[j];
				j++;
			}
			index++;
		}
		// 处理多余的数据
		while (j <= high) {
			temp[index] = arr[j];
			j++;
			index++;
		}
		while (i <= middle) {
			temp[index] = arr[i];
			i++;
			index++;
		}
		// 把临时数组中的数放入原数组
		for (int k = 0; k < temp.length; k++) {
			arr[k + low] = temp[k];
		}
	}

}

七、基数排序

package com.paixu;

import java.util.Arrays;

public class RadixSort {

	public static void main(String[] args) {
		int[] arr = new int[] { 1, 58, 156, 68, 445, 2221, 485, 45, 469, 574, 11, 322, 3, 45, 68, 45 };
		radixSort(arr);
		System.out.println(Arrays.toString(arr));
	}

	// 基数排序
	public static void radixSort(int[] arr) {
		// 最大数
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		// 计算最大数是几位数
		int maxLength = (max + "").length();
		// 用于临时存储数据的二维数组
		int[][] temp = new int[10][arr.length];
		// 用于记录在temp中相应数组存的数的数量
		int[] counts = new int[10];
		// 根据最大长度的数决定比较的次数
		for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {// n:第一次取个位，第二次取百位...
			// 把每个数分别计算余数
			for (int j = 0; j < arr.length; j++) {
				// 计算余数
				int ys = arr[j] / n % 10;
				temp[ys][counts[ys]] = arr[j];
				counts[ys]++;
			}
			// 记录取得元素需要放到原数组的位置
			int index = 0;
			// 把数字取出来
			for (int k = 0; k < counts.length; k++) {
				if (counts[k] != 0) {
					for (int l = 0; l < counts[k]; l++) {
						arr[index] = temp[k][l];
						index++;
					}
					// 把数量置为0
					counts[k] = 0;
				}
			}
		}
	}
}

八、队列实现基数排序

1.队列

package com.paixu;

/**
 * 队列:先进先出
 * 
 * @author l1
 *
 */
public class MyQueue {
	int[] elements;

	public MyQueue() {
		elements = new int[0];
	}

	// 查看队列中所有元素
	public String show() {
		String stringQueue = "";
		for (int i = 0; i < elements.length; i++) {
			stringQueue += elements[i] + " ";
		}
		return stringQueue;
	}

	// 入队
	public void add(int element) {
		int newArr[] = new int[elements.length + 1];
		for (int i = 0; i < elements.length; i++) {
			newArr[i] = elements[i];
		}
		newArr[elements.length] = element;
		elements = newArr;
	}

	// 出队
	public int poll() {
		// 把数组第0个元素取出
		int element = elements[0];
		int[] newArr = new int[elements.length - 1];
		// 复制原数组中的元素到新数组中
		for (int i = 0; i < newArr.length; i++) {
			newArr[i] = elements[i + 1];
		}
		// 替换数组
		elements = newArr;
		return element;
	}

	// 判断队列是否为空
	public boolean isEmpty() {
		return elements.length == 0;
	}
}

2.排序

package com.paixu;

import java.util.Arrays;

public class RadixMyQueueSort {

	public static void main(String[] args) {
		int[] arr = new int[] { 1, 58, 156, 68, 445, 2221, 485, 45, 469, 574, 11, 322, 3, 45, 68, 45 };
		radixSort(arr);
		System.out.println(Arrays.toString(arr));
	}

	// 队列实现基数排序
	public static void radixSort(int[] arr) {
		// 最大数
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		// 计算最大数是几位数
		int maxLength = (max + "").length();
		// 用于临时存储数据的队列数组
		MyQueue temp[] = new MyQueue[10];
		// 为队列数组赋值
		for (int i = 0; i < temp.length; i++) {
			temp[i] = new MyQueue();
		}
		// 根据最大长度的数决定比较的次数
		for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {// n:第一次取个位，第二次取百位...
			// 把每个数分别计算余数
			for (int j = 0; j < arr.length; j++) {
				// 计算余数
				int ys = arr[j] / n % 10;
				temp[ys].add(arr[j]);
			}
			// 记录取得元素需要放到原数组的位置
			int index = 0;
			// 把数字取出来
			for (int k = 0; k < temp.length; k++) {
				while (!temp[k].isEmpty()) {
					arr[index] = temp[k].poll();
					index++;
				}
			}
		}
	}
}
郝穹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
主要介绍了Java如何实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序 、快速排序、归并排序、堆排序和LST基数排序,需要的朋友可以参考下
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
热门推荐
HanMeng的博客
07-24 54万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
十大经典排序算法-归并排序算法详解
qq_35344198的博客
06-19 11万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
【JavaSE与数据结构】排序算法之冒泡排序，选择排序，插入排序与希尔排序
未见花闻的博客
02-21 1084
本篇文章带大家认识排序算法——冒泡排序，选择排序，插入排序与希尔排序，其中冒泡排序，选择排序，插入排序是基础的排序算法，希尔排序是插入排序的优化，四种排序算法全部都是基于比较的排序算法，本文将以图解动图的方式描述算法实现过程，实现代码为java。
【数据结构】八大排序(超详解+附动图+源码)
Edward_Asia的博客
11-21 7万+
前言 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 生活中各种地方都需要用到排序，所以学好排序算法是非常重要的。 排序分为 内部排序 和 外部排序。 内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。 这部分主要是内部排序。排序讲解都以升序为例。 常见的排序算法： // 排序实现的接口 // 插入排序 void InsertSort(int* arr..
哈工大数据结构实验5_冒泡排序与快速排序
03-26
（1） 冒泡排序和快速排序； （2） 插入排序和希尔排序； （3） 选择排序和堆排序； （4） 递归和非递归的归并排序。 2． 产生不同规模和分布的数据，以 Excel 生成算法执行时间 T(n)关于输入规模 n 的曲线的形式，...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
主要介绍了C++如何实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序 、快速排序、归并排序、堆排序和LST基数排序,需要的朋友可以参考下
八种排序算法原理及Java实现( 冒泡排序+快速排序直接插入排序+希尔排序+选择排序+归并排序+基数排序)
06-21
八种排序算法原理及Java实现( 冒泡排序+快速排序直接插入排序+希尔排序+选择排序+归并排序+基数排序)
排序算法演示：插入排序、选择排序、冒泡排序、希尔排序、归并排序、快速排序
12-03
排序算法演示：插入排序、选择排序、冒泡排序、希尔排序、归并排序、快速排序
华为校招机试 - 扑克牌消除（20240417）
伏城之外的博客
04-18 173
已支持（Java & JS & Python & C & C++），实现：栈结构
【Leetcode】2007. 从双倍数组中还原原数组
weixin_43627638的博客
04-19 124
一个整数数组original可以转变成一个数组changed，转变方式为将original中每个元素加入数组中，然后将所有元素。给你一个数组changed，如果change是数组，那么请你返回original数组，否则请返回空数组。original的元素可以以顺序返回。
每日两题1
FZC206的博客
04-14 326
可以试着倒着走，时间及空间复杂度不变；空间复杂度可以优化为O(1);
FloodFill算法简介（用BFS、DFS算法解决）
2301_76197086的博客
04-18 143
FloodFill算法简介
leetcode--3 无重复最长字串
m0_73173239的博客
04-15 670
给定一个字符串s，请你找出其中不含有重复字符的的长度。3因为无重复字符的最长子串是"abc"，所以其长度为 3。1因为无重复字符的最长子串是"b"，所以其长度为 1。3因为无重复字符的最长子串是"wke"，所以其长度为 3。请注意，你的答案必须是的长度，"pwke"是一个子序列，不是子串。
有关栈的练习
最新发布
luhaimin7的博客
04-19 838
有关栈的练习
算法：堆（优先队列）
得克特
04-18 142
堆（优先队列）分为最大堆和最小堆。
代码随想录算法训练营第三十八天|509.斐波那契数、70.爬楼梯、746. 使用最小花费爬楼梯
weilana的博客
04-15 310
楼梯和最小花费爬楼梯有点绕，理解了就好很多。学习时间90min。《代码随想录》。
【C语言】深入解析插入排序算法
qq_40205510的博客
04-19 266
本文将详细介绍插入排序算法的基本思想、算法步骤、性能分析以及C语言实现示例。通过本文的学习，读者将能够深入理解插入排序算法，并在实际编程中灵活运用。
直接插入排序，希尔排序，冒泡排序，快速排序，简单选择排序，堆排序，归并排序算法。
05-24
4. 快速排序：选定一个基准值，将数列分为左右两个部分，左边的元素都小于基准值，右边的元素都大于基准值，递归地对左右两个部分进行快速排序。时间复杂度为O(nlogn)。 5. 简单选择排序：从待排序的数列中选择最小...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值