写在前面的话，如果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);
}
}
}
