用队列对扑克牌排序

总时间限制:

1000ms

内存限制:

65536kB

描述

假设这里有36张扑克牌，分别为A1~A9,B1~B9,C1~C9,D1~D9，其中A代表方片，B代表草花，C代表红桃，D代表黑桃，那么，设定如下的排序规则：

1.对于两张卡牌，X1Y1与X2Y2，X1与X2表示A～D，Y1与Y2表示1～9，如果X1与X2不同，那么依照D>C>B>A的方式进行排序

2.假如有X1与X2相同时，那么就比较Y1与Y2的大小。

例如，对于如下的四张牌，有如下的升序排序结果：

D3，C4，A4，C1

升序排序的结果为A4，C1，C4，D3

有人提出了如下的排序策略：

先建立9个队列，用于存放点数的大小，将卡牌依点数存放入各自的队列之中，然后再按队列1到队列9依次出队。

例如，对于上面的结果，依次进队后，结果如下：

队列1：C1；队列3：D3，队列4：C4，A4

将其依次出队后，结果为C1，D3，C4，A4

然后，再建立4个队列，用于存放花色。将卡牌依花色A～D存放入队列1～4中，然后再按队列1到队列4依次出队。

例如，对于上面刚刚出队的序列C1，D3，C4，A4，将其依次进队，结果如下：

队列1：A4；队列3：C1，C4；队列4：D3

将其依次出队后，结果为A4，C1，C4，D3，排序结束。

 

请根据上面的算法，编写一个用队列对扑克牌排序的程序，要求依照上面的排序规则，根据先花色后点数的方法进行排序。

 

输入

输入分为两行，第一行为一个整数n，表示一共有n张牌（1<=n<=100）
第二行用XY的形式表示每一张牌，其中X为A～D，Y为1～9

输出

输出三个部分
第一个部分为第一次进队出队的结果，用Queue1:...表示，共9行，结果用空格分隔，下同
第二部分为第二次进队出队的结果，用QueueA:...表示，共4行
第三部分为一行，即将卡牌排序后的结果（升序排序）

样例输入

8
D8 A6 C3 B8 C5 A1 B5 D3

样例输出

Queue1:A1
Queue2:
Queue3:C3 D3
Queue4:
Queue5:C5 B5
Queue6:A6
Queue7:
Queue8:D8 B8
Queue9:
QueueA:A1 A6
QueueB:B5 B8
QueueC:C3 C5
QueueD:D3 D8
A1 A6 B5 B8 C3 C5 D3 D8

这个题目我选择用Java写，自己构建一个队列，写个比较方法然后进行操作。没想到一次就ac了。

 

package dsa;

import java.util.Scanner;
/**
 * 
 * @author tanlvxu
 *
 */
public class Demo17 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
       new Demo17().test() ;
	}
    public void test()
    {   
    	Queue qe[] = new Queue[13] ;
    	Scanner sc = new Scanner(System.in) ;
    	int n = sc.nextInt() ;
    	int i,t ;
    	String str[] = new String[n] ;
    	for(i=0;i<13;i++)
    		qe[i] = new Queue() ;
    	for( i=0;i<n;i++)
    	{	
    	   str[i] = sc.next() ;
       	}
    	
    	for(i=0;i<n;i++)
    	{  
    	    t = str[i].charAt(1) - '1' ;
    	  //  System.out.println(t) ;
       	    qe[t].add(str[i]) ;
    		
    	}
    	for(i=0;i<9;i++)
    	{
    		int t1 = qe[i].getLength() ;
    		System.out.print("Queue"+(i+1)+":");
    		for(int j=0;j<t1;j++)
    	    System.out.print(qe[i].query(j)+" ") ;
    		System.out.println() ;
    	}
    	swap(str) ;
    	for(i=0;i<n;i++)
    	{
    	   t = str[i].charAt(0) - 'A' +9;
    	   qe[t].add(str[i]) ;
    	}
//    	for( i=0;i<n;i++)
//    	{	
//    		System.out.println(str[i]) ;
//       	}
    	char c = 'A' ;
    	for(i=9;i<13;i++)
    	{
    		int t1 = qe[i].getLength() ;
    		
    		System.out.print("Queue"+c+":");
    		for(int j=0;j<t1;j++)
    	    System.out.print(qe[i].query(j)+" ") ;
    		System.out.println() ;
    		c = (char)((int)c+1) ;
    	}
    	for(i=9;i<13;i++)
    	{
    		int t1 = qe[i].getLength() ;
    		
    	
    		for(int j=0;j<t1;j++)
    			System.out.print(qe[i].query(j)+" ") ;
        }
    	 System.out.println();
    	
    }
    /**
     * 交换方法
     * @param str
     */
    public void swap(String str[])
    {
    	int i,j ;
    	for(i=0;i<str.length-1;i++)
    	for(j=i+1;j<str.length;j++)
    	{
    		if(str[i].charAt(0)-str[j].charAt(0)>0)
    		{
    			String s = str[j] ;
    			str[j] = str[i] ;
    			str[i] = s ;
    		}else if(str[i].charAt(0)-str[j].charAt(0)==0&&str[i].charAt(1)-str[j].charAt(1)>0)
    		{
    			String s = str[j] ;
    			str[j] = str[i] ;
    			str[i] = s ;
    		}
    	}
    }
    /**
     * 数组实现队列
     * @author tanlvxu
     *
     */
    class Queue
    {
    	String a[] = new String[0] ;  //数组
    	int index = 0 ;  //标记第一个空余位置
    	/**
    	 * 增加一个元素
    	 */
    	public void add(String i){
    		//新建一个数组，长度是原数组长度+1；
    		String b[] = new String[a.length+1] ;
    		//将要加入的对象放入新数组的最后一位置
    		b[a.length] = i ;
    		//将原数组中的东西放到新数组中；
    		for(int j=0;j<a.length;j++){
    			b[j] = a[j] ;
    		}
    		//指向新建的数组
    		a = b ;
    		index ++ ;
    	}
    	/**
    	 * 指定位置，删除一个元素
    	 */	
    	public void del(int i){
    	if( i<0 || i>a.length){
    		throw new IllegalArgumentException("下标越界:"+index+",size:"+a.length) ;
    	}
    	String b[] = new String[a.length-1] ;
    	for(int j=0;j<a.length-1;j++){
    		
    		if(j>=i){
    			b[j]=a[j+1];
    		}else{
    		b[j] = a[j] ;
    		}
    	}
    	 a =b ;
    	 index -- ;
    	}
    	/**
    	 * 查找
    	 */
    	public String query(int i){
    		String b = a[i];
    		return b ;
    	//	System.out.print("你查找的元素为："+ b);
    	}
        /**
         * 得到队列的长度
         */
        public int getLength()
        {
        	 return index ;
        }
    }
}

 

 

用G++实现：

 

#include<iostream>
#include<cstring>
using namespace std;
char cp[101][3] ;
int n ;
void swap()
{
 for(int i=0;i<n-1;i++)
    for(int j=i+1;j<n;j++)
 {
     if(cp[i][0]>cp[j][0])
     {
         char c[3] ;
         strcpy(c,cp[i]);
         strcpy(cp[i],cp[j]);
         strcpy(cp[j],c);
     }else if(cp[i][0]==cp[j][0]&&cp[i][1]>cp[j][1])
     {
         char c[3] ;
         strcpy(c,cp[i]);
         strcpy(cp[i],cp[j]);
         strcpy(cp[j],c);
     }
 }
}
class Queue{
  int index  ;
  public :
     Queue();
    ~Queue();
    char ch[101][3] ;
    void add(char c[3]) ;
    int getLength();
};
Queue::Queue()
{
    index = 0;
}
Queue::~Queue(){};
void Queue::add(char c[3])
{
  strcpy(ch[index],c) ;
   index ++ ;
}
int Queue::getLength()
{
   return index ;

}
int main()
{
    int i,t ;
    cin>>n ;
    for(i=0;i<n;i++)
     {
         cin>>cp[i];
     }
     Queue qe[13] ;
    for(i=0;i<n;i++)
    {
      t = cp[i][1] -'1' ;
      qe[t].add(cp[i]) ;

    }
    for(i=0;i<9;i++)
    {
        cout<<"Queue"<<(i+1)<<":" ;
       t = qe[i].getLength() ;
        for(int j=0;j<t;j++)
         cout<<qe[i].ch[j]<<" " ;
        cout<<endl ;
    }
    swap();
    for(i=0;i<n;i++)
    {
       t = cp[i][0] -'A'+9 ;
       qe[t].add(cp[i]) ;
    }
    char c = 'A' ;
     for(i=9;i<13;i++)
    {
        cout<<"Queue"<<c<<":" ;
       t = qe[i].getLength() ;
        for(int j=0;j<t;j++)
         cout<<qe[i].ch[j]<<" " ;
        cout<<endl ;
        c = (char)((int)c +1) ;
    }
    for(i=0;i<n;i++)
        cout<<cp[i]<<" " ;
    cout<<endl ;
}