数据结构之排序算法整理（3）

选择排序

1.直接选择排序

package com.SelectSort;

import java.util.Arrays;

/**
 * 选择排序中的直接选择排序
 * 直接选择排序，对于n个元素，需要经过n-1此比较。
 * 基本思想：
 * 第1趟比较：程序将记录定位在第一个数据上，拿第一个数据依次和其后面的元素比较，如果第一个元素比后面的某个元素大(或者小)，交换两个位置上元素，依次类推。经过第一次比较，这组数据中最小的元素被选出，被排列在第一位；
 * 第2趟比较：程序将记录定位在第二个数据上，拿第二个数据依次和其后面的元素比较，如果第一个元素比后面的某个元素大(或者小)，交换两个位置上元素，依次类推。经过第一次比较，这组数据中最小的元素被选出，被排列在第二位；
 *	……
 * 第n-1趟比较：……
 * 按照这个规则一共进行n-1次比较。
 * 优点：实现简单；缺点：每次只能确定一个元素
 * 补充：1.运行时间和输入无关；（一组随机数和排序好的数运行时间是一样的）；2.数据移动是最少的。
 * 其复杂度是O(n*n)，稳定性：不稳定；空间消：O(1)。
 * @author lenovo
 *
 */
public class SelectSort {
	public static void selectSort(int[] datas){
		for(int i = 0;i < datas.length - 1;i++){
			for(int j = i+1;j < datas.length;j++){
				//可以实现Comparable接口来实现对象的比较  
				if(datas[i] > datas[j]){
					int temp = datas[i];
					datas[i] = datas[j];
					datas[j] = temp;
				}
			}
			System.out.println(Arrays.toString(datas));
		}
	}
	
	public static void main(String[] args){
		int[] array = {22,30,49,30,16,9};
		SelectSort.selectSort(array);
		System.out.println(Arrays.toString(array));
		
	}
}

直接选择排序的性能上还是要略优于冒泡排序。

2.堆排序

package com.HeapSort;

public class Heap {
	private int[] heap;
	private int heapsize;
	public Heap(int[] array){
		this.heap = array;
		this.heapsize = heap.length;
	}
	public void BuildMaxHeap(){
		for(int i = heapsize/2 - 1;i >= 0;i--){
			Maxify(i);//依次向上将当前子树最大堆化
		}
	}
	public void HeapSort(){
		for(int i = 0;i < heap.length;i++){
			//执行n次，将每个当前最大的值放到堆末尾
			int tmp = heap[0];
			heap[0] = heap[heapsize - 1];
			heap[heapsize - 1] = tmp;
			heapsize--;
			Maxify(0);
		}
	}
	
	public void Maxify(int i){
		int l = Left(i);
		int r = Right(i);
		int largest;
		if(l < heapsize && heap[l] > heap[i]){
			largest = l;
		}else{
			largest = i;
		}
		if(r < heapsize && heap[r] > heap[largest]){
			largest = r;
		}
		//如果largest等于i说明i是最大元素 largest超出heap范围说明不存在
		//比i节点大的子女
		if(largest == i || largest >= heapsize){
			return;
		}
		int tmp = heap[i];
		heap[i] = heap[largest];
		heap[largest] = tmp;
		Maxify(largest);
	}
	
	
	public void IncreaseValue(int i,int val){
		heap[i] = val;
		if(i >= heapsize || i <= 0 || heap[i] >= val){
			return;
		}
		int p = Parent(i);
		if(heap[p] >= val)
			return;
		heap[i] = heap[p];
		IncreaseValue(p,val);
	}
	
	private int Parent(int i){
		return (i-1)/2;
	}
	
	private int Left(int i){
		return 2*(i+1) - 1;
	}
	
	private int Right(int i){
		return 2*(i+1);
	}
	
	//测试
	public static void main(String[] args){
		int[] array = new int[]{1,2,3,4,7,8,9,10,14,16};
		Heap MaxHeap = new Heap(array);
		System.out.println("执行最大堆化前堆的结构：");
		printHeapTree(MaxHeap.heap);
		MaxHeap.BuildMaxHeap();
		System.out.println("执行最大堆化后堆的结构：");
		printHeapTree(MaxHeap.heap);
		MaxHeap.HeapSort();
		System.out.println("执行堆排序后数组的内容：");
		printHeap(MaxHeap.heap);
	}
	
	public static void printHeapTree(int[] array){
		for(int i = 1;i<array.length;i=i*2){
				for(int k = i - 1;k <2*(i) - 1 && k < array.length;k++){
					System.out.print(array[k]+" ");
				}
				System.out.println();
		}
	}
	
	public static void printHeap(int[] array){
		for(int i = 0;i < array.length;i++){
			System.out.print(array[i]+" ");
		}
	}
}