C++、C#、java算法学习日记07----堆排序（HeapSort）

       根据上一篇 堆排序思想   这一篇我们用C++、C#、java 代码来实现它，要求对10000个随机数进行升序排列。

C++实例：

#include<iostream>
#include<vector>
#include<ctime>

using namespace std;
//调整堆
void HeapAdjust(vector<int> &array,int i,int nLength)
{
	int Child;
	for(;2*i+1<nLength;i=Child)
	{
		Child=2*i+1;  //左孩子下标 Child+1 右孩子下标
		if(Child+1<nLength&&array[Child]<array[Child+1])
		{  Child++;}
		if(array[i]<array[Child]) //保证父节点大于左右孩子
		{
			swap(array[i],array[Child]);
		}
		else
		{break;}
	}

}
//首尾交换再调整
void HeapSort(vector<int> &array,int Length)
{ 
	for(int i=(Length/2-1);i>=0;i--) //第一次调整为大根堆，需要对所有的节点都比较
	{
		HeapAdjust(array,i,Length);
	}
	for(int j=Length-1;j>0;j--)
	{
		swap(array[j],array[0]);//交换

		HeapAdjust(array,0,j); //不是第一次调整，只需要局部调整就行了
	}

}
void main()
{
	vector<int> array;
	clock_t start,end;
	for(int i=0;i<10000;i++) //将10000个数放入容器
	{
		array.push_back(rand());
	}
	int Length=array.size(); //计算长度
	start=clock();//开始时间

	HeapSort(array,Length); //堆排序
	end=clock();//结束时间
	//输出前十个数
	for(int i=0;i<10;i++)
	{
		cout<<array[i]<<"  ";
	}
	cout<<endl;
	cout<<"堆排序用时："<<end-start<<" 毫秒"<<endl;
}

结果：

C#实例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics; //要添加这个引用否则没有Stopwatch   

namespace HeapSort2
{
    class Sort
    { //调整堆
        public void HeapAdjust(List<int> array, int i, int nLength)
        {
            int Child, temp;
            for (; 2 * i + 1 < nLength; i = Child)
            {
                Child = 2 * i + 1;
                if (Child + 1 < nLength && array[Child + 1] > array[Child])
                { Child++; }
                if (array[i] < array[Child])
                {
                    temp = array[i];
                    array[i] = array[Child];
                    array[Child] = temp;
                }
                else
                { break; }

            }
        }
        //首尾交换再调整
        public void HeapSort(List<int> array)
        {
            int temp;
            for (int i = array.Count / 2 - 1; i >= 0; i--)
            {
                HeapAdjust(array, i, array.Count);
            }
            for (int j = array.Count - 1; j > 0; j--)
            {
                temp = array[0];
                array[0] = array[j];
                array[j] = temp;
                HeapAdjust(array, 0, j);
            }
        }
        static void Main(string[] args)
        {
            List<int> array = new List<int>();
            Random r = new Random();
            Stopwatch watch = new Stopwatch();
            for (int i = 0; i < 10000; i++)
            {
                array.Add(r.Next(1, 100000));
            }
            Console.WriteLine("排序前前十个元素为：" + String.Join(" ", array.Take(10).ToList()));
            Sort sorter = new Sort();
            watch.Start(); //开始计时
            sorter.HeapSort(array); //堆排序
            watch.Stop(); //结束计时
            Console.WriteLine("排序后前十个元素为：" + String.Join(" ", array.Take(10).ToList()));
            Console.WriteLine("堆排序用时：" + watch.ElapsedMilliseconds);
        }
    }
}

结果：

java实例：

package Sort;
import java.util.*;
public class Sort6 {
	public void HeapAdjust(List<Integer> array,int i,int nLength){
		int temp,Child;
		for(;2*i+1<nLength;i=Child){
			Child=2*i+1;
			if(Child+1<nLength&&array.get(Child)<array.get(Child+1)){
				Child++;
			}
			if(array.get(i)<array.get(Child)){
				temp=array.get(i);
				array.set(i, array.get(Child));
				array.set(Child, temp);
			}
			else{
				break;
			}
		}
		
	}
	public void HeapSort(List<Integer> array){
		int temp;
		for(int i=array.size()/2-1;i>=0;i--){
			HeapAdjust(array,i,array.size());
		}
		for(int j=array.size()-1;j>0;j--){
			temp=array.get(0);
			array.set(0,array.get(j));
			array.set(j, temp);
			HeapAdjust(array,0,j);
		}
	}

	public static void main(String[] args) {
		List<Integer> array = new ArrayList<Integer>();
		for(int i=0;i<10000;i++){
			array.add(new Random().nextInt(100000));
		}
		System.out.print("排序前前十个元素为：");
		for(int i=0;i<10;i++){
			System.out.print(array.get(i)+" ");
		}
		System.out.println();
		Sort6 sorter =new Sort6();
		long time_start=System.currentTimeMillis();//开始时间
		sorter.HeapSort(array);
		long time_stop=System.currentTimeMillis();//开始时间
		System.out.print("排序后前十个元素为：");
		for(int i=0;i<10;i++){
			System.out.print(/*i==0?"\n排序后前十个元素为：":" "+*/array.get(i)+" ");
		}
		System.out.print("\n"+"堆排序用时："+(time_stop-time_start));
		
	}

}

结果：

 

 

 

 

      堆排序就是如此了，有什么好的改进方法欢迎留言^_^