java听课笔记3(排序算法：冒泡，选择，直接插入)

最新推荐文章于 2022-02-06 23:38:19 发布

钢铁闪电

最新推荐文章于 2022-02-06 23:38:19 发布

阅读量178

点赞数 1

本文链接：https://blog.csdn.net/weixin_35069481/article/details/90142258

版权

写在前面的话，如果i=0,那么循环次数为i<nums.length，如果i=1,那么循环次数为i<=nums.length 在这里插入图片描述
在排序过程中，所有需要排序的数据都一次性加载到内存中，并在内存中调整他们的顺序，称为内排序；如果数据较大，只有部分被调入到内存，并借助内存调整在内存外中存放顺序，称为外排序；

1.直接插入排序

( 从后向前找到合适的位置插入 )
基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置( 从后向前找到合适位置后 )，直到全部插入排序完为止。
第一轮，在for循环中，先把[1]放在temp中，比较[0]和[1]，若[0]大于[1]，然后[0]值覆盖[1]值在这里插入图片描述
此时，将temp和[1]值比较，定顺序
第二轮，将[2]存在temp中，[1]的值后移覆盖[2]，此时[1]和[2]值相同，拿temp和[1]比较，定顺序
第三轮，将[3]存在temp中，再将[2]值向后覆盖到[3]上，令[2]和temp比较，发现[2]比temp大，[3]顺序不变，于是令[1]值覆盖到[2]上，用temp值(17)和[1]比较定顺序。在这里插入图片描述
第四轮 将[4]存于temp中，[3]覆盖到[4]上，比较temp和[3]，定顺序
第五轮，将[5]存于temp中，[34覆盖到[5]上，比较temp和[4]，定顺序，发现[5]小于[4]，再看是否[4]小于[3]，发现大于[3]，不用向前重复，定顺序在这里插入图片描述

import java.util.Scanner;
public class test14{
	public static void main(String []args){
		int[] num={34,4,56,17,90,65};//待排序的数列
		//外循环控制比较轮数，轮数从1开始，比数组长度少一个数
		for(int i=1;i<num.length;i++){
			int temp=num[i];//记录操作数
			int j=0;
			// j 为 i 前面一个数 
			for(j=i-1;j>=0;j--){
				if(num[j]>temp){
					num[j+1]=num[j];
					//如果执行该if，说明之前，前大后(temp)小，结果前后相等，都等于前面(大)且不等于temp
				}else{
					break;
					//else，结果浅前小后大
				}
			}
			//注意，for循环j--过后，j+1才等于前面的数
			//看前面（i=j+1）是否等于temp(小)
			if(num[j+1]!=temp){
				num[j+1]=temp;
			}
		}
		//输出结果
		for(int n:num){
			System.out.println(n);
		}
	}
}

总结算法性质

直接排序是稳定的;
算法的时间复杂度为O(n^2);
适用于量小、接近有序的数据

2.希尔排序

（1）算法思想
将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

（2）算法性质

直接排序是不稳定的;
算法的时间复杂度为O(n^1.3);
适用于量大、接近有序的数据

（3）算法示意图
在这里插入图片描述
例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样(竖着的元素是步长组成)：

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

然后我们对每列进行排序：

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45
将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。这时10已经移至正确位置了，然后再以3为步长进行排序：

10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45
排序之后变为：

10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94
最后以1步长进行排序（此时就是简单的插入排序了）

package test;

import java.util.Arrays;

public class test2
{
	public static void main(String[] args)
	{
		int[] nums = {2,3,5,1,23,6,78,34,23,4,5,78,34,65,32,65,76,32,76,1,9};
		int[] nums2 = sort(nums);
		//将数组输出
		//for(int in: nums2){
		//	System.out.println(in);
		//}
		System.out.println(Arrays.toString(nums2));
	}
	//创建排序方法
	public static int[] sort(int[] num){
		
		int n = num.length;
		int gap = n/2;//设置租数
		while(gap > 0){
			for(int j = gap; j < n; j++){
				int i=j;
				while(i >= gap && num[i-gap] > num[i]){
					int temp = num[i-gap]+num[i];
					num[i-gap] = temp-num[i-gap];
					num[i] = temp-num[i-gap];
					i -= gap;
				}
			}
			gap = gap/2;
		}
		return num;
	}
}

12.冒泡排序方法

冒泡排序算法的运作如下：（从前往后）
比较相邻元素。如果第一个比第二个大，就交换他们两个。(升国旗排队)
对每一对相邻元素做同样的工作，从开始第一对到结尾最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复以上的步骤，直到没有任何一对数字需要比较。
相同元素的前后顺序没有改变，所以冒泡排序是一种稳定的排序算法。

Import java.util.Scanner;
Public class Test{	
	    Public stastic void main (String[] args){
			    Int [ ] nums = {2,3,44,22,11,99,45,55,66} ;//待排序的数
			    //外循环控制轮数
			    for( int i=0 ; i<nums.length-1 ; i++){
					    //比较轮数等于数列长度减一
					    for( int j=0 ; j < nums.length-1-i ; j++){
						    If(nums[j] > nums[j+1]){
							    nums [ j ]=nums [j]+nums [j+1];
							    nums [j+1]=nums[j]-nums[ j+1];
							    nums [ j ]=num [ j ]-nums[j+1];
						    }
					    }
			    }
			    //输出结果
			    for(int n: nums){
			    System.out.println( n );
	    }
}

13 .选择排序算法

31,55,66,33,3,1,13,11
设31为初始最小值min，与其他数比较，发现更小的，min和该数交换位置，排序继续，一轮完毕后记录该次排序最小的下标
1 ，55,66,33,31,13,11 第一轮比较6次
1,11， 66,55,33,31,13 第二轮比较5次
1,11,13， 66,55,33,31 第三轮比较4次
1,11,13,31， 66,55,33 第三轮比较3次
…
毎一趟从带排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好的数列的最后，直到全部待排序的元素排完。选择排序是不稳定的排序算法。

 Import java .util.Scanner;
 public class Test13{
       public stastic void main( String [] args){
	        Int[] nums={31,55,66,33,3,1,13,11};
	        Int minIndex=0;//用于记录每次比较的最小值的下标
	        //外层循环控制轮数
	        for ( int i=0 ; i<nums.length ; i++ ){
	        //内层循环j表示和minIdex做比较的元素下标取值范围，很明显是从i+1个到最后一个
		        for (int j=i+1 ; j<nums.length ; j++ ){
			        if(nums[minIndex]>nums[ j ] ){
			        	minIndex=j;
			        }
		        }//判断需要交换的数下标是否为自己,不是自己要交换
		        if ( minIndex!=i){
			        nums[minIndex]=nums[minIndex]+nums[ i]；
			        nums[ i ]=nums[minIndex]-nums[ i]；
			        nums[minIndex]=nums[minIndex]-nums[ i]；
			       }
	        }
	        //输出结果
	        For(int n:nums){
		        System.out.printlin(n);
	        }
	   }
    }