算法之选择排序

简单选择排序：

package SelectSort;

import InsertSort.shellSort;

//选择排序之简单选择排序
//简单选择排序：
//基本思路：
//1.从一组数中选取最小的数与第一个数交换
//2.再从剩下的数组选取最小的数与第二个数交换
//3.循环至倒数第二个数与最后一个数比较为止
public class SimpleSelectSort {
	public int[] selectSort(int[] data){
		int tmp = 0;
		int position=0; 
		for(int i=0;i<data.length;i++){
			tmp = data[i];
			for(int j=i+1;j<data.length;j++){
				if(tmp>data[j]){
					tmp = data[j];
					position = j;
					data[position] = data[i];
					data[i] = tmp;
				}
			}
		}
		return data;
	}
	public String toString(int[] data){
		if(data.length==0){
				return "[]";
			}else{
				StringBuilder sb = new StringBuilder("[");
				for(int i = 0;i<data.length;i++){
				sb.append(data[i]+",");
			}
			int len = sb.length();
			sb.delete(len-1,len);
			return sb.append("]").toString();
		}
	}
	
	public static void main(String[] args){
		int[] data = {1,67,54,6,3,78,34,12,45,56,100};
		SimpleSelectSort dis = new SimpleSelectSort();
		System.out.println(dis.toString(dis.selectSort(data)));
	}
}

堆排序：

package SelectSort;

import java.util.Arrays;

public class HeapSort {  
	  
	//交换两者间的数
   public static void swap(int[] data,int i,int j){
	   int tmp = data[i];
	   data[i] = data[j];
	   data[j] = tmp;
	   
   }
   public static void heapSort(int[] data){
	   int arrayLength = data.length;
	   //循环创建堆
	   for(int i = 0;i<arrayLength-1;i++){
		   //创建堆
		   //自下至上创建堆，先是获得最后一个叶子结点的父节点
		   //比较父节点与其两个子节点间的大小，子节点大则交换
		   buildMaxheap(data,arrayLength-1-i);
		   //堆创建好之后，需要将堆顶元素与最大索引处交换
		   swap(data,0,arrayLength-1-i);
		  
	   }
	   System.out.println("排序后数组：" + Arrays.toString(data));
   }
   //建造大堆顶
   public static void buildMaxheap(int[] data,int lastIndex){
	   for(int parent = (lastIndex-1)/2;parent>=0;parent--){
		 //得到该父节点下的子节点，进行比较，交换
		   //得到的是父节点下的左子节点,并且作为最大数的一个索引
		   int biggestIndex = parent*2+1;
		   if(biggestIndex<lastIndex){
			   //判断该左子节点是否还有右子节点
			  
				   //如果左子节点比右子节点小，则把biggestIndex加一,biggestIndex总是记录最大值
				   if(data[biggestIndex]<data[biggestIndex+1]){
					   biggestIndex++;
				   }
			   
		   }
		 //确定叶子结点，用最大的叶子结点数与父节点作比较，父节点小则交换
		   if(data[parent]<data[biggestIndex]){
			   //交换两者
			   swap(data,parent,biggestIndex);  
			   //parent = biggestIndex;
			   biggestIndex = parent;
		   }
		   //将最大值索引交换  
		  // biggestIndex = parent;
		   
	   }
   }
	 public static void main(String[] args) {  
		//int[] array = {1,13,44,69,97,53,29,42,96,51,40,12,8,14,10,100};
		int[] array = {13,69,97,53,29,42,96,51,40,12,8,14,10,100};
		HeapSort.heapSort(array);   
	}
  
}