Java数据结构与算法笔记——排序算法(全)

最新推荐文章于 2024-10-25 18:01:58 发布
最新推荐文章于 2024-10-25 18:01:58 发布
阅读量86 收藏
点赞数
分类专栏： Java数据结构与算法笔记 文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51382726/article/details/120597724
版权
该篇博客详细展示了多种排序算法的实现，包括冒泡排序、优化后的冒泡排序、选择排序、插入排序、希尔排序（交换式和位移式）、快速排序以及归并排序。博主通过代码实现并测试了这些排序算法，最后使用基数排序和快速排序对一个大数组进行排序，对比了它们的时间效率。
摘要由CSDN通过智能技术生成 
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class PX {
	public static void main(String[] args) {
//		int[] arr = new int[80000];
//		for(int i=0;i<80000;i++) {
//			arr[i]=(int)(Math.random()*800000);
//		}
//		PXExample pX = new PXExample();
//		Date date1=new Date();
//		SimpleDateFormat simple1=new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
//		String date1Str=simple1.format(date1);
//		System.out.println(date1Str);
//		pX.maoPao2(arr);
//		Date date2=new Date();
//		String date2Str=simple1.format(date2);
//		System.out.println(date2Str);
		PXExample pX = new PXExample();
//		int arr[] = new int[10];
//		int temp2[] = new int[10];
		int arr[] = new int[10000000];
		for (int i = 0; i < 10000000; i++) {
			arr[i] = (int) (Math.random() * 100000000);
		}
		// pX.maoPao1(arr);
		// pX.maoPao2(arr);
		// pX.xuanZe(arr);
		// pX.chaRu(arr);
		// pX.shellSort1(arr);
		// pX.shellSort2(arr);
		Date date1 = new Date();
		SimpleDateFormat simple1 = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
		String date1Str = simple1.format(date1);
		System.out.println(date1Str);
		// pX.mergeSort(arr, 0, arr.length - 1, temp2);
		// pX.kuaiSu(arr, 0, arr.length - 1);
		pX.radixSort(arr);
		;
		Date date2 = new Date();
		String date2Str = simple1.format(date2);
		System.out.println(date2Str);
		// System.out.println("快速排序：" + Arrays.toString(arr));
		// System.out.println("归并排序：" + Arrays.toString(arr));
	}

}

class PXExample {
	static int temp;

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

	// 冒泡排序
	public void maoPao1(int[] arr) {
		int temp = 0;
		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]) {
					swap(arr, j, j + 1);
				}
			}
		}
		System.out.println("冒泡排序：" + Arrays.toString(arr));
	}

	// 冒泡排序优化
	public void maoPao2(int[] arr) {
		int temp = 0;
		boolean flag;
		for (int i = 0; i < arr.length - 1; i++) {
			flag = false;
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					swap(arr, j, j + 1);
					flag = true;
				}
			}
			if (!flag)
				break;
		}
		System.out.println("优化后的冒泡排序：" + Arrays.toString(arr));
	}

	// 选择排序
	public void xuanZe(int arr[]) {
		int minIndex;
		for (int i = 0; i < arr.length - 1; i++) {
			minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[minIndex] > arr[j]) {
					minIndex = j;
				}
			}
			swap(arr, minIndex, i);
		}
		System.out.println("选择排序：" + Arrays.toString(arr));
	}

	// 插入排序
	public void chaRu(int arr[]) {
		for (int i = 1; i < arr.length; i++) {
			int insertVal = arr[i];
			int insertIndex = i - 1;
			while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
				arr[insertIndex + 1] = arr[insertIndex];
				insertIndex--;
			}
			arr[insertIndex + 1] = insertVal;
		}
		System.out.println("插入排序：" + Arrays.toString(arr));
	}

	// 希尔排序（交换式）
	public void shellSort1(int[] arr) {
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			for (int i = gap; i < arr.length; i++) {
				for (int j = i - gap; j >= 0; j -= gap) {
					if (arr[j] > arr[j + gap]) {
						swap(arr, j, j + gap);
					}
				}
			}
		}
		System.out.println("希尔排序（交换式）：" + Arrays.toString(arr));
	}

	// 希尔排序（位移式）
	public void shellSort2(int[] arr) {
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			for (int i = gap; i < arr.length; i++) {
				int j = i;
				int temp1 = arr[j];
				if (arr[j - gap] > arr[j]) {
					// while中的判断顺序不能改变，如果改变可能会导致j-gap<0导致数组越界
					while (j - gap >= 0 && arr[j - gap] > temp1) {
						arr[j] = arr[j - gap];
						j -= gap;
					}
					arr[j] = temp1;
				}
				// arr[j + gap] = temp1;如果把这行放在这里，可能当if语句没运行时，导致数组越界。
			}
		}
//		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
//			for (int i = gap; i < arr.length; i++) {
//				int j = i;
//				int temp1 = arr[j];
//				if (arr[j] < arr[j - gap]) {
//					while (j - gap >= 0 && temp1 < arr[j - gap]) {
//						arr[j] = arr[j - gap];
//						j -= gap;
//					}
//					arr[j] = temp1;
//				}
//			}
//		}
		System.out.println("希尔排序:（位移式）" + Arrays.toString(arr));
	}

	// 快速排序
	public void kuaiSu(int arr[], int left, int right) {
		int l = left, r = right;
		int pivot = arr[(left + right) / 2];
		while (l < r) {
			while (arr[l] < pivot) {
				l++;
			}
			while (arr[r] > pivot) {
				r--;
			}
			if (l == r) {
				break;
			}
			swap(arr, l, r);
			if (arr[l] == pivot) {
				r--;
			}
			if (arr[r] == pivot) {
				l++;
			}
			/*
			 * if(arr[l]==pivot) { r--; } if(arr[r]==pivot) { l++; }
			 * 这些代码不能省略，如果省略会导致当数组中有重复的数字时，无妨推出
			 */
		}
		if (l == r) {
			l++;
			r--;
		}
		if (left < r) {
			kuaiSu(arr, left, r);
		}
		if (l < right) {
			kuaiSu(arr, l, right);
		}
	}

	public void quickSort(int arr[], int left, int right) {
		int l = left, r = right;
		int pivot = arr[(left + right) / 2];
		while (l < r) {
			while (arr[l] < pivot) {
				l++;
			}
			while (arr[r] > pivot) {
				r--;
			}
			if (l >= r) {// 这里可以用>=也可以用==
				break;
			}
			swap(arr, r, l);
			if (arr[r] == pivot) {
				l++;
			}
			if (arr[l] == pivot) {
				r--;
			}
		}
		if (l == r) {
			r--;
			l++;
		}
		if (l < right) {
			quickSort(arr, l, right);
		}
		if (left < r) {
			quickSort(arr, left, r);
		}
	}

	// 归并排序
	public void guiBingPaiXu(int arr[], int left, int right, int temp2[]) {
		if (left < right) {
			int mid = (right + left) / 2;
			guiBingPaiXu(arr, left, mid, temp2);
			guiBingPaiXu(arr, mid + 1, right, temp2);
			guiBing(arr, left, mid, right, temp2);
		}
	}

	public void guiBing(int arr[], int left, int mid, int right, int temp2[]) {
		int i = left, j = mid + 1;
		int t = 0;
		while (i <= mid && j <= right) {
			if (arr[i] <= arr[j]) {
				temp2[t++] = arr[i++];
			} else {
				temp2[t++] = arr[j++];
			}
		}
		while (i <= mid) {
			temp2[t++] = arr[i++];
		}
		while (j <= right) {
			temp2[t++] = arr[j++];
		}
		t = 0;
		while (left <= right) {
			arr[left++] = temp2[t++];
		}
	}

	// 分+合方法
	public void mergeSort(int[] arr, int left, int right, int[] temp) {
		if (left < right) {
			int mid = (left + right) / 2;
			// 先向左递归分解
			mergeSort(arr, left, mid, temp);
			// 然后向右分解
			mergeSort(arr, mid + 1, right, temp);
			// 每分解一次就合并一次
			merge(arr, left, mid, right, temp);
		}
	}

	/**
	 *
	 * @param arr   要排序的数组
	 * @param left
	 * @param mid   中间索引
	 * @param right
	 * @param temp  中转数组
	 */
	public void merge(int[] arr, int left, int mid, int right, int[] temp) {
//        System.out.println("xxx");
		int i = left; // 初始化左边序列的初始索引
		int j = mid + 1;// 初始化右边序列的初始索引
		int t = 0;

		// (1)
		// 先把左右两边的（有序）的数据按照规则填到数组里面
		// 直到两边的有序序列有一边处理完为止
		while (i <= mid && j <= right) {
			// 左边有序序列的当前元素小于等于右边元素
			if (arr[i] <= arr[j]) {
				temp[t++] = arr[i++];
			} else {
				temp[t++] = arr[j++];
			}

		}

		// (2)
		// 把有剩余数据的一边数据依次完全填充到temp

		while (i <= mid) {
			temp[t++] = arr[i++];
		}

		while (j <= right) {
			temp[t++] = arr[j++];
		}

		// (3)
		// 将temp数组的元素拷贝到arr
		// 并不是每次都拷贝所有数据到原来的数组 从下往治
		t = 0;
		int tempLeft = left;
//        System.out.println("tempLeft = "+ tempLeft+",right = "+right);
		while (tempLeft <= right) {
			arr[tempLeft++] = temp[t++];
		}
	}

	// 基数排序
	public void jishu(int arr[]) {
		int temp1 = 0;
		int divisor = 1;
		while (true) {
			int zeroTime = 0;
			int[] k = new int[10];
			int bucket[][] = new int[10][arr.length];
			for (int i = 0; i < arr.length; i++) {
				// temp1 = (arr[i] / divisor)%10;
				temp1 = (arr[i] / divisor) % 10;
				if (temp1 == 0)
					zeroTime++;
				bucket[temp1][k[temp1]++] = arr[i];
			}
			divisor *= 10;
			if (zeroTime == arr.length)
				break;
			int sortTime = 0;
			for (int i = 0; i < 10; i++) {
				if (k[i] != 0) {
					for (int j = 0; j < k[i]; j++) {
						arr[sortTime++] = bucket[i][j];
					}
				}
			}
		}
		System.out.println("基数排序：" + Arrays.toString(arr));
	}

	public void radixSort(int arr[]) {
		// 先找到最大数的位数
		int max = arr[0];
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		int maxLength = (max + "").length();

		// 用这个二维数组表示桶
		int[][] bucket = new int[10][arr.length];

		// 用这个记录桶中数字的数量
		int[] bucketElementCounts = new int[10];

		// 开始循环
		for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
			for (int j = 0; j < arr.length; j++) {
				int digitOfElement = (arr[j] / n) % 10;
				bucket[digitOfElement][bucketElementCounts[digitOfElement]++] = arr[j];
			}
			// 把桶中的数据放入原来的数组中
			int index = 0;
			for (int k = 0; k < 10; k++) {
				if (bucketElementCounts[k] != 0) {
					for (int j = 0; j < bucketElementCounts[k]; j++) {
						arr[index++] = bucket[k][j];
					}
					bucketElementCounts[k] = 0;
				}
			}
		}

		// 输出结果
		//System.out.println("基数排序：" + Arrays.toString(arr));
	}
}
wlrobot
关注
专栏目录
尚硅谷Java数据结构与java算法 全194章笔记整理
Foools的博客
08-11 2236
前言 视频地址：https://www.bilibili.com/video/BV1E4411H73v?from=search&seid=13120683720695451628 评价：整个教程的数据结构部分讲的挺好的，知识点全都覆盖了，而且每个数据结构都有代码解释，但是最后20节算法部分讲的有点乱，算法部分我决定直接刷leetcode了 数组 稀疏数组： 二维数组的省内存的保存方法，一般是n行3列，三列分别为行，列，值。 二维数组转稀疏数组： 遍历整个二维数组，查看有多少个有效数字 根据有效数字
java怎么遍历优先级队列_Java数据结构与算法笔记——优先级队列
weixin_34246474的博客
02-24 1436
文章目录优先级队列介绍普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。在插入元素时，要按照优先级找到正确的位置并插入。实现一个简单的优先级队列数值的大小作为优先级，数值越大优先级越高。插入：根据元素的大小插入。取出：取出队头元素。在这里插入代码片package queue;public class QueueTest3 {public stat...
【数据结构与算法】——学习笔记
2301_79175212的博客
09-06 1618
今天从恩师惠老师那里受赠一本C语言版本的数据结构，万分感动，在此立誓，誓要学好数据结构，掌握好算法，争取做出一番成就，绝不辜负恩师的期望。
数据结构与算法学习笔记——希尔排序
惟愿此间无白头的博客
02-22 320
希尔排序 —— 插入排序的升级版 1. 希尔排序介绍 希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。它的时间复杂度为O(n^(1.3—2))。 2. 希尔排序法基本思想 希尔排序是把数据按下标的一定增量分组，对每组使用插入排序；随着增量逐渐减少，当增量减至1时，整个数据恰被分成...
Java 数据结构与算法1——几个经典算法面试题
weixin_45968656的博客
02-08 414
简介 本文会介绍十大常用算法，二分查找（非递归)、分治、动态规划、贪心、KMP、马踏棋盘等 先看几个经典算法面试题 字符串匹配问题 1)有一个字符串 str1="“硅硅谷尚硅谷你尚硅尚硅谷你尚硅谷你尚硅你好”"，和一个子串 str2=“尚硅谷你尚硅你” 2)现在要判断str1是否含有str2，如果存在，就返回第一次出现的位置,如果没有，则 返回-1 3)要求用最快的速度来完成匹配 4)你的思路是什么? 思路一：暴力匹配，简单、效率低 思路二：KMP算法，部分匹配表 汉诺塔游戏 请完成汉诺塔游戏的代码
数据结构（王道笔记）——九大内部排序算法详解及比较（Java实现）
lranqi的博客
08-23 801
内部排序，是指在排序期间元素全部存放在内存中的排序。包括插入排序（直接插入排序、折半插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（简单选择排序、堆排序）、归并排序、基数排序 九大排序算法。内部排序算法的性能取决于算法的时间复杂度和空间复杂度，而时间复杂度一般是由比较和移动的次数决定的。文章详细介绍了哥哥排序基本思想及Java代码实现，并介绍了时间复杂度、空间复杂度、稳定性、过程特征、最坏情况的下界、适用性及应用。来源于王道一书的课程笔记。
数据结构（Java）学习笔记——知识点：排序算法（一）
qq_44699157的博客
07-16 414
数据结构知识点中有关排序算法方面的问题，以及具体排序算法的代码实现。
【结构与算法】—— 排序算法总结 | 八大排序算法详解
看世界，也找自己
10-22 827
排序算法是最经典的算法知识。因为其实现代码短，应该广，在面试中经常会问到排序算法及其相关的问题。一般在面试中最常考的是快速排序和归并排序等基本的排序算法，并且经常要求现场手写基本的排序算法。如果这些问题回答不好，估计面试就凉凉了。所以熟练掌握排序算法思想及其特点并能够熟练地手写代码至关重要。
12.21_黑马数据结构与算法笔记Java
2301_80185446的博客
12-21 896
//最近在复习，，java的进度会比较慢一些目录219 排序算法 基数排序2220 排序算法 java排序221 排序 e01 根据另一个数组次序排序222 排序 e02 根据出现频率排序223 排序 e03 最大间距 解法1（超出内存限制）224 排序 e03 最大间距 解法2225 排序 e03 最大间距 解法3226 排序 e03 最大间距 解法4227 图 基本概念228 图 表示方式229 图 java表示230 图 DFS不可以先排百位再排个位的原因是因为，越到后面，优先级越高，最后排个位的话，
Java数据结构和算法笔记总结
笔记别偷看
11-19 1470
第 1章 数据结构和算法概述 数据结构和算法的关系 数据 data 结构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了数据结构.学好数据结构可以编写出更加漂亮,更加有效率的代码。 要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决. 程序 = 数据结构 + 算法 数据结构是算法的基础, 换言之，想要学好算法，需要把数据结构学到位。 数据结构和算法的应用 修路问题 => 最小生成树(加权值)【数据结构】+ 普利姆算法 最短路径问题 => 图+弗洛
《Java数据结构和算法》学习笔记(2)——4种简单排序算法
03-14
在编程领域，掌握数据结构和算法是提升编程能力的关键步骤，尤其是在Java这样的高级语言中。本文将深入探讨四种简单的排序算法：插入排序、冒泡排序、选择排序。这些算法虽然在复杂度上不如高级排序算法如快速排序或...
《Java数据结构和算法》学习笔记(5)——递归 归并排序
03-14
在本篇《Java数据结构和算法》学习笔记中，我们将深入探讨递归和归并排序。递归是一种强大的编程技术，常用于解决复杂问题，而归并排序则是利用递归实现的一种高效排序算法。 首先，让我们理解什么是递归。递归是...
数据结构——笛卡尔树详解
数据结构和算法
10-22 657
前面我们讲过《堆》和《二叉搜索树》，能不能把这两种数据结构的特性结合起来构造一棵新的树呢？当然是可以的，这个就是我们这里要讲的笛卡尔树(笛卡尔树的每个节点有两个值(x，y)，其中一个满足二叉搜索树的特性，一个满足堆的特性，所以笛卡尔树是一棵具有二叉搜索树和堆的两种特性的二叉树笛卡尔树中节点的两个值分别是数组中元素的值，和该元素在数组中的下标，其中元素的值满足堆的特性，元素的下标满足二叉搜索树的特性。下面使用数组构造一棵笛卡尔树。
二叉树的性质
2401_83624776的博客
10-18 1170
二叉树的基本概念与性质（适合复习用）
Python实现非线性数据结构-字典、集合、树、图
captain
10-22 256
存储键值对，内部使用哈希表实现。时间复杂度是 O(1)， 创建、新增、查询、删除键值对，访问值、修改值。：无序的、不包含重复元素的数据结构。支持并集、交集、差集。内部使用哈希表实现。添加、删除、检查元素是否存在。非线性数据结构：数据不遵循线性顺序，根据特定的关系或规则来组织数据。：由节点和连接这些节点的边组成。分为有向图(边有方向)和无向图。每个节点有一个值并且可以有0个或多个子节点。
数据结构预备知识---Java集合框架、List接口、包装类、装箱拆箱和泛型
最新发布
2401_83147199的博客
10-25 817
Java集合框架，List接口的介绍，装箱拆箱、包装类和泛型
数据结构：树和二叉树
qingttqing的博客
10-25 755
二叉树的基本概念；二叉树的查找采用递归函数即可进行；二叉树与树和森林转换；二叉树的应用；二叉查找树
C语言实现二叉树和堆
zzz87的博客
10-24 1137
二叉树是一种重要的数据结构，它在计算机科学中有着广泛的应用。二叉树的每个节点最多有两个子节点，这两个子节点分别称为左子节点和右子节点。这种结构使得二叉树在处理数据时具有良好的平衡性和高效性。 它在Top-k问题能以较小的成本完成选众多数据中，前k数据，如统计，全市高考分数最高的十人，通过二叉树能不完全排序下拿到结果。 排序中堆排序是一种基于二叉堆的数据结构的排序算法，它利用了二叉堆的特性来实现排序。在文件系统中，目录结构可以看作是一种特殊的二叉树，每个目录都是一个节点，文件和子目录是节点的子节点。
Javascript数据结构——哈希表
警警的博客
10-24 616
哈希表的基本思路是，设要存储的元素个数为n，设置一个长度为m（m≥n）的连续内存单元，以每个元素的关键字k为自变量，通过哈希函数把k映射为内存单元的地址（下标），并把该元素存储在这个内存单元中，如此构造的存储结构称为哈希表。简单来说，哈希表就像是一个巨大的书架，每个书架格都有一个编号（哈希值），而每个编号下都可以存放一本书（键值对）。当你想要找一本书时，只需知道它的编号，就能迅速定位到它所在的位置。
深入理解Java中的数据结构与算法分析
资源摘要信息: 该压缩包文件的标题表明，它包含了关于《数据结构与算法分析——Java语言描述》这本书的学习笔记。这是一本面向Java编程语言的数据结构和算法分析的专业书籍，适用于计算机科学与技术领域的学生和专业...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值