Java/Go实现——把正整数数组的元素拼成一个最小的数

转自几个面试经典算法题（http://www.cnblogs.com/sunniest/p/4596182.html）题目四

这个算法的思想和快速排序的思想相似。先把第一个元素p当作中间数，数组前后各有一个索引begin、end。先从后索引对应元素e起，如果ep>pe或e=p，那么后索引往前移动，直到后索引等于前索引，或ep<pe。交换e、p元素。再从前索引对应元素b起，如果pb>bp或b=p，那么前索引后移，直到前索引等于后索引或pb<bq，交换p、b。这时，“小于”p的都在p左边（这里小于的意思是，两个数a、b拼成一个数时，a小于b指ab<ba），“大于”p的都在p右边（这里大于的意思是，两个数a、b拼成一个数时，a大于b指ab>ba）。再对p的两边子数组各自进行递归处理。

//数组组成的最小数
import java.util.Arrays;

public class MinNumberFromArray {
	
	private void swap(int[] array , int m , int n){
		int t = array[m];
		array[m] = array[n];
		array[n] = t;
	}
	
	public boolean isMBiggerThanN(int m , int n){
		String s1 = String.valueOf(m);
		String s2 = String.valueOf(n);
		
		int i = Integer.valueOf(s1 + s2);
		int j = Integer.valueOf(s2 + s1);
		
		if(i > j){
			return true;
		}else{
			return false;
		}
	}
	
	public int partition(int[] array , int left , int right){
		int partition = array[left];
		while(left < right){
			while(left < right && (partition == array[right] ||  isMBiggerThanN(array[right] , partition))){
				right--;
			}
			swap(array , left , right);
			while(left < right && (partition == array[left] || isMBiggerThanN(partition , array[left]))){
				left++;
			}
			swap(array , left , right);
		}
		return left;
	}
	
	public void qsort(int[] array , int left , int right){
		if(left < right){
			int position = partition(array , left , right);
			qsort(array , left , position - 1);
			qsort(array , position + 1 , right);
		}
	}
	public static void main(String[] args) {
		MinNumberFromArray m = new MinNumberFromArray();
		int[] a = {2 , 11 , 5 , 52};
		m.qsort(a, 0, a.length - 1);
		System.out.println(Arrays.toString(a));
	}

}

Go语言

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var a = []int { 2, 3, 1, 6, 2, 5}
	quickSort(a, 0, len(a) - 1)
	for i := range a {
		fmt.Print(a[i])
	}
	fmt.Println()
}

func MBiggerThanN(m, n int) bool {
	if m == n {
		return false
	}

	sm := strconv.Itoa(m)
	sn := strconv.Itoa(n)
	s1 := sm + sn
	s2 := sn + sm

	i1, err1 := strconv.Atoi(s1)
	if err1 != nil {
		fmt.Println("first parameter transfer fails")
		return false
	}
	i2, err2 := strconv.Atoi(s2)
	if err2 != nil {
		fmt.Println("seconde parameter transfer fails")
		return false
	}

	if i1 > i2 {
		return true
	} else {
		return false
	}
}

func getPivotPosition(array []int, left int, right int) int {
	pivot := array[left]
	for left < right {
		for (left < right && (pivot == array[right] || MBiggerThanN(array[right], pivot))) {
			right--
		}
		array[left], array[right] = array[right], array[left]
		for (left < right && (pivot == array[left] || MBiggerThanN(pivot, array[left]))) {
			left++
		}
		array[left], array[right] = array[right], array[left]
	}
	array[left] = pivot
	return left
}

func quickSort(array []int, left int, right int ) {
	if left < right {
		position := getPivotPosition(array, left, right)
		quickSort(array, left, position - 1)
		quickSort(array, position + 1, right)
	}
}