LeetCode上Largest Number

public class Solution {
    //思路
    //先使用transfer函数   将int数组转为Node型数组  一个Node里面存储一个char类型  把每个int型每一位都变为char类型 
    //如1402  则变为 '1'->'4'->'0'->'2'
    //现在则数组transfer成如下的样子
    //  myNode[0]-->'3'   
    //  myNode[1]-->'3'-->'0'  
    //  myNode[2]-->'3'-->'4'  
    //  myNode[3]-->'5'  
    //  myNode[3]-->'9' 
    
    //然后对这个数组进行快速排序
    
    
    //现在的关键就是快速排序两个数的大小如何定义？
    //所以设计compare函数比较 myNode[i]  myNode[j]
    //比较方式是： 都从头指针数据开始比  相同则同时向后
    
    //如果数字完全相同，直到其中一个到结尾 另一个后面还有数字怎么办？  
    //如  384    38447   
    //那么取38447的头指针和 刚刚的指针（38447现在已经走到4的指针）  再循环上一步的比较即
    //       38447(取头指针)
    // 384   47 (38447现在已经走到4的指针)  
    //比较方式同上      
    //如果依然走到底  如
    //      38438438
    // 384  38438         
    //此时则应该取上面多的数4  与这一串数字的开头比较（即3）  这样得出大小关系
    
    public static String largestNumber(int[] num) {
        
    	Node[] myNode=new Node[num.length];
    	transfer(myNode,num);
    	
    	if(num.length==0)  		return "";
    	quickSort(myNode,0,myNode.length-1);
    	StringBuffer result=new StringBuffer();
    	for(int i=0;i<myNode.length;i++){
    		while(myNode[i]!=null){
    			result.append(myNode[i].num);
    			myNode[i]=myNode[i].next;
    		}
    	}
    	
    	//记录字符串开头有几个0
    	int z=0;
    	for(int k=0;k<result.length();k++){
    		if(result.charAt(k)=='0')
    			z++;
    		else
    			break;
    	}
    	if(z>1){
    		result.delete(0, z-1);
    	}
		
    	return result.toString();
    }

	private static void transfer(Node[] myNode, int[] num) {
		// TODO Auto-generated method stub
		
		for(int i=0;i<num.length;i++){
			int temp=num[i];
			//进行除法剩下的数
			int a=0;
			//进行取余剩下的数
			int b=0;
			do{
				b=temp%10;
				Node newNode=new Node((char)(b+'0'));
				//头插法
				Node tempNode=myNode[i];
				myNode[i]=newNode;
				newNode.next=tempNode;
			}while((temp=temp/10)>0);
		}
	}

	private static void quickSort(Node[] myNode,int left,int right) {
		// TODO Auto-generated method stub
		if(left>=right)		return ;

		int place=findPlace(myNode,left,right);
		quickSort(myNode,left,place-1);
		quickSort(myNode,place+1,right);
	}

	private static int findPlace(Node[] myNode, int left, int right) {
		// TODO Auto-generated method stub
		int i=left;
		int j=left+1;
		
		for(;j<=right;j++){
			if(compare(myNode,left,j)){
				i++;
				swap(myNode,i,j);
				continue;
			}
		}
		swap(myNode,left,i);
		return i;
	}

	private static void swap(Node[] myNode, int i, int j) {
		// TODO Auto-generated method stub
		Node temp=myNode[i];
		myNode[i]=myNode[j];
		myNode[j]=temp;
	}

	//因为要逆序     i大的  返回false
	private static boolean compare(Node[] myNode, int i, int j) {
		// TODO Auto-generated method stub

		Node node1=myNode[i];
		Node node2=myNode[j];
	
		while(node1!=null&&node2!=null){
			if(node1.num>node2.num)
				return false;
			else if(node1.num<node2.num)
				return true;
			else if(node1.num==node2.num){
				node1=node1.next;
				node2=node2.next;
			}
		}

		if(node1!=null)	{
			Node tempN=myNode[i];
			while(node1!=null){
				if(node1.num>tempN.num)
					return false;
				else if(node1.num<tempN.num)
					return true;
				else if(node1.num==tempN.num){
					node1=node1.next;
					tempN=tempN.next;
				}
			}
			if(tempN.num>myNode[i].num)
				return true;
			else
				return false;
		}
			
		if(node2!=null){
			Node tempN=myNode[j];
			while(node2!=null){
				if(node2.num>tempN.num)
					return true;
				else if(node2.num<tempN.num)
					return false;
				else if(node2.num==tempN.num){
					node2=node2.next;
					tempN=tempN.next;
				}
			}
			if(tempN.num>myNode[j].num)
				return false;
			else
				return true;
		}

		return false;
	}
}


class Node{
	public Node(char b) {
		// TODO Auto-generated constructor stub
		num=b;
	}
	char num;
	Node next;
}

后来查资料看到其他博客中也有使用拼接两个数A和B    然后比价AB和BA大小关系从而得到A与B的大小关系的   那种方式可能更加巧妙

我的方式比较原始，有问题的地方还望大家批评指正