Java八大排序

概述 

排序分为内部排序与外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。


当n较大时,应该采用时间复杂度为0(nlog2n)的排序方法:快速排序、堆排序、归并排序。

快速排序是目前基于比较的内部排序中被认为最好的方法,当待排序的关键字是随机分布时,快速排序的平均时间最短。

1、直接插入排序(Straight Insertion Sort)                      基本思想:把n个待排序的元素看成为一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含有n-1个元素,排序过程中每次从无序表中取出第一个元素,将它插入到有序表中的适当位置,使之成为新的有序表,重复n-1次可完成排序过程。

把a[i]插入到a[0],a[1],...,a[i-1]之中的具体实施过程为:先把a[i]赋值给变量t,然后将t依次与a[i-1],a[i-2],...进行比较,将比t大的元素右移一个位置,直到发现某个j(0<=j<=i-1),使得a[j]<=t或j为(-1),把t赋值给a[j+1]. 

    

算法分析:直接插入排序算法的空间复杂度为O(1)。 

最好的情况,要比较的无序序列原本就是顺序有序的,那么要比较的次数是n-1,移动了0次,时间复杂度O(n)。 

最坏的情况,要比较的无序序列原本就是逆序有序的,那么要比较的次数是(n+2)(n-1)/2,移动的次数(n+4)(n-1)/2,时间复杂度O(n²)。

直接插入排序的平均复杂度为O(n²),直接插入排序是稳定的。                                                                                   

public void insertSort(int[] arr) {
		for(int i=1;i<arr.length;i++) {//首位元素作为已排好的有序序列,后续元素一个一个插入当中
			int j;
			int x=arr[i];//待插入元素
			for(j=i;j>0 && x<arr[j-1];j--) {//逐个前移寻找对应的位置
				arr[j]=arr[j-1];
			}
			arr[j]=x;
		}
	}

2、希尔排序(Shell Sort)

基本思想:先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的记录“基本有序”时,再对全体记录进行依次直接插入排序。

操作方法:

  1. 选择一个增量序列t1,t2,…,tk,其中ti>tj,tk=1;
  2. 按增量序列个数k,对序列进行k 趟排序;
  3. 每趟排序,根据对应的增量ti,将待排序列分割成若干长度为m 的子序列,分别对各子表进行直接插入排序。仅增量因子为1 时,整个序列作为一个表来处理,表长度即为整个序列的长度  

 

算法实现:我们简单处理增量序列:增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

即:先将要排序的一组记录按某个增量d(n/2,n为要排序数的个数)分成若干组子序列,每组中记录的下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的增量(d/2)对它进行分组,在每组中再进行直接插入排序。继续不断缩小增量直至为1,最后使用直接插入排序完成排序。   

               

public class ShellSort {  
  
    public static void main(String[] args) {  
        int a[] = {3,1,5,7,2,4,9,6,10,8};    
        ShellSort  obj=new ShellSort();  
        System.out.println("初始值:");  
        obj.print(a);  
        obj.shellSort(a);  
        System.out.println("\n排序后:");  
        obj.print(a);  
  
    }  
    private void shellSort(int[] a) {  
         int dk = a.length/2;   
         while( dk >= 1  ){    
            ShellInsertSort(a, dk);    
            dk = dk/2;  
         }  
    }  
    private void ShellInsertSort(int[] a, int dk) {//类似插入排序,只是插入排序增量是1,这里增量是dk,把1换成dk就可以了  
        for(int i=dk;i<a.length;i++){  
            if(a[i]<a[i-dk]){  
                int j;  
                int x=a[i];//x为待插入元素  
                a[i]=a[i-dk];  
                for(j=i-dk;  j>=0 && x<a[j];j=j-dk){//通过循环,逐个后移一位找到要插入的位置。  
                    a[j+dk]=a[j];  
                }  
                a[j+dk]=x;//插入  
            }  
                  
        } 
          
    }  
    public void print(int a[]){  
        for(int i=0;i<a.length;i++){  
            System.out.print(a[i]+" ");  
        }  
    }  
}  

希尔排序时效分析很难,关键码的比较次数与记录移动次数依赖于增量因子序列d的选取,特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的增量因子序列的方法。增量因子序列可以有各种取法,有取奇数的,也有取质数的,但需要注意:增量因子中除1 外没有公因子,且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。

3、简单选择排序(Simple Selection Sort)

基本思想:在要排序的一组数中,选出最小(或者最大)的一个数与第1个位置的数交换;然后在剩下的数当中再找最小(或者最大)的与第2个位置的数交换,依次类推,直到第n-1个元素(倒数第二个数)和第n个元素(最后一个数)比较为止。

简单选择排序的示例:

 

操作方法:第一趟,从n 个记录中找出关键码最小的记录与第一个记录交换;


      第二趟,从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换;


      以此类推.....

      第i 趟,则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换,直到整个

      序列按关键码有序。

public class SimpleSelectSort {  
  
    public static void main(String[] args) {  
        int a[] = {3,1,5,7,2,4,9,6,10,8};    
        SimpleSelectSort  obj=new SimpleSelectSort();  
        System.out.println("初始值:");  
        obj.print(a);  
        obj.selectSort(a);  
        System.out.println("\n排序后:");  
        obj.print(a);  
  
    }  
    private void selectSort(int[] a) {  
        for(int i=0;i<a.length;i++){  
            int k=i;//k存放最小值下标。每次循环最小值下标+1  
            for(int j=i+1;j<a.length;j++){//找到最小值下标  
                if(a[k]>a[j])  
                    k=j;  
            }  
            swap(a,k,i);//把最小值放到它该放的位置上  
        }  
    }  
    public void print(int a[]){  
        for(int i=0;i<a.length;i++){  
            System.out.print(a[i]+" ");  
        }  
    }  
     public  void swap(int[] data, int i, int j) {    
            if (i == j) {    
                return;    
            }    
            data[i] = data[i] + data[j];    
            data[j] = data[i] - data[j];    
            data[i] = data[i] - data[j];    
        }    
}  

4、堆排序

堆排序是一种树形选择排序,是对直接选择排序的有效改进
基本思想:堆的定义如下:具有n个元素的序列(k1,k2,...,kn),当且仅当满足

             

时称之为堆。由堆的定义可以看出,堆顶元素(即第一个元素)必为最小项(小顶堆)。
若以一维数组存储一个堆,则堆对应一棵完全二叉树,且所有非叶结点的值均不大于(或不小于)其子女的值,根结点(堆顶元素)的值是最小(或最大)的。如:
   (a)大顶堆序列:(96, 83,27,38,11,09)
   (b)小顶堆序列:(12,36,24,85,47,30,53,91)
             
  初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树(一维数组存储二叉树),调整它们的存储序,使之成为一个堆,将堆顶元素输出,得到n 个元素中最小(或最大)的元素,这时堆的根节点的数最小(或者最大)。然后对前面(n-1)个元素重新调整使之成为堆,输出堆顶元素,得到n 个元素中次小(或次大)的元素。依此类推,直到只有两个节点的堆,并对它们作交换,最后得到有n个节点的有序序列。称这个过程为堆排序。

因此,实现堆排序需解决两个问题:
1. 如何将n 个待排序的数建成堆;
2. 输出堆顶元素后,怎样调整剩余n-1 个元素,使其成为一个新堆。

首先讨论第二个问题:输出堆顶元素后,对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法:

1)设有m 个元素的堆,输出堆顶元素后,剩下m-1 个元素。将堆底元素送入堆顶((最后一个元素与堆顶进行交换),堆被破坏,其原因仅是根结点不满足堆的性质。

2)将根结点与左、右子树中较小元素的进行交换。

3)若与左子树交换:如果左子树堆被破坏,即左子树的根结点不满足堆的性质,则重复方法 (2).

4)若与右子树交换,如果右子树堆被破坏,即右子树的根结点不满足堆的性质。则重复方法 (2).

5)继续对不满足堆性质的子树进行上述交换操作,直到叶子结点,堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图:

                                

再讨论对n 个元素初始建堆的过程。
建堆方法:对初始序列建堆的过程,就是一个反复进行筛选的过程。

1)n 个结点的完全二叉树,则最后一个结点是第个结点的子树。

2)筛选从第个结点为根的子树开始,该子树成为堆。

3)之后向前依次对各结点为根的子树进行筛选,使之成为堆,直到根结点。

如图建堆初始过程:无序序列:(49,38,65,97,76,13,27,49)

               

public class HeapSort {  
  
    public static void main(String[] args) {  
        int a[] = {3,1,5,7,2,4,9,6,10,8};    
        HeapSort  obj=new HeapSort();  
        System.out.println("初始值:");  
        obj.print(a);  
          
        for(int i=0;i<a.length;i++){  
            obj.createLittleHeap(a,a.length-1-i);//创建堆,创建的是小顶堆。每次循环完,二叉树的根节点都是最小值,所以与此时的未排好部分最后一个值交换位置  
            obj.swap(a, 0, a.length - 1 - i);//与最后一个值交换位置,最小值找到了位置  
            obj.print(a);  
            System.out.println();  
              
        }  
          
        System.out.println("\n排序后:");  
        obj.print(a);  
  
    }  
    /* 
     * 创建小顶堆:双亲节点小于子节点的值。从叶子节点开始,直到根节点。这样建立的堆定位最小值 
     */  
    private void createLittleHeap(int[] data, int last) {  
         for (int i = (last- 1) / 2; i >= 0; i--) {  //找到最后一个叶子节点的双亲节点  
                // 保存当前正在判断的节点    
                int parent = i;    
                // 若当前节点的左子节点存在,即子节点存在  
                while (2 * parent + 1 <= last) {    
                    // biggerIndex总是记录较大节点的值,先赋值为当前判断节点的左子节点    
                    int bigger = 2 * parent + 1;//bigger指向左子节点    
                    if (bigger < last) { //说明存在右子节点  
                        
                        if (data[bigger] > data[bigger+ 1]) { //右子节点>左子节点时  
                           
                            bigger=bigger+1;    
                        }    
                    }    
                    if (data[parent] > data[bigger]) {  //若双亲节点值大于子节点中最大的  
                        // 若当前节点值比子节点最大值小,则交换2者得值,交换后将biggerIndex值赋值给k    
                        swap(data, parent, bigger);    
                        parent = bigger;    
                    } else {    
                        break;    
                    }    
                }    
            }    
    }  
    public void print(int a[]){  
        for(int i=0;i<a.length;i++){  
            System.out.print(a[i]+" ");  
        }  
    }  
     public  void swap(int[] data, int i, int j) {    
            if (i == j) {    
                return;    
            }    
            data[i] = data[i] + data[j];    
            data[j] = data[i] - data[j];    
            data[i] = data[i] - data[j];    
        }    
}  

5、冒泡排序(Bubble Sort)

基本思想:冒泡排序算法需要遍历几次数组。在每次遍历中,比较连续相邻的元素。如果某一对元素的排序与排序要求相反,则互换他们的值;否则,保持不变。



在第k次遍历时,不需要考虑最后k-1个元素,因为他们已经排序好了。

public class BubbleSort {
	
	public static void bubbleSort(int[] list) {
		boolean needNextPass=true;
		
		for(int k=1;k<list.length && needNextPass;k++ ) {
			needNextPass=false;
			for(int i=0;i<list.length-k;i++) {
				if(list[i]>list[i+1]) {
					int temp=list[i];
					list[i]=list[i+1];
					list[i+1]=temp;
					needNextPass=true;
				}
			}
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] list= {2,3,2,5,6,1,-2,3,14,12};
		bubbleSort(list);
		for(int a:list)
			System.out.print(a+"  ");
	}

}

6、快速排序(Quick Sort)

基本思想:快速排序算法在数组中选择一个称为主元(pivot)的元素,将数组分为两部分,使得第一部分的所有元素小于或等于主元,而第二部分的所有元素都大于主元。对第一部分递归地应用快速排序算法,然后对第二部分递归地应用快速排序算法。

7、归并排序(Merge Sort)

8、基数排序(Radix Sort)


猜你喜欢

转载自blog.csdn.net/wulibabywenyu/article/details/79770082
0条评论
添加一条新回复