模板类 template <class T> sort

Myth丶恋晨 2022-08-12 18:59 168阅读 0赞

模板类    template <class T>  
队列从中间开始（５）插入若干元素，并对其进行升序排列  
队列为循环队列,队列长度为１０

/********************************************
    模板类	template <class T>
    队列从中间开始（５）插入若干元素，并对其进行升序排列
    队列为循环队列,队列长度为１０
    ********************************************/
    #include <iostream>
    using namespace std;
    
    template <class T>
    class xqueue{
    public:
    	xqueue();
    	void enqueue(T item);
    	void sort(T *num, int len);
    	void print()const;
    	T *getdata(){	
    		return data;
    	}
    private:
    	T data[10];
    	int head;
    	int tail;
    };
    
    template <class T>
    //xqueue<T>::xqueue():head(5),tail(5){}
    xqueue<T>::xqueue()
    {
    	head = 5;
    	tail = 5;
    }
    
    template <class T>
    void xqueue<T>::enqueue(T item){
    	data[tail] = item;
    	tail = (tail +1)%10;
    }
    
    
    template <class T>
    void xqueue<T>::print()const{
    	for(int i = head; i != tail; i=(i+1)%10){
    		data[i].print();	
    	}
    }
    
    
    
    class RN{
    public:
    	RN(int _x, int _y);
    	bool operator >(RN rn)const;
    	void print()const;
    private:
    	int x;
    	int y; 	
    };
    RN::RN(int _x = 1, int _y = 1):x(_x),y(_y){}
    
    bool RN::operator>(RN rn)const{
    	return x/(double)y > rn.x/(double)rn.y;
    }
    void RN::print()const{
    	cout << x << "/" << y << endl;
    }
    
    
    class xpoint{
    public:
    	xpoint(int _x, int _y);
    	bool operator >(xpoint xp)const;
    	void print()const;
    private:
    	int x, y;
    };
    
    
    xpoint::xpoint(int _x = 0, int _y = 0):x(_x),y(_y){}
    
    bool xpoint::operator >(xpoint xp)const{
    //	return (x^2 + y^2) > (xp.x^2 + xp.y^2);　//错误
    	return (x^2) + (y^2) > (xp.x^2) + (xp.y^2);//ok
    //	return (x*x + y*y) > (xp.x*xp.x + xp.y*xp.y); //ok
    }
    
    void xpoint::print()const{
    	cout << "(" << x << "," << y << ")" << endl;
    }
    
    
    
    template <class T>
    void print_array(T *buf, int len)
    {
    	T tmp;
    	for(int i = 0; i < len; i++){
    		buf[i].print();
    	}
    }
    
    
    template <class T>
    void xqueue<T>::sort(T *num, int len)  
    {  
        int i, j;
    	T tmp;
        for(i = 0; i < len; i++){  
    //      for(j = 0; j < len - i - 1; j++){  
            for(j = head; j != (tail - 1) ; j = (j+1)%10){  //是　j != (tail - 1) 
                if(num[j] > num[(j + 1)%10]){   //注意是num[j] and num[j + 1]
                    tmp = num[(j + 1)%10];  
                    num[(j + 1)%10] = num[j];  
                    num[j] = tmp;  
                }  
        	}   
    	}  
    }
    #if 0
    template <class T>
    void sort(T *a, size_t len){
        T t;
        for(int i=0;i<len-1;i++) /* 冒泡法排序 */
            for(int j=0;j<len-i-1;j++)
                if(a[j]>a[j+1]) {
                    t=a[j];/* 交换a[i]和a[j] */
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
    }
    #endif
    
    int main(){
    	xqueue<RN> q1;
    	q1.enqueue(RN(1,2));
    	q1.enqueue(RN(4,2));
    	q1.enqueue(RN(4,2));
    	q1.enqueue(RN(1,2));
    	q1.enqueue(RN(8,3));
    	q1.enqueue(RN(8,3));
    	q1.sort(q1.getdata(),6);
    	q1.print();
    	cout << "----------------------" << endl;
    	xqueue<xpoint> q2;
    	q2.enqueue(xpoint(2,2));
    	q2.enqueue(xpoint(5,3));
    	q2.enqueue(xpoint(6,6));
    	q2.enqueue(xpoint(1,6));
    	q2.enqueue(xpoint(4,2));
    	q2.enqueue(xpoint(4,2));
    	q2.sort(q2.getdata(),6);
    	q2.print();
    
    }
    
    /*$ ./a.out 
    1/2
    1/2
    4/2
    4/2
    8/3
    8/3
    ----------------------
    (2,2)
    (4,2)
    (4,2)
    (1,6)
    (5,3)
    (6,6)
    */