数据结构与算法：排序(java代码)

一，基本概念

排序又称为分类，就是将一组任意序列的数据元素按一定的规律进行排列，使之成为有序序列。
按照排序过程中所涉及的存储器，可分为内部排序和外部排序；
按照排序的稳定性，可分为稳定排序和不稳定排序；
按照排序采用的策略，可分为插入排序，交换排序，选择排序，归并排序和基数排序。

二，插入排序

1.直接插入排序

 public static void insertionSort(int[] a) {
        int tmp;
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0; j--) {
                if (a[j] < a[j - 1]) {
                    tmp = a[j - 1];
                    a[j - 1] = a[j];
                    a[j] = tmp;
                }
            }
        }
    }

二，交换排序

1.冒泡排序

public class BubbleSort {
	public static void main(String[] args) {
		int a[]= {1,5,32,7,4};
		int temp;
        	for(int i=0;i<a.length;i++) {
        		for(int j=i+1;j<a.length;j++) {
        			if(a[i]>a[j]) {
        				temp=a[i];
        				a[i]=a[j];
        				a[j]=temp;
        			}
        		}
        	}
    	  for(int i=0;i<a.length;i++) {
    		  System.out.print(a[i]+" ");
    	  }
}
	
	}

2.快速排序
基本思想：任选一个记录，以它的关键字作为“基准”，凡关键字小于基准的记录均移至基准之前，凡关键字大于基准的记录均移至基准之后。
首先对无序的记录序列进行“一次划分”，之后分别对分割所得两个子序列“递归”进行一趟快速排序。

public class FastSort {

	     public static void main(String []args){
	        int[] a = {12,20,5,16,15,1,30,45,23,9};
	        int start = 0;
	        int end = a.length-1;
	        sort(a,start,end);
	        for(int i = 0; i<a.length; i++){
	             System.out.print(a[i]+" ");
	         }
	        
	     }
	     
	     public static void sort(int[] a,int low,int high){
	         int start = low;
	         int end = high;
	         int key = a[low];
	         
	         
	         while(end>start){
	             //从后往前比较
	             while(end>start&&a[end]>=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
	                 end--;
	             if(a[end]<=key){
	                 int temp = a[end];
	                 a[end] = a[start];
	                 a[start] = temp;
	             }
	             //从前往后比较
	             while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
	                start++;
	             if(a[start]>=key){
	                 int temp = a[start];
	                 a[start] = a[end];
	                 a[end] = temp;
	             }
	         //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
	         }
	         //递归
	         if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
	         if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个
	     }
	     
	}

三，选择排序

1.简单选择排序
首先通过 n –1 次关键字比较，从 n 个记录中找出关键字最小的记录，将它与第一个记录交换。
再通过 n –2 次比较，从剩余的 n –1 个记录中找出关键字次小的记录，将它与第二个记录交换。
重复上述操作，共进行 n –1 趟排序后，排序结束。
总结：第i次通过n-i次比较来确定最小的数据元素并排序。

public class SelectionSort {

	     public static void main(String []args){
	        int[] a = {12,20,5,16,15,1,30,45,23,9};
	        for (int i = 0; i < a.length - 1; i++) {
	            int temp = 0;
	            int index = i; // 用来保存最小值得索引
	     
	            // 寻找第i个小的数值
	            for (int j = i + 1; j < a.length; j++) {
	                if (a[index] > a[j]) {
	                    index = j;
	                }
	            }
	     
	            // 将找到的第i个小的数值放在第i个位置上
	            temp = a[index];
	            a[index] = a[i];
	            a[i] = temp;
	     
	}
	        for(int i=0;i<a.length;i++) {
	        	System.out.print(a[i]+" ");
	        }
	        
	     }
	     }

2.堆排序
将无序序列建成一个堆，得到关键字最小（大）的记录；输出堆顶的最小（大）值后，将剩余的 n-1 个元素重又建成一个堆，则可得到 n 个元素的次小值；如此重复执行，直到堆中只有一个记录为止，每个记录出堆的顺序就是一个有序序列，这个过程叫堆排序。
简单来说：堆排序是将数据看成是完全二叉树、根据完全二叉树的特性来进行排序的一种算法。
最大堆要求节点的元素都要不小于其孩子，最小堆要求节点元素都不大于其左右孩子。
那么处于最大堆的根节点的元素一定是这个堆中的最大值。

四，归并排序

将两个或两个以上的序列组合成一个新的有序表。在内部排序中，通常采用的是 2-路归并排序。即将两个位置相邻的记录有序子序列归并为一个记录有序的序列。

五，总结

1、从时间复杂度比较
直接插入排序、冒泡排序、简单选择排序时间复杂度均为O(n2) ，而快速排序、堆排序、二路归并排序的时间复杂度都为O(nlog2n) ，希尔排序的时间复杂度介于这两者之间。
2、从空间复杂度比较
归并排序的空间复杂度最大为 O(n)，快速排序的空间复杂度为 O(lon2n)，其它排序的空间复杂度为 O(1)。
3、从稳定性比较
直接插入排序、冒泡排序、归并排序都是稳定的排序方法，而直接选择排序、希尔排序、快速排序、堆排序是不稳定的排序方法。
4、从算法简单性比较
直接插入排序、冒泡排序、简单选择排序都是简单的排序方法，算法简单，易于理解，而希尔排序、快速排序、归并排序都是改进型的排序方法，算法比简单排序要复杂得多，也难于理解。