Java冒泡排序，插入排序，选择排序

最新推荐文章于 2022-04-14 09:40:41 发布
最新推荐文章于 2022-04-14 09:40:41 发布
阅读量213 收藏
点赞数
分类专栏： 算法

冒泡排序：

[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.zyg.test.sort;  
  2. //博客：http://blog.csdn.net/m_changgong  
  3. public class BubbleSort {  
  4.     public static void main(String[] args) {  
  5.         int[] array = {10,5,7,12};  
  6.         System.out.print("排序前；");  
  7.         printArray(array);  
  8.   
  9.         bubbleAscSort(array);  
  10.         bubbleDescSort(array);  
  11.     }  
  12.       
  13.     /** 
  14.      * 冒泡升序排序 
  15.      * @param array 
  16.      */  
  17.     public static void bubbleAscSort(int[] array){  
  18.         int length = array.length;  
  19.         int temp=0;  
  20.         for(int i=0;i<length-1;i++){  
  21.             for(int j=0;j<length-i-1;j++){  
  22.                 if(array[j+1]<array[j]){  
  23.                     temp = array[j];  
  24.                     array[j] = array[j+1];  
  25.                     array[j+1] = temp;  
  26.                 }  
  27.             }  
  28.         }  
  29.           
  30.         System.out.println();  
  31.         System.out.print("升序排序后；");  
  32.         printArray(array);  
  33.     }  
  34.       
  35.     /** 
  36.      * 冒泡降序排序 
  37.      * @param array 
  38.      */  
  39.     public static void bubbleDescSort(int[] array){  
  40.         int length = array.length;  
  41.         int temp=0;  
  42.         for(int i=0;i<length-1;i++){  
  43.             for(int j=0;j<length-i-1;j++){  
  44.                 if(array[j+1]>array[j]){  
  45.                     temp = array[j];  
  46.                     array[j] = array[j+1];  
  47.                     array[j+1] = temp;  
  48.                 }  
  49.             }  
  50.         }  
  51.           
  52.         System.out.println();  
  53.         System.out.print("降序排序后；");  
  54.         printArray(array);  
  55.     }  
  56.       
  57.     public static void printArray(int[] array){  
  58.         int length = array.length;  
  59.         for(int i=0;i<length;i++){  
  60.             System.out.print(array[i]);  
  61.             if(i!=length-1){  
  62.                 System.out.print(",");  
  63.             }  
  64.         }  
  65.     }  
  66. }  
package com.zyg.test.sort;
//博客：http://blog.csdn.net/m_changgong
public class BubbleSort {
	public static void main(String[] args) {
		int[] array = {10,5,7,12};
		System.out.print("排序前；");
		printArray(array);

		bubbleAscSort(array);
		bubbleDescSort(array);
	}
	
	/**
	 * 冒泡升序排序
	 * @param array
	 */
	public static void bubbleAscSort(int[] array){
		int length = array.length;
		int temp=0;
		for(int i=0;i<length-1;i++){
			for(int j=0;j<length-i-1;j++){
				if(array[j+1]<array[j]){
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		
		System.out.println();
		System.out.print("升序排序后；");
		printArray(array);
	}
	
	/**
	 * 冒泡降序排序
	 * @param array
	 */
	public static void bubbleDescSort(int[] array){
		int length = array.length;
		int temp=0;
		for(int i=0;i<length-1;i++){
			for(int j=0;j<length-i-1;j++){
				if(array[j+1]>array[j]){
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		
		System.out.println();
		System.out.print("降序排序后；");
		printArray(array);
	}
	
	public static void printArray(int[] array){
		int length = array.length;
		for(int i=0;i<length;i++){
			System.out.print(array[i]);
			if(i!=length-1){
				System.out.print(",");
			}
		}
	}
}


插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间

[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.zyg.test.sort;  
  2.   
  3. public class InsertSort {  
  4.     public static void main(String[] args) {  
  5.         int[] array = {2,3,1,8,6};  
  6.         System.out.print("排序前；");  
  7.         printArray(array);  
  8.   
  9.         insertAscSort(array);  
  10.         insertDescSort(array);  
  11.     }  
  12.       
  13.     /** 
  14.      * 插入升序排序 
  15.      * @param array 
  16.      */  
  17.     public static void insertAscSort(int[] array){  
  18.         int length = array.length;  
  19.         for(int out = 1;out<length;out++){  
  20.             int temp = array[out];  
  21.             int in = out;  
  22.             while(in>0 && array[in-1]>temp){  
  23.                 array[in] = array[in-1];  
  24.                 --in;  
  25.             }  
  26.             array[in]=temp;  
  27.         }  
  28.           
  29.         System.out.println();  
  30.         System.out.print("升序排序后；");  
  31.         printArray(array);  
  32.     }  
  33.       
  34.     /** 
  35.      * 插入降序排序 
  36.      * @param array 
  37.      */  
  38.     public static void insertDescSort(int[] array){  
  39.         int length = array.length;  
  40.         for(int out = 1;out<length;out++){  
  41.             int temp = array[out];  
  42.             int in = out;  
  43.             while(in>0 && array[in-1]<temp){  
  44.                 array[in] = array[in-1];  
  45.                 --in;  
  46.             }  
  47.             array[in]=temp;  
  48.         }  
  49.           
  50.         System.out.println();  
  51.         System.out.print("升序排序后；");  
  52.         printArray(array);  
  53.     }  
  54.       
  55.     public static void printArray(int[] array){  
  56.         int length = array.length;  
  57.         for(int i=0;i<length;i++){  
  58.             System.out.print(array[i]);  
  59.             if(i!=length-1){  
  60.                 System.out.print(",");  
  61.             }  
  62.         }  
  63.     }  
  64. }  
package com.zyg.test.sort;

public class InsertSort {
	public static void main(String[] args) {
		int[] array = {2,3,1,8,6};
		System.out.print("排序前；");
		printArray(array);

		insertAscSort(array);
		insertDescSort(array);
	}
	
	/**
	 * 插入升序排序
	 * @param array
	 */
	public static void insertAscSort(int[] array){
		int length = array.length;
		for(int out = 1;out<length;out++){
			int temp = array[out];
			int in = out;
			while(in>0 && array[in-1]>temp){
				array[in] = array[in-1];
				--in;
			}
			array[in]=temp;
		}
		
		System.out.println();
		System.out.print("升序排序后；");
		printArray(array);
	}
	
	/**
	 * 插入降序排序
	 * @param array
	 */
	public static void insertDescSort(int[] array){
		int length = array.length;
		for(int out = 1;out<length;out++){
			int temp = array[out];
			int in = out;
			while(in>0 && array[in-1]<temp){
				array[in] = array[in-1];
				--in;
			}
			array[in]=temp;
		}
		
		System.out.println();
		System.out.print("升序排序后；");
		printArray(array);
	}
	
	public static void printArray(int[] array){
		int length = array.length;
		for(int i=0;i<length;i++){
			System.out.print(array[i]);
			if(i!=length-1){
				System.out.print(",");
			}
		}
	}
}

选择排序 (Selection sort)是一种简单直观的 排序算法 。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

[java] view plain copy
print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.zyg.test.sort;  
  2.   
  3. public class SelectSort {  
  4.     public static void main(String[] args) {  
  5.         int[] array = {23,10,7,12,5,1};  
  6.         System.out.print("排序前；");  
  7.         printArray(array);  
  8.   
  9.         selectAscSort(array);  
  10.         selectDescSort(array);  
  11.     }  
  12.       
  13.     /** 
  14.      * 选择升序排序 
  15.      * @param array 
  16.      */  
  17.     public static void selectAscSort(int[] array){  
  18.         int length = array.length;  
  19.         int min = array[0];  
  20.         int minIdx = 0;  
  21.         for(int i=0;i<length-1;i++){  
  22.             for(int j=i+1;j<length;j++){  
  23.                 if(array[j]<min){//将比较符号改为>即是降序排序算法  
  24.                     min = array[j];  
  25.                     minIdx = j;  
  26.                 }  
  27.             }  
  28.             array[minIdx]= array[i];  
  29.             array[i] = min;  
  30.             //重置min、minIdx值  
  31.             min = array[i+1];  
  32.             minIdx = i+1;  
  33.         }  
  34.           
  35.         System.out.println();  
  36.         System.out.print("升序排序后；");  
  37.         printArray(array);  
  38.     }  
  39.       
  40.     /** 
  41.      * 选择降序排序 
  42.      * @param array 
  43.      */  
  44.     public static void selectDescSort(int[] array){  
  45.         int length = array.length;  
  46.         int max = array[0];  
  47.         int maxIdx = 0;  
  48.         for(int i=0;i<length-1;i++){  
  49.             for(int j=i;j<length;j++){  
  50.                 if(array[j]>max){//将比较符号改为<即是升序排序算法  
  51.                     max = array[j];  
  52.                     maxIdx = j;  
  53.                 }  
  54.             }  
  55.             array[maxIdx]= array[i];  
  56.             array[i] = max;  
  57.             //重置max、maxIdx值  
  58.             max = array[i+1];  
  59.             maxIdx = i+1;  
  60.         }  
  61.           
  62.         System.out.println();  
  63.         System.out.print("降序排序后；");  
  64.         printArray(array);  
  65.     }  
  66.       
  67.     public static void printArray(int[] array){  
  68.         int length = array.length;  
  69.         for(int i=0;i<length;i++){  
  70.             System.out.print(array[i]);  
  71.             if(i!=length-1){  
  72.                 System.out.print(",");  
  73.             }  
  74.         }  
  75.     }  
  76. }  
package com.zyg.test.sort;

public class SelectSort {
	public static void main(String[] args) {
		int[] array = {23,10,7,12,5,1};
		System.out.print("排序前；");
		printArray(array);

		selectAscSort(array);
		selectDescSort(array);
	}
	
	/**
	 * 选择升序排序
	 * @param array
	 */
	public static void selectAscSort(int[] array){
		int length = array.length;
		int min = array[0];
		int minIdx = 0;
		for(int i=0;i<length-1;i++){
			for(int j=i+1;j<length;j++){
				if(array[j]<min){//将比较符号改为>即是降序排序算法
					min = array[j];
					minIdx = j;
				}
			}
			array[minIdx]= array[i];
			array[i] = min;
			//重置min、minIdx值
			min = array[i+1];
			minIdx = i+1;
		}
		
		System.out.println();
		System.out.print("升序排序后；");
		printArray(array);
	}
	
	/**
	 * 选择降序排序
	 * @param array
	 */
	public static void selectDescSort(int[] array){
		int length = array.length;
		int max = array[0];
		int maxIdx = 0;
		for(int i=0;i<length-1;i++){
			for(int j=i;j<length;j++){
				if(array[j]>max){//将比较符号改为<即是升序排序算法
					max = array[j];
					maxIdx = j;
				}
			}
			array[maxIdx]= array[i];
			array[i] = max;
			//重置max、maxIdx值
			max = array[i+1];
			maxIdx = i+1;
		}
		
		System.out.println();
		System.out.print("降序排序后；");
		printArray(array);
	}
	
	public static void printArray(int[] array){
		int length = array.length;
		for(int i=0;i<length;i++){
			System.out.print(array[i]);
			if(i!=length-1){
				System.out.print(",");
			}
		}
	}
}


LiTianao88
关注
专栏目录
Java实现冒泡排序、选择排序、插入排序
Mr.Qin
04-27 506
冒泡排序：是一种简单的排序算法，需要重复的访问要排序的元素序列，不断地比较相邻的元素。如果相邻的元素满足了比较的条件，如前一个数据大于（或小于）后一个数据，则交换元素的顺序，使较大（或较小）的数据向后移。同样，再使这个较大（或较小）的数据与下一个相邻的元素比较。依此类推，比较到序列的末尾，得到一个最大（最小）的值。前面剩下的元素，重复之前的操作比较。直到得到一个排好序的序列。稳定排序算法，平均算法...
Java常见排序算法之冒泡排序、选择排序、插入排序、快速排序
c1441173216的博客
11-08 1101
Java实现常见的排序算法 冒泡 选择 插入 快速排序。代码清晰易懂
java实现冒泡排序，选择排序，插入排序，快速排序（简洁版）及性能测试
844604778
09-17 297
1、冒泡排序是排序里面最简单的了，但性能也最差，数量小的时候还可以，数量一多，是非常慢的。 它的时间复杂度是O（n*n），空间复杂度是O（1） 代码如下，很好理解。 public void bubbleSort(int[] arr){ for(int i=0;i&lt;arr.length-1;i++){ for(int j=arr.length-1;j&gt;i;j--){ ...
Java中的简单排序：冒泡排序，选择排序，插入排序
zhbitxhd的专栏
08-26 947
简单排序中包括了：冒泡排序、选择排序、插入排序； 原理与思想：   1.冒泡排序的思想：   假设有N个数据需要排序，则从第0个数开始，依次比较第0和第1个数据，如果第0个大于第1个则两者交换，否则什么动作都不做，继续比较第1个第2个…，这样依次类推，直至所有数据都“冒泡”到数据顶上。   冒泡排序的的java代码：   Public void bubbleSort()
冒泡排序，插入排序，选择排序(java)
奔跑的小白
09-23 151
package ch02; public class BubbleSort { public static void sort(long[] arr) { long temp = 0; for(int i = 0; i &lt; arr.length - 1; i ++) { for (int j = arr.length - 1; j &gt; 0; j --) { ...
冒泡排序 快速排序 插入排序 选择排序——java语言简单实现
君当自强
08-13 379
目录 1.冒泡排序： 2.快速排序： 3.插入排序： 4.选择排序： 1.冒泡排序： 冒泡排序重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如...
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
它是基于插入排序的，但通过将待排序的元素按照一定的间隔分组，对每组进行插入排序，随着间隔逐渐减小，最终达到整个序列有序的目的。希尔排序的时间复杂度介于O(n^2)和O(nlogn)之间，具体取决于所使用的间隔序列。...
java选择排序等排序算法资源：java排序算法源代码（包括冒泡排序，选择排序，插入排序）
05-29
本资源包含了几种基本的排序算法，如冒泡排序、选择排序和插入排序，这些都是理解和学习算法的基础。 **冒泡排序**是最基础的排序算法之一，它通过重复遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把...
选择排序 冒泡排序 插入排序 快速排序 堆排序.zip
12-18
本资源包"选择排序 冒泡排序 插入排序 快速排序 堆排序.zip"聚焦于五种经典的排序算法，包括选择排序、冒泡排序、插入排序、快速排序以及堆排序。这些算法的实现语言是Objective-C，这是一种强大的面向对象的编程...
java冒泡排序和插入排序
m0_56987404的博客
04-14 807
Java排序
java基本算法总结（冒泡排序、选择排序、插入排序）
技术人宝哥
03-17 1592
package com.java.dataStructArithmeic.sort; /**  * @author gongpeibao  * @since 2012.03.16  * 基本排序方法  * 选择排序放比冒泡排序效率高，原因是它的交换次数少了,比较次数都是N*(N-1)/2  * 插入排序法是这儿最好的一种基本排序方法，虽然排序算法仍然需要O(N^2)的时间，  *
Java数据结构和算法总结-冒泡排序、选择排序、插入排序算法分析
anxiushang5448的博客
10-05 130
　　前言：排序在算法中的地位自然不必多说，在许多工作中都用到了排序，就像学生成绩统计名次、商城商品销量排名、新闻的搜索热度排名等等。也正因为排序的应用范围如此之广，引起了许多人深入研究它的兴趣，直至今天，排序算法已经出现了很多种。本篇博文主要介绍常见的八种排序算法，总得来说，不同的排序算法在不同的场景下都有着自己独特的优点，例如一下简单的冒泡排序、选择排序、插入排序不仅思路简单，有利于我...
几种基本的排序算法：选择排序、插入排序、冒泡排序
party
10-13 309
选择排序（Selection sort）、插入排序（Insertion sort）与冒泡排序（Bubble sort）這三个排序方式是初学排序所必须知道的三个基本排序方式，它们由于速度不快而不实用（时间复杂度都是O(n2)），然而它们排序的方式确实值得我们观察和探讨。 一、选择排序 原理：将初始序列(A[0]~A[n-1])作为待排序序列，第一趟在待排序序列(A[0]~A[n-1])中找到最小...
三种基础排序算法(选择排序、插入排序、冒泡排序)
热门推荐
weixin_38830382的博客
01-26 3万+
注：  图片转自点击打开链接  以下均使用升序介绍。 选择排序： 从数组中找到最小的元素，和第一个位置的元素互换。   从第二个位置开始，找到最小的元素，和第二个位置的元素互换。  ........  直到选出array.length-1个较小元素，剩下的最大的元素自动排在最后一位。 代码实现：
三种常见的排序算法（冒泡排序，选择排序，插入排序）
Casey
12-16 531
冒泡排序： 按照冒泡排序的思想，我们要把相邻的元素两两比较，根据大小来交换元素的位置，过程如下： def Bubble_sort(list): for i in range(len(list)-1): # 外循环控制循环的次数 for j in range(len(list) - i-1): # 内循环控制遍历到哪一位 ...
面试时常常考察的java排序算法--选择排序、冒泡排序、插入排序
前方一片光明
02-09 7204
注：本文是从java语言角度对三种排序算法进行分析比较。 一、选择排序 核心思想： 依次拿当前元素和其后面的元素比较大小，满足条件就互换值 public static int[] shunxu(int[] arr){ int len = arr.length; int temp = 0; for (int i = 0; i < len-1; i++) { for (i...
VB程序实例-图像的打印.zip
11-03
VB程序实例-图像的打印.zip
VB程序实例-字形窗口.zip
最新发布
11-03
VB程序实例-字形窗口.zip
VB程序实例36_动态控制_增减控件.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
java冒泡排序 插入排序 选择排序
06-21
冒泡排序是一种简单的排序算法，它的基本思想是重复遍历待排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历次数会逐渐减少，直到没有再需要交换的元素，排序完成。在Java中，你可以用嵌套...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值