排序算法 ---选择排序（直排，堆排）（java）

排序是在程序开发中常用的操作，也是个大公司面试的时候检验一个人编程能力的一个必考题，排序就是涉及到了算法了，今天下午就想着来搞一下排序的算法，算是对其有一个初步的了解吧，后天期中考了，挂科可就不是排序算法能够解决的问题了。

衡量一个算法优劣的标准：

1.时间复杂度，完成这个任务，算法所需要的时间。

2.空间复杂度，完成该任务，算法所需要的占用的内存空间，或者是所需要的外部辅助空间。

3.稳定性，完成任务后，对原始数据的影响大不大，会不会产生了一些不必要的操作，导致了原始数据发生了错误。

现在的排序方式分为两种：1.内部排序2.外部排序

内部排序就是整个排序操作都在内存中执行不借助于外部，外部排序就是需要借助外部的存储，大多是数据量比较大的一些排序，对于外部排序常用的方式就是多路归并操作，将原始文件分成多个可以一次性装进内存的子文件，执行排序，排序后，将其输出到外部程序中。

我们所说的排序大多指的是内部排序，内部排序分为以下几类：选择排序（直接选择排序，堆排序），交换排序（冒泡排序，快速排序），插入排序（直接插入排序，折半插入排序，Sheel排序），归并排序，桶式排序，基数排序。

选择排序

1.直接选择排序

//直接选择排序
    public int[] sort(int[] a) {
	for (int i = 0; i < a.length - 1; i++) {
	    int max = a[i];
	    for (int j = i + 1; j < a.length; j++) {
		if (a[j] > max) {
		    max = a[j];
		    a[j] = a[i];
		    a[i] = max;
		}
	    }

	}
	return a;

    }

思路：两个嵌套的for循环，通过第一个循环找到第一个元素，通过一个值记录这个元素，然后进入下一个循环，通过这个循环找到该数组中当前元素值要大的数，然后将两者的值进行交换。上面的排序中当找出来符合值之后要进行多次值的交换，比较影响程序性能的，下面这种通过记录其下标值来对较大的值做一个记录，然后最后再对其进行交换，如果数据大的话，明显的可以提升程序的性能。

public int[] sort(int[] a) {
	for (int i = 0; i < a.length - 1; i++) {
	    int index = i;
	    for (int j = i + 1; j < a.length; j++) {
		if (a[j] > a[index]) {
		    index = j;
		}
	    }
	    if(index != i)
	    {
//		不借助第三变量将连个数的值进行交换
		a[i] = a[index]+a[i];
		a[index] = a[i]- a[index];
		a[i] = a[i] - a[index];
	    }

	}
	return a;

    }

2.堆排序

堆排序，首先就是要建堆，堆在这里又分为大顶堆和小顶堆，根据堆，堆在本质上就是一个二叉树，大顶堆就是二叉树的根节点是树中最大的值，小顶堆就是根节点为最小的二叉树，利用堆进行排序的时候，首先是将所有数据建堆，将最大数或者最小数选择出来，然后放在所有数据的最后面，然后将剩余的数据执行上一次操作。

public void buildHeap(int [] a){
	for(int i = 0;i<a.length-1;i++){
	    buildMaxHeap(a,a.length-1-i);
	    a[0] = a[0]+a[a.length-1-i];
	    a[a.length-1-i] =a[0]-a[a.length-1-i];
		    a[0]=a[0]-a[a.length-1-i];
	}
    }
    
    public void buildMaxHeap (int []a,int lastIndex){
	for(int i = (lastIndex-1)/2 ; i >= 0 ; i--){
	    int k = i;
	    while(k*2+1 <= lastIndex){
		int biggerIndex = 2*k+1;
		if(biggerIndex<lastIndex){
		    if(a[biggerIndex]<a[biggerIndex+1]){
			biggerIndex++;
		    }
		}
		if(a[k]>a[biggerIndex]){
		    a[k] = a[k]+a[biggerIndex];
		    a[biggerIndex] = a[k] - a[biggerIndex];
		    a[k] = a[k]-a[biggerIndex];
		}
		else
		    break;
	    }
	}
    }

对原来的数组进行抽象化，将其抽象成一棵二叉树，数组中的首位元素是二叉树的根结点，首先我们找到该数组的最后一位元素的下标，然后建立大顶堆，找到最后一个元素的父结点，判断左右结点的大小，然后记录下数值较大的数的坐标，然后将其和其父节点进行数值上的交换，然后继续向和其父节点处在同一层的元素的大小判断，最中产生

了一个大顶堆，然后我们将这个顶端的值保存在数组的最后一个元素的位置，然后将之前的记录的最后一个位置坐标向前移动一位，然后接着进行循环。