排序算法之插入排序（Java）及堆排序

1.直接插入排序

《算法导论》P10，《数据结构》P265

向已经排好序的数组a[1..j-1]插入a[j],进行一趟循环遍历。插入排序的基本操作是在一个有序表进行查找和插入。每一趟插入排序从后往前进行比较，便于数组中元素的向后移动。

空间复杂度：O(1)（当使用swap交换时，可实现原址）

时间复杂度：(n^2)/4即O(n^2)

2.拓展

1）折半查找排序

插入排序的基本操作是在一个有序表进行查找和插入。由查询故可以想到“二分查找”即折半查找，通过折半查找找到插入位置，再操作数组插入

 

代码：

//插入排序
public class Insert_Sort {

	//直接插入排序
	public void InsertSort(int[] data)
	{
		if((data != null)&&(data.length > 0))
		{
			for(int i = 1;i < data.length; i ++)
			{
				int key = data[i];//记录下当前需要插入的数字，作为哨兵
				int index = i - 1;//记录哨兵最终要插入的位置
				//一直循环找到第一个比key小的位置
				while((index > 0)&&(data[index] > key))
				{
					//后移数组
					data[index + 1] = data[index];
					index --;
				}
				//将哨兵插入
				data[index + 1] = key;
			}
		}
	}
	
	//直接插入排序实现方法二
	public void InsertSort2(int[] data)
	{
		if((data != null)&&(data.length > 0))
		{
			for(int i = 1;i < data.length; i ++)
			{
				int key = data[i];//记录下当前需要插入的数字，作为哨兵
				int index = i - 1;//记录哨兵最终要插入的位置
				//一直循环找到第一个比key小的位置
				while((index > 0)&&(data[index] > key))
				{
					//直接交换数据，即将要插入的值通过不断往前交换，插入到合适的值
					swap(data, index + 1, index);
					index --;
				}
			}
		}
	}
	
	
	//折半插入排序
	public void BinaryInsertSort(int[] data)
	{
		if((data != null)&&(data.length > 0))
		{
			for(int i = 1;i < data.length; i ++)
			{
				int key = data[i];//记录下当前需要插入的数字，作为哨兵
				int start = 0;
				int end = i - 1;
				//二分查找
				while(start < end)
				{
					int mid = (start + end) / 2;
					if(data[mid] > key)//插入点在前半段
					{
						end = mid - 1;
					}
					else if(data[mid] < key)//插入点在后半段
					{
						start = mid + 1;
					}
					else          //相等即找到插入点
					{
						start = end = mid;
					}
				}
				
				//移动数组插入,注意要从后往前移动，且此时start=mid
				for(int j = i - 1; j > end; j--)
				{
					data[j + 1] = data[j];
				}
				data[end + 1] = key;
			}
		}
	}
	
	private void swap(int[] data , int a, int b)
	{
		int temp = data[a];
		data[a] = data[b];
		data[b] = temp;
	}
	
	public static void main(String[] args) {
		int data[] = {2,34,45,2,13,24,5,24,57};
		Insert_Sort insert_Sort = new Insert_Sort();
		insert_Sort.BinaryInsertSort(data);
		Main.print_array(data);
	}

}

二、堆排序：

/** 堆排序（最小堆）**/
public class HeapSort<T> {
	

	private List<T> heaps;
	private Comparator<T> comparator;
	
	public HeapSort(int max_size, Comparator<T> comparator) {
		if (max_size >= 0) {
			heaps = new ArrayList<T>(max_size);
		}
		this.comparator = comparator;
	}
	
	/** 
	 * 上移调整堆中元素  
	 * 
	 * @param index 要迁移的元素位置index**/
	private void shiftUp(int index) {
		// 判断index是否合法
		if ((index < 0) || (index >= heaps.size())) 
			return;
		
		T target = heaps.get(index);
		
		while (index > 0) {
			int parentIndex = (index - 1) / 2;
			T parentData = heaps.get(parentIndex);
			// 如果父节点的值大于新插入节点值，则需要进行交换
			if (comparator.compare(parentData, target) > 0) {
				heaps.set(index, parentData);
				index = parentIndex;
			} else { // 否则则表示已经形成了最小堆，无需再做转换
				break;
			}
		}
		// 将target移动到最合适的位置
		heaps.set(index, target);
	}
	
	/**
	 * 下移调整
	 * 思路：对于index位置的元素，首先找出其左右子节点的较小值；然后与index位置元素作比较
	 * 若较小值小于[index]，则明显不符合最小堆的性质，因此需要将两者位置进行交换
	 ***/
	private void shiftDown(int index) {
		// 判断index是否合法
		if ((index < 0) || (index >= heaps.size())) 
			return;
		T target = heaps.get(index); 
		int leftIndex = index * 2 + 1;
		
		while (leftIndex < heaps.size()) {
			int minIndex = leftIndex;
			T minData = heaps.get(minIndex);// 默认左节点为较小节点
			
			int rightIndex = leftIndex  + 1;
			if (rightIndex < heaps.size()) { // 弱存在右节点，则需要比较得到较小的那个
				T rightData = heaps.get(rightIndex);
				if (comparator.compare(rightData, minData) < 0) {
					minData = rightData;
					minIndex = rightIndex;
				}
			}
			
			// 再将最小值与目标值进行比较
			if (comparator.compare(target, minData) > 0) {
				heaps.set(index, minData);
				// 为继续循环做准备
				index = minIndex;
				leftIndex = minIndex * 2 + 1;
			} else {
				break;
			}
		}
	}
	
	/** 添加元素  **/
	public void addToHeap(T node) {
		heaps.add(node);
		shiftUp(heaps.size() - 1);
	}
	
	/** 建堆   **/
	public void buildHeap(T[] nodes) {
		for (T node : nodes) {
			addToHeap(node);
		}
	}
	
	/** 从堆中删除堆顶元素  
	 *  @return 返回删除的元素 **/
	public T removeHeapTop() {
		// 如果当前堆为空，则不能继续删除
		if (isEmpty()) return null;
		T topData = heaps.get(0);
		
		if (heaps.size() > 1) {// 等于1，则移除之后堆便为空，无需再做重排
			// 由于删除堆顶元素之后，其左右子树仍然是最小堆，故取最后的叶子节点放到
			// 堆顶,进行ShiftDown重排之后最后得到的堆依然是最小堆
			T lastData = heaps.remove(heaps.size() - 1);
			heaps.set(0, lastData);
			shiftDown(0);
		}
		return topData;
		
	}
	
	
	/** 进行排序   **/
	public void heapSortPrint(T[] nodes) {
		if (nodes == null || nodes.length == 0) 
			return;
		T data = null;
		
		while ((data = removeHeapTop()) != null) {
			System.out.print(data);
		}
		
	}
	
	/** 判断堆是否为空  **/
	public boolean isEmpty() {
		return heaps.isEmpty();
	}
	
	public static class ListNode {
	    int val;
	    ListNode next;

	    ListNode(int x) {
	        val = x;
	    }
	}
	

	public static void main(String[] args) {
		Comparator<ListNode> comparator = new Comparator<ListNode>() {

			@Override
			public int compare(ListNode o1, ListNode o2) {
				if (o1 == null) 
                    return -1;
                if (o2 == null)
                    return 1;
                return o1.val - o2.val;
			}
		};
		
		int[] datas = {1, -2, 3, 4, -5, 6, 7, -8, 9, -100};
		
		ListNode[] nodes = new ListNode[datas.length];
		for (int i = 0; i < nodes.length; i++) {
			nodes[i] = new ListNode(datas[i]);
		}
		
		HeapSort<ListNode> heapSort = new HeapSort<>(nodes.length, comparator);
		heapSort.heapSortPrint(nodes);
		
	}
}

C++实现：

void print(int a[], int n){
	for(int j= 0; j<n; j++){
		cout<<a[j] <<"  ";
	}
	cout<<endl;
}



/**
 * 已知H[s…m]除了H[s] 外均满足堆的定义
 * 调整H[s],使其成为大顶堆.即将对第s个结点为根的子树筛选, 
 *
 * @param H是待调整的堆数组
 * @param s是待调整的数组元素的位置
 * @param length是数组的长度
 *
 */
void HeapAdjust(int H[],int s, int length)
{
	int tmp  = H[s];
	int child = 2*s+1; //左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置)
    while (child < length) {
		if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)
			++child ;
		}
		if(H[s]<H[child]) {  // 如果较大的子结点大于父结点
			H[s] = H[child]; // 那么把较大的子结点往上移动，替换它的父结点
			s = child;		 // 重新设置s ,即待调整的下一个结点的位置
			child = 2*s+1;
		}  else {			 // 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出
			 break;
		}
		H[s] = tmp;			// 当前待调整的结点放到比其大的孩子结点位置上
	}
	print(H,length);
}


/**
 * 初始堆进行调整
 * 将H[0..length-1]建成堆
 * 调整完之后第一个元素是序列的最小的元素
 */
void BuildingHeap(int H[], int length)
{ 
	//最后一个有孩子的节点的位置 i=  (length -1) / 2
	for (int i = (length -1) / 2 ; i >= 0; --i)
		HeapAdjust(H,i,length);
}
/**
 * 堆排序算法
 */
void HeapSort(int H[],int length)
{
    //初始堆
	BuildingHeap(H, length);
	//从最后一个元素开始对序列进行调整
	for (int i = length - 1; i > 0; --i)
	{
		//交换堆顶元素H[0]和堆中最后一个元素
		int temp = H[i]; H[i] = H[0]; H[0] = temp;
		//每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整
		HeapAdjust(H,0,i);
  }
} 

int main(){
	int H[10] = {3,1,5,7,2,4,9,6,10,8};
	cout<<"初始值：";
	print(H,10);
	HeapSort(H,10);
	//selectSort(a, 8);
	cout<<"结果：";
	print(H,10);

}