如何使用向量实现Bubblesort

Question

我在使该程序正常工作方面遇到了一些严重的麻烦。 我知道我的问题不是很具体，但我不知道该去哪里。 到目前为止，这就是我所拥有的。 插入，调整大小，擦除，查找和清空所有文件都可以。 重载的输出运算符和排序功能均已损坏。 必须以这种方式设置程序，因为这就是分配的内容。

主要测试程序：

#include <iostream>
#include "UList.h"
#include "sortBS.h"
#include <vector>

using namespace std;

int main(){
    UList<size_t> list1(20), list2;

    cout<<list1.size()<<endl;
    cout<<list2.size()<<endl;
    list1.insert(3);
    list1.insert(5);
    list1.insert(4);
    list1.erase(4);
    cout<<list1.find(3)<<endl;
    cout<<list1.find(4)<<endl;
    cout<<list1.empty()<<endl;
    cout<<list2.empty()<<endl;
    sort(list1);
    cout<<list1<<endl;
    //sort
    //<<

}

UList.h

#ifndef UList__H
#define UList__H
#include <iostream>
#include <vector>
#include "sortBS.h"
template <class T>
class UList{
public:
    UList(size_t=10);
    void insert(const T&);
    bool erase(const T&);
    bool find(const T&);
    size_t size() const;
    bool empty() const;
    friend void sort (UList<T>&);
    friend std::ostream& operator << (std::ostream&, const UList<T>&);

protected:
    std::vector<T> items;
};

template <class T>
UList<T>::UList(size_t size){
    items.resize(size);
}

template <class T>
void UList<T>::insert(const T& element){
    items.insert(items.begin(), element);
}

template <class T>
bool UList<T>::erase(const T& element){
    for(size_t index=0; index<items.size(); index++){
        if(element==items.at(index))
            items.erase(items.begin()+index);
            return true;
    }
    return false;
}

template <class T>
bool UList<T>::find(const T& element){
    bool found=false;
    size_t index=0;
    while(index<items.size()){
        if(items.at(index)==element)
            found=true;
        index++;
    }
    return found;
}

template <class T>
size_t UList<T>::size() const{
    return items.size();
}

template <class T>
bool UList<T>::empty() const{
    return items.empty();
}

template<class T>
std::ostream& operator << (std::ostream& out, const UList<T>& List){
    if(List.items.empty())
        out<<"list is empty."<<std::endl;
    else{
        for(size_t index=0;index<List.items.size();index++){
            out<<List.items.at(index);
            if(index<List.items.size()-1)
                out<<" ";
        }
    }
    return out;
}

template<class T>
void sort(UList<T>& List){
    sortBS(List);
}

#endif

sortBS.h

#ifndef sortBS__H
#define sortBS__H
#include <iostream>
#include <vector>
#include "UList.h"

template <class T>
void sortBS(UList<T> List){
    for(size_t iteration=1;iteration<items.size();iteration++){
        for(size_t index=0;index<items.size()-iteration;index++){
            if(items.at(index)>items.at(index+1)){
                T temp = items.at(index);
                items.at(index) = items.at(index+1);
                items.at(index+1) = temp;
            }
        }
    }    
}

#endif // sortBS__H

错误

  ||=== Build: Debug in Program04 (compiler: GNU GCC Compiler) ===|
  G:\Program04\sortBS.h|8|error: variable or field 'sortBS' declared void|
  G:\Program04\sortBS.h|8|error: 'UList' was not declared in this scope|
  G:\Program04\sortBS.h|8|error: expected primary-expression before '>' token|
  G:\Program04\sortBS.h|8|error: 'List' was not declared in this scope|
  G:\Program04\UList.h|15|warning: friend declaration 'void sort(UList<T>&)' declares a                 non-template function [-Wnon-template-friend]|
  G:\Program04\UList.h|15|note: (if this is not what you intended, make sure the    function     template has already been declared and add <> after the function name here) |
  G:\Program04\UList.h|16|warning: friend declaration 'std::ostream&    operator<<(std::ostream&, const UList<T>&)' declares a non-template function [-Wnon-    template-friend]|
 ||=== Build failed: 4 error(s), 2 warning(s) (0 minute(s), 0 second(s)) ===|

这是创建程序的规范（这位老师非常模糊，丝毫没有帮助，所以我不能向他寻求帮助（尝试过多次））

对于此分配，您将创建一个独立的函数sort，该函数采用UList参数，并使用Bubble Sort算法对其进行排序。 该排序功能将放置在名为sortBS.h的文件中，而UList应在名为UList.h的文件中。 下面给出了UList的UML图：

UList<T>
#items: vector<T>
+UList(size_t=10)
+insert(const T&): void
+erase(const T&): bool
+find(const T&) const: bool
+size() const: size_t
+empty() const: bool
+friend operator << (ostream&, const UList<T>&): ostream&
+friend sort (UList<T>&): void
Submit sortBS.h and UList.h prior to the due date/time using the following form (I will        be using my own driver file for grading purposes): 

Answer 1

这是我可以找到的问题：

• 不要在UList.h中包含sortBS.h。 UList不需要sortBS存在（没有它就可以正常工作），因此不应这样包含它。 另外，由于在定义实际UList之前已包含该文件，因此会出现错误，提示sortBS不知道UList是什么。

• sortBS声明了一个名为List的变量，然后不使用它，并尝试使用一个不存在的名为“ items”的变量。 重命名其中一个以匹配另一个。

• sortBS的最后一部分可以简化为：

  如果（items [index]> items [index + 1]）std :: swap（items [index]，items [index + 1]）;

Answer 2

首先，不需要sortBS() ，因为您只需将sort()声明为类UList的朋友UList 。

在您的UList类中，请使用以下代码：

template< typename C >
friend void sort (UList<C>&);
template< typename C>
friend std::ostream& operator << (std::ostream&, const UList<C>&);

但是在sort函数中，存在一个错误：您不能直接访问items ，请执行vector<T> items(List.items);

template< typename T>
void sort(UList<T>& List){
    vector<T> items(List.items);
    for(size_t iteration=1;iteration<items.size();iteration++){
        for(size_t index=0;index<items.size()-iteration;index++){
            if(items.at(index)>items.at(index+1)){
                T temp = items.at(index);
                items.at(index) = items.at(index+1);
                items.at(index+1) = temp;
            }
        }
    } 
}

如果您只想使用friend void sort (UList<T>&); ，应将函数sort的定义代码放入类UList ，如下所示：

template <class T>
class UList{
public:
    UList(size_t=10);
    void insert(const T&);
    bool erase(const T&);
    bool find(const T&);
    size_t size() const;
    bool empty() const;
    friend void sort (UList<T>& List)
    {
        vector<T> items(List.items);
        for(size_t iteration=1;iteration<items.size();iteration++){
            for(size_t index=0;index<items.size()-iteration;index++){
                if(items.at(index)>items.at(index+1)){
                    T temp = items.at(index);
                    items.at(index) = items.at(index+1);
                    items.at(index+1) = temp;
                }
            }
        } 
    }
    template< typename C>
    friend std::ostream& operator << (std::ostream&, const UList<C>&);

protected:
    std::vector<T> items;
};