/**
*前面七大排序为Kotlin,基数排序为java,在最后面
*/
fun main(array: Array<String>){
val a = intArrayOf(2,5,3,7,9,8,1,6,4)
println("插入排序:")
insertSort(a).forEach {
println(it)
}
println("冒泡排序:")
bubbleSort(a).forEach {
println(it)
}
println("选择排序:")
selectedSort(a).forEach {
println(it)
}
println("希尔排序:")
shellSort(a).forEach {
println(it)
}
println("快速排序:")
quickSort1(a,0,a.size-1).forEach {
println(it)
}
println("归并排序")
mergeSort(a,0,a.size-1).forEach {
println(it)
}
println("堆排序")
heapSort(a).forEach {
println(it)
}
}
/**
* 插入排序
*/
fun insertSort(s: IntArray): IntArray{
for(i in 1..(s.size-1)){
var temp = s[i]
var j = i-1
while (j >= 0 && temp<s[j]){
s[j+1] = s[j]
j--
}
s[j+1] = temp
}
return s
}
/**
* 快速排序注意i 永远 不会等于 j,最后只会大于,即交叉
* 两种情况i=j,即数组所有元素相同,还有length=2
*/
fun quickSort1(s: IntArray,left: Int,right: Int): IntArray{
if(right-left==0){
return s
}
val base = s[left]
var i=left+1
var j=right
while(i<j){
while(s[i] <= base && i<j){
i++
}
while(s[j] > base && i<j){
j--
}
if(i<j){
val temp = s[i]
s[i] = s[j]
s[j] = temp
}
}
if(s[left]>s[j]){
val temp = s[left]
s[left] = s[j]
s[j] = temp
}
quickSort1(s,left,j-1)
if (j<right) quickSort1(s,j+1,right)
return s
}
/**
*希尔排序
*/
fun shellSort(s: IntArray): IntArray{
var n=s.size/2
while(n>=1){
for( j in n..(s.size-1) step n){
val temp = s[j]
var k = j-n
while(k>=0 && s[k]>temp){
s[k+n] = s[k]
k -= n
}
s[k+n] = temp
}
n/=2
}
return s
}
/**
* 选择排序
*/
fun selectedSort(s: IntArray): IntArray{
for(i in 0..(s.size-2)){
var index = i
for( j in i+1..(s.size-1)){
if(s[i] > s[j]){
index = j
}
}
if(index!=i){
val temp = s[i]
s[i] = s[index]
s[index] = temp
}
}
return s
}
/**
* 冒泡排序
*/
fun bubbleSort(s: IntArray):IntArray{
for (i in 0..(s.size-2)){
for(j in 0..(s.size-2-i)){
if(s[j] > s[j+1]){
val temp = s[j]
s[j] = s[j+1]
s[j+1] = temp
}
}
}
return s
}
/**
* 归并排序
*/
fun mergeSort(array: IntArray,start: Int,end: Int): IntArray{
if(start==end) return array
val mid=(start+end)/2
mergeSort(array,start,mid)
mergeSort(array,mid+1,end)
merge(array,start,mid,end)
return array
}
fun merge(array: IntArray,start: Int,mid: Int,end: Int){
val left = array.sliceArray(start..mid)
val right = array.sliceArray(mid+1..end)
var i=0
var j=0
for (k in start..end){
if(i==left.size){
array[k] = right[j]
j++
}else if(j==right.size){
array[k] = left[i]
i++
}else{
if(left[i]>right[j]){
array[k] = right[j]
j++
}else{
array[k] = left[i]
i++
}
}
}
}
/**
* 堆排序
*/
fun heapSort(array: IntArray): IntArray{
var end = array.size-1
initHeap(array,array.size)
swap(array,0,end)
while(end>0){
//adjustHeap(array,--end,0)
adjustHeap2(array,--end,0)
swap(array,0,end)
}
return array
}
/**
* 堆排序堆化
*/
fun initHeap(array: IntArray,length: Int): IntArray{
if(length==1) return array
val m = length/2-1
for (k in m downTo 0 ){
// adjustHeap(array,array.size-1,k)
adjustHeap2(array,array.size-1,k)
}
return array
}
/**
* 堆排序递归调整
*/
fun adjustHeap(array: IntArray,end: Int,index: Int){
val i = index
var j = 2 * i + 1
if (j >=end+1) return
if (j+1<end+1 && array[j]<array[j+1]) j++
if (array[j]>array[i]){
swap(array,i,j)
adjustHeap(array,end,j)
}
}
/**
* 迭代调整
*/
fun adjustHeap2(array: IntArray,end: Int,index: Int){
var i = index
var j = 2*i +1
while(j<end+1){
if(j+1<end+1 && array[j]<array[j+1]) j++
if(array[j]>array[i]){
swap(array,i,j)
i = j
j = 2*i+1
}else{
break
}
}
}
fun swap(array: IntArray,i: Int,j:Int){
val temp = array[i]
array[i] = array[j]
array[j] = temp
}
##基数排序:Java
/**
* 基数排序
* 先分配到桶里面,再回收,再重置计数
* 重复d次,d为最大数的长度
* @author Shinelon
*
*/
public class RadixSort {
public static void main(String [] args) {
int [] array = {5,21,66,9512,152,477,888};
RadixSort radix = new RadixSort();
radix.executeRadixSort(array);
for(int i=0;i<array.length;i++) System.out.println(array[i]);
}
public void executeRadixSort(int [] array) {
//每个桶存放的数的数量,初始化为0
int [] count = new int[10];
//所有桶的容量
int [][] store = new int[10][array.length];
//找出最大值
int temp = 0;
for(int i=0;i<array.length;i++) {
if(array[i]>temp) {
temp = array[i];
}
}
//d为最大长度
int d = Integer.valueOf(temp).toString().length();
for(int x=0;x<d;x++) {
//开始分配行为
for(int k=0;k<array.length;k++) {
int g = getNumber(array[k],x);
store[g][count[g]] = array[k];
count[g]++;
}
//开始回收行为
int n = 0;
for(int j=0;j<10;j++) {
for(int k=0;k<count[j];k++) {
array[n] = store[j][k];
n++;
}
//重置本行的计数
count[j]=0;
}
}
}
public int getNumber(int num,int q){
int t = (int)Math.pow(10, q);
int s =num/t%10;
return s;
}
}
Basic Algorithms (1) - Implementation of Kotlin by Eight Sorting Algorithms
Guess you like
Origin http://43.154.161.224:23101/article/api/json?id=325683158&siteId=291194637
Ranking