n*log(3)n排序算法 初稿

 

在看文章之前,请先熟悉堆排序:http://blog.csdn.net/morewindows/article/details/6709644/

假如你熟悉了,那么现在讲的是一个和二叉堆排序同类算法,也是堆排序.只是形式上变化了一下, 还可以降低, 但是有个极限,极限其实是一个函数方程解，是深度和长度，设排序数量为n（n>k），采用k叉树排序（k>=2），深度为d有有关系式d=log（k）n，d*k+1<=n<=d*k+k，复杂度计算公式d*k，具体应该是log（k）2+log（k）3+...+log（k）n+（k-1）*log（k）n+...+（k-1）*log（k）2，表达式中的log都是向上取整可以对其合并求导，只剩一步求解了

以下是该树的性质:
1.	父节点都不小于子节点.
以下是推导出的性质
1.节点k的子孩子是3k+1,3k+2,3k+3

建树过程:
从根节点的第一个子节点开始.和父节点比较,如果父节点小于子节点,则交换.交换后若依然有父节点小于子节点,继续交换.依次对所有节点进行调整操作. 第一步log(3)2向上取整第二步是log(3)3向上取整…∑「log(3)k()」(k=1,…,n),可以推导出o(n)<n*log(3)n
排序过程:
取根节点,把最后一个子节点放入根节点,树不再满足原来的性质,若最大子节点大于父节点则交换.循环至树为空. 第一步3*log(3)k向上取整第二步是3*log(3)(k-1)向上取整…∑「log(3)k」(k=1,…,n),可以推导出o(n)<3n*log(3)n

package main

import (

"fmt"

 "math/rand"

"math"

)

const(

ARRAYLENTH=20

)

var array [ARRAYLENTH]int

var newArray [ARRAYLENTH]int

func  main(){

    for i:=0;i<ARRAYLENTH;i++{

        array[i]=rand.Intn(100)

    }

    fmt.Println("初始:")

    print()

    initArray()

    fmt.Println("建树后:")

    print

    sort()

    fmt.Println("排序后:")

    for i:=0;i<ARRAYLENTH;i++{

        fmt.Print("    ",newArray[i])

    }

}

func print( ){

    k:=1

    fmt.Println("")

    for i:=0;i<ARRAYLENTH;i++{

        fmt.Print(array[i],"   ")

    }

    fmt.Println("   ")

    for i:=0;i<ARRAYLENTH;i++{

        if i*2>=int(math.Pow(float64(3),float64(k-1))-1){

            fmt.Print("\n第",k,"层:")

            k++

        }

        fmt.Print(array[i],"   ")

    }

}

func initArray( ){

    for index:=1;index<ARRAYLENTH;index++{

        if array[index]>array[(index-1)/3]{

            createTreeAdjust(index)

        }

    }

}

func createTreeAdjust(index int){

    for ;index!=0;{

        if array[index]>array[(index-1)/3]{

            tmp:=array[index]

            array[index]=array[(index-1)/3]

            array[(index-1)/3]=tmp

        }else{

            return

        }

        index=(index-1)/3

    }

}

func sort( ){

    index:=0

    for count:=ARRAYLENTH;count>0;count--{

        newArray[index]=array[0]

        array[0]=array[count-1]

        sortAdjust(count-1)

        index++

    }

}

func sortAdjust(count int){

    if count==0{return}

    index:=0

     max:=0

    for ;3*index+3<count;{

        max=3*index+1

        if array[max]<array[3*index+2]{

            max=3*index+2

        }

        if array[max]<array[3*index+3]{

            max=3*index+3

        }

		if array[index]>array[max]{
			return
		}

        tmp:=array[index]

        array[index]=array[max]

        index=max

        array[index]=tmp

    }

    if index==count-1{return}

    if 3*index+2>count{return}

    max=count-1

    if array[max]<array[count-2]&&((count-3)/3==index){

        max=count-2

    }

    tmp:=array[index]

    array[index]=array[max]

    array[max]=tmp

}