数据结构中的排序算法

概述

数据结构中的排序算法分为内部排序算法和外部排序算法,内部外部的区分标识在于数据量的多少,当数据量较小在内存中就能一次性的把所有的数据完成排序,这就是内部排序,数据量很大时需要借助外存才能完成排序,这就是外部排序,本篇博客就是从思想到具体实现介绍数据结构中的排序算法.

1 内部排序

内部排序按照排序的方式有可分为插入排序,选择排序,交换排序,归并排序等.

插入排序

1.1 直接插入排序

所谓的直接插入排序就是将一个数据插入到长度为n并且已经是排好序的有序列表中,在插入之后变为长度为n+1的有序表.

以遍历方式为划分标准,直接插入排序可分为两种,分别是自前而后排序和自后而前排序,下面是具体的实现(Java版本).

//自前往后排序
//思路是依次比较两个相邻元素的大小,当出现逆序的时候就要在前面已经排好序的表中为其找到一个合适的位置插入
public class InsertSort{
	public void insertSort(int [] a){
		int size=a.length;
		for(int i=1;i<size;i++){
			if(a[i]<a[i-1]){
				for(int j=0;j<i;j++){
					if(a[j]>a[i]){
						int temp=a[j];
						a[j]=a[i];
						a[i]=temp;
					}
				}
			}
			print(a);
		}
	}
	public void insertSort1(int [] a){
		int size=a.length;
		for(int i=size-1;i>0;i--){
			if(a[i-1]>a[i]){
				for(int j=i;j<size;j++){
					if(a[j-1]>a[j]){
						int temp=a[j-1];
						a[j-1]=a[j];
						a[j]=temp;
					}
				}
			}
			print(a);
		}
	}
	public void print(int [] a){
        System.out.print("a={");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + ",");
        }
        System.out.print("}");
        System.out.println();
    }
    public static void main(String[] args){
    	InsertSort insertSort=new InsertSort();
    	int [] numbers={10,9,3,1,5,2,0};
    	insertSort.insertSort(numbers);
    	insertSort.insertSort1(numbers);
    }

总结
直接插入排序是最简单的一种排序方式,同时它还是一种稳定排序,所谓的稳定排序就是当插入元素与原有序表中的元素相同时,插入元素插入到原有序表元素的后面,不改变其位置,这就是稳定排序.
直接插入排序的时间复杂度为O(n^2)(共n个数),因为遍历一次的时间复杂度为n,需要比较n-1次,故时间复杂度为n平方.

1.2 希尔排序

所谓的希尔排序是在直接插入排序的基础上引入增量的概念,即将整个序列分为若干个子序列,对每个子序列运行直接插入排序,最后当增量为1的时候对整个序列进行直接插入排序,从而实现了对整个序列的排序.

public Class ShellSort{
	public void shellSort(int [] a){
		int size=a.length;
		int h=sizw/2;
		while(h>0){
			for(int i=h;i<sizw;i+=h){
				if(a[i-h]>a[i]){
					for(int j=0;j<i;j+=h){
						if(a[j]>a[i]){
							int temp=a[j];
							a[j]=a[i];
							a[i]=temp;
						}
					}
				}
			}
		}
	}
	public void print(int [] a){
		System.out.print("a={");
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+",");
		}
		System.out.print("}");
		System.out.println();
	}
}

总结
所谓希尔排序就是改进版的直接插入排序,引入了增量序列,第一次突破了n^2的时间复杂度,这是因为希尔排序事先做了对无序序列的"处理工作",经过了这些处理工作,原本无序的序列已经基本变得有序,此时再执行直接插入排序时间复杂度趋于O(n),这样时间复杂度相对于直接插入排序就缩短了,此外希尔排序是一个不稳定的排序方法.

1.2 选择排序

1.2.1 简单选择排序

简单选择排序的基本思想:比较和交换.
排序的基本步骤:
1.从待排序的序列中找到最小的元素;
2.判断最小的元素是否在第一个元素的位置,如果不是则替换;
3.从剩下的N-1个元素执行步骤1,2,直至排序结束.
从上面的步骤可以看出基本选择排序需要两重循环,它查询和比较的次数跟初始序列是否有序无关,因此它的时间复杂度始终为O(n^2),它是一个不稳定的排序算法.

public class SimpleSelectSort{
	public void simpleSelectSort(int [] a){
		int size=a.length;
		for(int i=0;i<size;i++){
			for(int j=i+1;j<size;j++){
				if(a[j]>a[i]){
					int temp=a[j];
					a[j]=a[i];
					a[i]=temp;
				}
			}
			print(a);
		}
	}
	public void print(int [] a){
		System.out.print("a={");
		for(int i=0;i<a.length;a++){
			System.out.print(a[i]+",");
		}
		System.out.print("}");
		System.out.println();
	}
}

1.2.2 堆排序

堆排序