【算法】排序

1.冒泡排序

算法思想：遍历待排序的数组，每次遍历比较相邻的两个元素，如果他们的排列顺序错误就交换他们的位置，经过一趟排序后，最大的元素会浮置数组的末端。重复操 作，直到排序完成。

两次for循环，可以从后往前，首先比较全部的，比较完把最大的放最后，然后减掉最后一个比较剩下的。

public static void changenumber(int[] a){
        int temp = 0;                                //设置中间变量
       for (int i = a.length - 1; i > 0; --i)        //从后往前判断
        {
         for (int j = 0; j < i; ++j)               //判断i以前两个数值的大小，最终把这次循环最大的数放到i的位置上去
           {
               if (a[j + 1] < a[j])                    
               {
                   temp = a[j];
                   a[j] = a[j + 1];
                   a[j + 1] = temp;  
               }
           }
       }
      }
public static void main(String[] args) {
     int i = 0;
     int a[] = {9,4,2,1,5,6,7,8,4};
     changenumber(a);
     for (i = 0; i < a.length; i++) {
     System.out.println(a[i]);
     }
}

2.插入排序

 

刚开始假定一个记录有序，其余记录无序，接着从第二个记录开始，插入到前面的有序数列中

以数组{38,65,97,76,13,27,49}为例， 

 

public static void InsertSort(int[] arr)
{
    int i, j;
    int target;  //这个 target 一定要有，很重要!
 
    //假定第一个元素被放到了正确的位置上
    //这样，仅需遍历1 到 n-1
    for (i = 1; i < arr.length;i++)
    {
        j = i;
        target = arr[i];
 
        while (j > 0 && target < arr[j - 1])
        {
            arr[j] = arr[j - 1];
            j--;
        }
 
        arr[j] = target;
    }
}

 

我们这样来看：

当i=1时，i<7

j=1,target=65

j>0 65>arr[0],不进入while ，arr[1]=65；

当i=3时，i<7

j=3,target=76

j>0 且76<arr[2],此时arr[3]=arr[2],和那个大的交换和顺序，然后j--继续往前比较。

3.选择排序

 

给定一组记录，经过一轮比较得到最小记录，然后将该记录和第一个记录位置交换，接着对不包括第一个记录以外的其他记录进行第二轮比较，得到最小记录并与第二个记录进行位置交换，如此下去即可

 

public class xzpx {
    //选择排序
public static void changenumber(int[] a) {
int temp = 0;
int flag = 0;
for (int i = 0; i < a.length; i++) {
temp = a[i];                                                  //当前值给temp
flag = i;                                                     //把当前值的位置传递给flag
for (int j = i + 1; j < a.length; j++) {                      //循环当前值之后的值，把当前值之后的最小值给temp,位置给flag
if (a[j] < temp) {                                        //如果之后有小于当前值的
temp = a[j];                                          //将之后的那个值给temp
flag = j;                                             //将之后的那个值的位置给flag


}


}
if(flag !=i){                                                  //如果值之后的最小值不是他自己                 
a[flag]=a[i];                                             //最小值现在下标是flag，把最小值的位置给当前值
a[i]=temp;                                                //把那额个最小值得值赋值给当前值

}
}
}
public static void main(String[] args) {
int i = 0;
int a[] = { 9, 8, 1, 6, 4, 4, 3, 2, 1 };
changenumber(a);
for (i = 0; i < a.length; i++) {


System.out.println(a[i]);
}


}
}

4.快速排序

基本思想：

先找到一个初始关键字，然后使左边都比它小，右边都比它大，然后按这种方式处理左边和右边。

具体实现：

快速排序可以归结为：挖坑填数+分治法

我们以这个数组为例子，取位置0作为基准数。

 

开始时，i = 0; j = 9; X = a[i] = 72
由于已经将a[0]中的数保存到X中，可以理解成在数组a[0]上挖了个坑，可以将其它数据填充到这来。
从j开始向前找一个比X小或等于X的数。当j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8]; i++; 这样一个坑a[0]就被搞定了，但又形成了一个新坑a[8]，这怎么办了？简单，再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数，当i=3，符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3]; j--;

数组变为

 

i = 3; j = 7; X=72

再重复上面的步骤，先从后向前找，再从前向后找。

从j开始向前找，当j=5，符合条件，将a[5]挖出填到上一个坑中，a[3] = a[5]; i++;

从i开始向后找，当i=5时，由于i==j退出。

此时，i = j = 5，而a[5]刚好又是上次挖的坑，因此将X填入a[5]。

数组变为：

 

可以看出a[5]前面的数字都小于它，a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。

总结:

对挖坑填数进行总结

1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。

2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。

3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。

4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。

 

public class kspx{
	public static void main(String[] args) {
		int[] a={3,4,5,2,1};
		Sortkspx(a,0,4);
		for (int i=0;i<a.length;i++){
	     System.out.print(a[i]+",");
			}
	}
	
static void Sortkspx(int s[], int l, int r)  
	{  
	    if (l < r)                  //判断开始和结束值是否合规
	    {  
	        int i = l, j = r, x = s[l];   //起始值给i 终止值给j 将数值起始值给x 
	        while (i < j)                 //一直到i不小于j时
	        {  
	        	while(i < j && s[j] >= x)        
	                j--;                  //不断进行j-- 一直找到小于x的数
	                if(i < j)                           
	                s[i++] = s[j];        //将这个数放到起点位置 ，然后i+1
	              
	                while(i < j && s[i] < x)  // 
	                i++;    
	                if(i < j)                 //找到s[i]大于X得数
	                s[j--] = s[i];        //将这个放到j位置，然后j-1
	        }  
	        s[i] = x;                     //X就是抽出来的那个值，这里的意思是把X方法哦隔断值上
	       
	        Sortkspx(s, l, i - 1); // 递归调用   
	        Sortkspx(s, i + 1, r);  
	    }  
	}  
}	

输出：

 

1,2,3,4,5,

 

几种排序的比较：

1.稳定性比较

插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的
选择排序、希尔排序、快速排序、堆排序是不稳定的

2.时间复杂性比较

插入排序、冒泡排序、选择排序的时间复杂性为O(n2)
其它非线形排序的时间复杂性为O(nlog2n)
线形排序的时间复杂性为O(n);

3.辅助空间的比较

线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空间为O(1);


4.其它比较

插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度
反而在这种情况下，快速排序反而慢了。
当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。
若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。
当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。
当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下,宜用归并排序。
当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。