数据结构

最新推荐文章于 2025-03-08 09:33:28 发布
最新推荐文章于 2025-03-08 09:33:28 发布
阅读量64 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 技术 排序分析 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xuyoujia1991/article/details/84652085
本文深入探讨了四种经典的排序算法：插入排序、希尔排序、选择排序与冒泡排序。从基本思想出发，详细解释了每一算法的工作原理，并通过Java代码实例展示了其实现过程。同时，对比了这些算法的特点，帮助读者理解在不同场景下如何选择合适的排序策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.插入排序

 

基本思想:

 

将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

 

要点：设立哨兵，作为临时存储和判断数组边界之用。

 

直接插入排序示例：

 

 

如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

算法的实现：

 

Java代码 复制代码  收藏代码
  1. public class ArraySort {   
  2.   
  3.     public static void main(String[] args) {   
  4.         ArraySort sort = new ArraySort();   
  5.   
  6.       // 插入排序排序后的数组   
  7.         int[] charu = sort.SortChaRu(arraysort);   
  8.         for (int n = 0; n < charu.length; n++) {   
  9.             //System.out.println(charu[n]);   
  10.         }   
  11.   
  12.   
  13. /**  
  14.      * 插入排序的方法  
  15.      *   
  16.      * @param ChaRuSort  
  17.      *            传入的原始数据  
  18.      * @return 返回排序后的数组  
  19.      */  
  20.     public int[] SortChaRu(int[] ChaRuSort) {   
  21.         for (int i = 0; i < ChaRuSort.length; i++) {   
  22.             for (int j = i; j > 0; j--) {   
  23.                 if (ChaRuSort[j] < ChaRuSort[j - 1]) {   
  24.                     int temp = ChaRuSort[j];   
  25.                     ChaRuSort[j] = ChaRuSort[j - 1];   
  26.                     ChaRuSort[j - 1] = temp;   
  27.                 }   
  28.             }   
  29.         }   
  30.   
  31.         return ChaRuSort;   
  32.   
  33.     }  
public class ArraySort {

	public static void main(String[] args) {
		ArraySort sort = new ArraySort();

      // 插入排序排序后的数组
		int[] charu = sort.SortChaRu(arraysort);
		for (int n = 0; n < charu.length; n++) {
			//System.out.println(charu[n]);
		}


/**
	 * 插入排序的方法
	 * 
	 * @param ChaRuSort
	 *            传入的原始数据
	 * @return 返回排序后的数组
	 */
	public int[] SortChaRu(int[] ChaRuSort) {
		for (int i = 0; i < ChaRuSort.length; i++) {
			for (int j = i; j > 0; j--) {
				if (ChaRuSort[j] < ChaRuSort[j - 1]) {
					int temp = ChaRuSort[j];
					ChaRuSort[j] = ChaRuSort[j - 1];
					ChaRuSort[j - 1] = temp;
				}
			}
		}

		return ChaRuSort;

	}

 

运算结果:

Java代码 复制代码  收藏代码
  1. 原始数据11  
  2. 原始数据22  
  3. 原始数据332  
  4. 原始数据223  
  5. 原始数据20  
  6. 原始数据234  
  7. 11  
  8. 20  
  9. 22  
  10. 223  
  11. 234  
  12. 332   
原始数据11
原始数据22
原始数据332
原始数据223
原始数据20
原始数据234
11
20
22
223
234
332

 

 

 

 

 

 2. 插入排序—希尔排序

 

希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序

基本思想：

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

操作方法：

  1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  2. 按增量序列个数k，对序列进行k 趟排序；
  3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

希尔排序的示例：

 

算法实现：

 

我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

 

算法的实现：

Java代码 复制代码  收藏代码
  1. public class ArraySort {   
  2.   
  3.     public static void main(String[] args) {   
  4.         ArraySort sort = new ArraySort();   
  5.   
  6.         // 排序的原始数组   
  7.         int[] arraysort = { 11, 22, 332, 223, 20, 234 };   
  8.         // 遍历出原始数据   
  9.         for (int i = 0; i < arraysort.length; i++) {   
  10.             System.out.println("原始数据" + arraysort[i]);   
  11.         }   
  12.        
  13.         //希尔排序   
  14.         int[] xier = sort.SortXiEr(arraysort);   
  15.         for(int x = 0;x<xier.length;x++){   
  16.             //System.out.println(xier[x]);   
  17.         }   
  18.   
  19.     }   
  20.   
  21. /**  
  22.      * 希尔排序的方法  
  23.      *   
  24.      * @param XiErSort  
  25.      *            数组的原始数据  
  26.      * @return 返回排序后的数据  
  27.      */  
  28.     public int[] SortXiEr(int[] XiErSort) {   
  29.         // 分组   
  30.         for (int increment = XiErSort.length / 2; increment > 0; increment /= 2) {   
  31.             //每组内部排序   
  32.             for (int i = increment; i < XiErSort.length; i++) {   
  33.                 int temp = XiErSort[i];   
  34.                 int j = 0;   
  35.                 for (j = i; j >= increment; j -= increment) {   
  36.                     if (temp < XiErSort[j - increment]) {   
  37.                         XiErSort[j] = XiErSort[j - increment];   
  38.                     } else {   
  39.                         break;   
  40.                     }   
  41.                 }   
  42.                 XiErSort[j] = temp;   
  43.             }   
  44.         }   
  45.         return XiErSort;   
  46.   
  47.     }   
  48.   
  49. }  
public class ArraySort {

	public static void main(String[] args) {
		ArraySort sort = new ArraySort();

		// 排序的原始数组
		int[] arraysort = { 11, 22, 332, 223, 20, 234 };
		// 遍历出原始数据
		for (int i = 0; i < arraysort.length; i++) {
			System.out.println("原始数据" + arraysort[i]);
		}
	
		//希尔排序
		int[] xier = sort.SortXiEr(arraysort);
		for(int x = 0;x<xier.length;x++){
			//System.out.println(xier[x]);
		}

	}

/**
	 * 希尔排序的方法
	 * 
	 * @param XiErSort
	 *            数组的原始数据
	 * @return 返回排序后的数据
	 */
	public int[] SortXiEr(int[] XiErSort) {
		// 分组
		for (int increment = XiErSort.length / 2; increment > 0; increment /= 2) {
			//每组内部排序
			for (int i = increment; i < XiErSort.length; i++) {
				int temp = XiErSort[i];
				int j = 0;
				for (j = i; j >= increment; j -= increment) {
					if (temp < XiErSort[j - increment]) {
						XiErSort[j] = XiErSort[j - increment];
					} else {
						break;
					}
				}
				XiErSort[j] = temp;
			}
		}
		return XiErSort;

	}

}

 

 

 

 

 

3. 选择排序

基本思想：

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

简单选择排序的示例：

 

操作方法：

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

算法实现：

Java代码 复制代码  收藏代码
  1. public class ArraySort {   
  2.   
  3.     public static void main(String[] args) {   
  4.         ArraySort sort = new ArraySort();   
  5.   
  6.         // 排序的原始数组   
  7.         int[] arraysort = { 11, 22, 332, 223, 20, 234 };   
  8.         // 遍历出原始数据   
  9.         for (int i = 0; i < arraysort.length; i++) {   
  10.             System.out.println("原始数据" + arraysort[i]);   
  11.         }   
  12. // 选择排序排序后的数组   
  13.         int[] xuanze = sort.SortXuanZe(arraysort);   
  14.         for (int j = 0; j < xuanze.length; j++) {   
  15.             // System.out.println(xuanze[j]);   
  16.         }   
  17.       }   
  18.   
  19. /**  
  20.      * 选择排序排序数组  
  21.      *   
  22.      * @param XuanZesort  
  23.      *            传入的数组  
  24.      * @return 返回排序后的数组  
  25.      *   
  26.      *         思路:在遍历数组时先把第一个当作最小的,然后与后面的比较  
  27.      */  
  28.     public int[] SortXuanZe(int[] XuanZesort) {   
  29.   
  30.         for (int i = 0; i < XuanZesort.length; i++) {   
  31.             // 假设i是最小的数   
  32.             int lowerIndex = i;   
  33.   
  34.             for (int j = i + 1; j < XuanZesort.length; j++) {   
  35.                 if (XuanZesort[j] < XuanZesort[lowerIndex]) {   
  36.                     // 此时j是最小的   
  37.                     lowerIndex = j;   
  38.                 }   
  39.             }   
  40.             // 交换   
  41.             int temp = XuanZesort[i];   
  42.             XuanZesort[i] = XuanZesort[lowerIndex];   
  43.             XuanZesort[lowerIndex] = temp;   
  44.         }   
  45.         // 将数组返回   
  46.         return XuanZesort;   
  47.   
  48.     }  
public class ArraySort {

	public static void main(String[] args) {
		ArraySort sort = new ArraySort();

		// 排序的原始数组
		int[] arraysort = { 11, 22, 332, 223, 20, 234 };
		// 遍历出原始数据
		for (int i = 0; i < arraysort.length; i++) {
			System.out.println("原始数据" + arraysort[i]);
		}
// 选择排序排序后的数组
		int[] xuanze = sort.SortXuanZe(arraysort);
		for (int j = 0; j < xuanze.length; j++) {
			// System.out.println(xuanze[j]);
		}
      }

/**
	 * 选择排序排序数组
	 * 
	 * @param XuanZesort
	 *            传入的数组
	 * @return 返回排序后的数组
	 * 
	 *         思路:在遍历数组时先把第一个当作最小的,然后与后面的比较
	 */
	public int[] SortXuanZe(int[] XuanZesort) {

		for (int i = 0; i < XuanZesort.length; i++) {
			// 假设i是最小的数
			int lowerIndex = i;

			for (int j = i + 1; j < XuanZesort.length; j++) {
				if (XuanZesort[j] < XuanZesort[lowerIndex]) {
					// 此时j是最小的
					lowerIndex = j;
				}
			}
			// 交换
			int temp = XuanZesort[i];
			XuanZesort[i] = XuanZesort[lowerIndex];
			XuanZesort[lowerIndex] = temp;
		}
		// 将数组返回
		return XuanZesort;

	}

 

 

 

 

4. 交换排序—冒泡排序（Bubble Sort）

冒泡排序;http://baihe747.iteye.com/blog/2067294

基本思想：

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

冒泡排序的示例：

 

算法的实现：

Java代码 复制代码  收藏代码
  1. public class ArraySort {   
  2.   
  3.     public static void main(String[] args) {   
  4.         ArraySort sort = new ArraySort();   
  5.   
  6.         // 排序的原始数组   
  7.         int[] arraysort = { 11, 22, 332, 223, 20, 234 };   
  8.         // 遍历出原始数据   
  9.         for (int i = 0; i < arraysort.length; i++) {   
  10.             System.out.println("原始数据" + arraysort[i]);   
  11.         }   
  12.   
  13.         // 冒泡排序后的数   
  14.         int[] maopao = sort.SortMaoPao(arraysort);   
  15.         for (int i = 0; i < maopao.length; i++) {   
  16.             // System.out.println(maopao[i]);   
  17.         }   
  18. }   
  19.   
  20. /**  
  21.      * 冒泡排序的方法  
  22.      *   
  23.      * @param arraysort传入的原始数组  
  24.      * @return返回排序好了的数组  
  25.      *   
  26.      *                  思路:将第一个与后面的比较  
  27.      */  
  28.     public int[] SortMaoPao(int[] MaoPaosort) {   
  29.         for (int i = 0; i < MaoPaosort.length; i++) {   
  30.             for (int j = i + 1; j < MaoPaosort.length; j++) {   
  31.                 // 判断两个数的大小   
  32.                 if (MaoPaosort[i] > MaoPaosort[j]) {   
  33.                     int temp = MaoPaosort[i];   
  34.                     MaoPaosort[i] = MaoPaosort[j];   
  35.                     MaoPaosort[j] = temp;   
  36.                 }   
  37.             }   
  38.         }   
  39.   
  40.         return MaoPaosort;   
  41.     }  
public class ArraySort {

	public static void main(String[] args) {
		ArraySort sort = new ArraySort();

		// 排序的原始数组
		int[] arraysort = { 11, 22, 332, 223, 20, 234 };
		// 遍历出原始数据
		for (int i = 0; i < arraysort.length; i++) {
			System.out.println("原始数据" + arraysort[i]);
		}

		// 冒泡排序后的数
		int[] maopao = sort.SortMaoPao(arraysort);
		for (int i = 0; i < maopao.length; i++) {
			// System.out.println(maopao[i]);
		}
}

/**
	 * 冒泡排序的方法
	 * 
	 * @param arraysort传入的原始数组
	 * @return返回排序好了的数组
	 * 
	 *                  思路:将第一个与后面的比较
	 */
	public int[] SortMaoPao(int[] MaoPaosort) {
		for (int i = 0; i < MaoPaosort.length; i++) {
			for (int j = i + 1; j < MaoPaosort.length; j++) {
				// 判断两个数的大小
				if (MaoPaosort[i] > MaoPaosort[j]) {
					int temp = MaoPaosort[i];
					MaoPaosort[i] = MaoPaosort[j];
					MaoPaosort[j] = temp;
				}
			}
		}

		return MaoPaosort;
	}

 

数据结构之链表
gangaue的博客
04-01 5608
文章目录1.1链表的概念及结构1.2逻辑结构和物理结构1.3单链表的优势1.4单链表的实现1.5完整代码 1.1链表的概念及结构 概念： 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 实际中要实现的链表的结构非常多样，以下情况组合起来就有8种链表结构： 1、单向、双向 2、带头、不带头 3、循环、非循环 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试
苏大872计算机-苏州大学《数据结构》20卷试真题库+答案.rar
05-25
苏州大学《数据结构》20卷试真题库是一本涵盖数据结构基础知识、经典算法、应用实践等方面的试题集合，适用于计算机科学、计算机工程、软件工程等专业的学生以及从事计算机算法开发的程序员。本书以数据结构和算法为...
redis数据结构
Drftyytf的博客
02-03 4233
redis的数据结构：String(字符串)、List(列表)、hash(哈希)、Set(集合)、Shorted Set(有序集合) 底层数据结构：简单动态字符串、双向链表、压缩列表、哈希表、跳表、整数数组 1.哈希表：一个哈希表其实就是一个数组，数组中的每一个元素称为一个哈希桶。 哈希冲突和rehash可能会带来操作阻塞。 redis解决哈希冲突的方法是链式哈希，而rehash是增加现有hash桶的数量。 rehash的操作步骤：1.给哈希表分配更大的空间，例如是当前hash表大小的两倍 2.把哈希表
《数据结构》C语言版（清华严蔚敏考研版） 全书知识梳理 + 练习习题详解（超详细清晰易懂）
热门推荐
繁凡さん的博客
04-15 22万+
《数据结构》知识梳理，适合考前复习，高分冲刺。包含大量习题，偷偷告诉你，考试就考这个
常见的数据结构，附带图解
weixin_58016347的博客
04-19 1341
理解常见的数据结构
数据结构820
残影的博客
09-01 1848
数据结构820第一部分 数据结构及算法的相关概念和术语1. 数据结构及算法的概念 第一部分 数据结构及算法的相关概念和术语 1. 数据结构及算法的概念 数据（data）： 数据是对客观事物的符号表示，是信息的载体。 在计算机科学中数据指所有能够被计算机识别的符号集合。 识别： 输入、存储、处理、显示、输出。 符号： 数字、字母、汉字、语音、图形、图像。 数据元素（Data Element）: 是数据（集合）中的一个“个体”，是数据结构中讨论的基本单位 。 数据项（Data Item）： 是数据结构中讨论
最流行的6种自定义数据结构全面分析与设计技巧
最新发布
百锦再的博客
03-08 3669
哈希映射是一种基于哈希函数的数据结构，提供高效的键值存储。
初识数据结构
一个正在学习C/C++的博主
11-26 1508
数据结构
常见的数据结构
weixin_42740360的博客
04-30 4567
目录 1.数组（Arrays） 2.链表 3.栈 4.队列 5.Map和哈希表 6.树 7.堆 1.数组（Arrays） 数组是最简单也是最常见的数据结构，他们的特点是可以通过索引（位置）轻松访问元素 它们是做什么用的？ 想象一下有一排剧院椅。每把椅子都分配了 一个位置，因此每个观众都会从他将要坐的椅子上分配一个号码（索引）。这是一个数组。将问题扩展到整个剧院（椅子的行和列），您将拥有一个二维数组（矩阵） 特性 元素的值按照顺序存储，并通过从0到数组长度的...
数据结构线性表基本操作
lizhi20210729的博客
11-20 1万+
数据结构线性表基本操作基本内容线性表的顺序表示和实现线性表的顺序存储表示顺序表中基本操作的实现 基本内容 因为第一次数据结构阶段考写代码又想规范写又写不出规范的可读性强的代码，让我第一次意识到自己应该在这方面下一些功夫。这篇文章是记录自己把书上写的算法打到电脑上遇到的问题。 线性表的顺序表示和实现 线性表的顺序存储表示 将书中代码复刻如下： #define MAXSIZE 100//顺序表可能达到的最大长度 typedef struct { ElemType *elem;//储存空间的基地址
C#数据结构
weixin_45344894的博客
12-15 1858
一、常见的数据结构 1.静态数组 int[] num=new int[size] 静态数组的内存是被指定大小的 2.动态数组 Array List <> 可以存任意类型的数据，相当于把所有数据 装箱为了object 类型，而应用数据时，则需要进行拆箱，将object类型转化为原来需要得类型，并且在索引查询上比较麻烦，占用内存过多，影响了效率 List<type> 泛型 对需要存储得类型进行指定，存贮数据时通过索引可以得到快速查询 3.链表 利用委托，相...
李云清数据结构第三版C语言版课后答案
01-28
数据结构是计算机科学中的核心概念，它涉及到如何组织和管理数据以便高效地访问和操作。李云清的《数据结构》第三版C语言版是一部详细讲解这一主题的教材，其课后习题提供了深入理解数据结构的机会。 1. 数据结构是...
数据结构python数据结构练习题目与源代码
06-05
【数据结构】基于python语言的数据结构练习题目与源代码 资源内容： 第一部分--python语言必备知识 1. 数据结构与算法概述 3. python数据结构 4. python三大结构 5. 函数 第二部分--线性数据结构 1. 线性表 第三...
长春工业大学2022硕士研究生试题-数据结构.docx
01-04
"长春工业大学2022硕士研究生试题-数据结构" 本试题涵盖了数据结构的多个方面，包括数据结构的概念、逻辑结构、存储结构、线性表、链表、栈、队列、树、串等。以下是对试题中出现的知识点的详细解释： 一、选择题 ...
数据结构与算法分析C++语言描述第四版参考答案
10-13
《数据结构与算法分析C++语言描述第四版》是一本深度探讨数据结构和算法的经典教材。这本书由Mark Allen Weiss撰写，旨在帮助读者理解和掌握如何在C++编程环境中有效地设计和实现数据结构及算法。第四版更新了内容，...
org.springframework.jdbc.CannotGetJdbcConnectionException:
xuyoujia1991的博客
12-15 2362
Exception in thread "main" org.springframework.jdbc.CannotGetJdbcConnectionException: Failed to obtain JDBC Connection; nested exception is com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure The last packet sent successfully
小程序开发笔记-block，wx:for等知识
xuyoujia1991的博客
11-04 878
小程序笔记 今天完成小程序的商户信息列表和详情页面的开发。涉及到的空间有{{items.value1}}{{item.value2}}…… wx:for中是js中data传过来的参数，这个参数就是一个数组[1,2,3,4,5],而item就是其中的1，2，3，4…… 涉及到的方法 wx.request请求方法：参数有url,header,success,fail setTimeout(()=>{ })：进行延时方法 onPulldownRefresh方法:当用户进行下拉操作的时候触发
2021-11-08-ajax跨域问题笔记
xuyoujia1991的博客
11-11 826
ajax跨域问题 通过ajax访问“http://www.kuaidi100.com/query”，浏览器报错： Access to XMLHttpRequest at ‘http://www.kuaidi100.com/query?type=zhongtong&postid=78237558620256’ from origin ‘null’ has been blocked by CORS policy: Response to preflight request doesn’t pass a
web项目的修改步骤及idea调试
xuyoujia1991的博客
01-22 662
如何将普通application项目改成web项目 1.pom文件中添加：war 2.pom文件中新增tomcat插件 3.在main路径下创建src/main/webapp/WEB-INF/web.xml，web.xml是servlet的描述服务 maven打包操作 进入项目的路径：D:\ideaProjects\geetbanglesson\think-in-spring\bean-scope mvn --version mvn clean package ----提示以下异常-----------
数据结构习题解答指南
根据提供的文件信息，我们可以得知所讨论的主题是关于数据结构及其课后习题的答案。数据结构是计算机科学中用于存储、组织数据的一种方式，其目的是为了更高效地对数据进行处理和检索。以下我们将详细解析数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值