堆排序--八大排序算法[java][c语言]

堆排序–八大排序算

堆排序动画演示

代码【java】【c语言】

java

package sort;

import java.util.Arrays;

public class HeapSort {

	public static void main(String[] args) {
		// TODO 要求将数组升序排序
		int arr[] = {4,6,8,5,7,1,9,10,3,2};
		heapSort(arr);
		
	}
	/**
	 * i 表示飞非叶子结点在数组中的索引
	 * length 表示对排序数组的长度 是在减少
	 * */
	/**功能：将i对应的非叶子结点的数调整成大顶堆 
	 * eg: {4,6,8,5,9} -》  i=1  -》  adjustHeap -》  {4,9,8,5,6}
	 * 再次  adjustHeap 将i= 0传入，得到{9,4,8,5,6} -》 {9,6,8,5,4}
	 * */
	public static void adjustHeap(int arr[],int i,int length) {
		int temp = arr[i];
		// k = i * 2 + 1 是i结点的左子节点
		for(int k = i * 2 + 1; k < length; k = k * 2 + 1) {
			if(k + 1<length&& arr[k]< arr[k+1]) {
				k++;//让k指向左右子节点的最大的一个
			}
			if(arr[k]> temp) {
				arr[i] = arr[k];
				i = k; //让i指向k以便循环比较
			}else {
				break;
			}
			
		}
		//当for循环结束后，我们已经将i为父节点的树最大值，放在最顶（局部）
		arr[i] = temp;//将temp放在调整后的位置
	}
	public static void heapSort(int arr[]) {
		int temp = 0;
		System.out.println("堆排序：");
		
//		adjustHeap(arr,1,arr.length);
//		System.out.println("第1次："+Arrays.toString(arr));
//		adjustHeap(arr,0,arr.length);
//		System.out.println("第2次："+Arrays.toString(arr));
		
		//完成我们最终代码
		//将无序序列构建成一个堆，根据升序降序需求选择大顶堆还是小顶堆
		for(int i = arr.length/2 - 1; i>= 0;i--) {
			adjustHeap(arr,i,arr.length);
		}
		/**
		 * 将栈顶元素与末尾元素交换，使得最大元素到数组末端
		 * 重新调整结构，使其满足堆定义，
		 * 然后继续交换栈顶元素和当前末尾元素，反复执行调整+交换步骤，直到整个序列有序*/
		for(int j = arr.length - 1;j> 0;j--) {
			//交换
			temp = arr[j];
			arr[j] = arr[0];
			arr[0] = temp;
			adjustHeap(arr,0,j);
		}
		System.out.println("数组："+Arrays.toString(arr));
	}
}

c语言

//声明全局变量，用于记录数组array的长度；
static int len;
    /**
     * 堆排序算法
     *
     * @param array
     * @return
     */
    public static int[] HeapSort(int[] array) {
        len = array.length;
        if (len < 1) return array;
        //1.构建一个最大堆
        buildMaxHeap(array);
        //2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆
        while (len > 0) {
            swap(array, 0, len - 1);
            len--;
            adjustHeap(array, 0);
        }
        return array;
    }
    /**
     * 建立最大堆
     *
     * @param array
     */
    public static void buildMaxHeap(int[] array) {
        //从最后一个非叶子节点开始向上构造最大堆
        for (int i = (len/2 - 1); i >= 0; i--) { //感谢 @让我发会呆 网友的提醒，此处应该为 i = (len/2 - 1) 
            adjustHeap(array, i);
        }
    }
    /**
     * 调整使之成为最大堆
     *
     * @param array
     * @param i
     */
    public static void adjustHeap(int[] array, int i) {
        int maxIndex = i;
        //如果有左子树，且左子树大于父节点，则将最大指针指向左子树
        if (i * 2 < len && array[i * 2] > array[maxIndex])
            maxIndex = i * 2;
        //如果有右子树，且右子树大于父节点，则将最大指针指向右子树
        if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex])
            maxIndex = i * 2 + 1;
        //如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
        if (maxIndex != i) {
            swap(array, maxIndex, i);
            adjustHeap(array, maxIndex);
        }
    }