為什么我的冒泡排不了序啊

#include <iostream>
#include<cmath>
using namespace std;

typedef int Rank; //秩
#define DEFAULT_CAPACITY  10 //默認的初始容量（實際應用中可設定為更大）

template <typename T> class Vector { //向量模板類
 protected:
Rank _size; int _capacity;  T* _elem; //規模、容量、資料區
void copyFrom(T const* A, Rank lo, Rank hi); //復制陣列區間A[lo, hi)
void expand(); //空間不足時擴容
void shrink(); //裝填因子過小時壓縮

Rank max(Rank lo, Rank hi); //選取最大元素
void selectionSort(Rank lo, Rank hi); //選擇排序演算法
void merge(Rank lo, Rank mi, Rank hi); //歸并演算法
void mergeSort(Rank lo, Rank hi); //歸并排序演算法
void heapSort(Rank lo, Rank hi); //堆排序（稍后結合完全堆講解）
Rank partition(Rank lo, Rank hi); //軸點構造演算法
void quickSort(Rank lo, Rank hi); //快速排序演算法
void shellSort(Rank lo, Rank hi); //希爾排序演算法
public:
// 建構式
Vector(int c = DEFAULT_CAPACITY, int s = 0, T v = 0) //容量為c、規模為s、所有元素初始為v
{ _elem = new T[_capacity = c]; for (_size = 0; _size < s; _elem[_size++] = v); } //s<=c
Vector(T const* A, Rank n) { copyFrom(A, 0, n); } //陣列整體復制
Vector(T const* A, Rank lo, Rank hi) { copyFrom(A, lo, hi); } //區間
Vector(Vector<T> const& V) { copyFrom(V._elem, 0, V._size); } //向量整體復制
Vector(Vector<T> const& V, Rank lo, Rank hi) { copyFrom(V._elem, lo, hi); } //區間
// 解構式
 ~Vector() { delete[] _elem; } //釋放內部空間
// 只讀訪問介面
Rank size() const { return _size; } //規模
bool empty() const { return !_size; } //判空
Rank find(T const& e) const { return find(e, 0, _size); } //無序向量整體查找
Rank find(T const& e, Rank lo, Rank hi) const; //無序向量區間查找
Rank search(T const& e) const //有序向量整體查找
{ return (0 >= _size) ? -1 : search(e, 0, _size); }
Rank search(T const& e, Rank lo, Rank hi) const; //有序向量區間查找
// 可寫訪問介面
T& operator[] (Rank r); //多載下標運算子，可以類似于陣列形式參考各元素
const T& operator[] (Rank r) const; //僅限于做右值的多載版本
Vector<T> & operator= (Vector<T> const&); //多載賦值運算子，以便直接克隆向量
T remove(Rank r); //洗掉秩為r的元素
int remove(Rank lo, Rank hi); //洗掉秩在區間[lo, hi)之內的元素
Rank insert(Rank r, T const& e); //插入元素
Rank insert(T const& e) { return insert(_size, e); } //默認作為末元素插入
void sort(Rank lo, Rank hi); //對[lo, hi)排序
void sort() { sort(0, _size); } //整體排序
void unsort(Rank lo, Rank hi); //對[lo, hi)置亂
void unsort() { unsort(0, _size); } //整體置亂
int deduplicate(); //無序去重
int uniquify(); //有序去重
void bubbleSort(Rank lo, Rank hi); //起泡排序演算法
bool bubble(Rank lo, Rank hi); //掃描交換
 // 遍歷
void traverse(void(*) (T&)); //遍歷（使用函式指標，只讀或區域性修改）
template <typename VST> void traverse(VST&); //遍歷（使用函式物件，可全域性修改）
}; //Vector


template <typename T> void Vector<T>::expand() { //向量空間不足時擴容
if (_size < _capacity) return; //尚未滿員時，不必擴容
    if (_capacity < DEFAULT_CAPACITY) _capacity = DEFAULT_CAPACITY; //不低于最小容量
    T* oldElem = _elem;  _elem = new T[_capacity <<= 1]; //容量加倍
    for (int i = 0; i < _size; i++)
       _elem[i] = oldElem[i]; //復制原向量內容（T為基本型別，或已多載賦值運算子'='）
    delete[] oldElem; //釋放原空間
}
template <typename T> void Vector<T>::shrink() { //裝填因子過小時壓縮向量所占空間
if (_capacity < DEFAULT_CAPACITY << 1) return; //不致收縮到DEFAULT_CAPACITY以下
if (_size << 2 > _capacity) return; //以25%為界
T* oldElem = _elem;  _elem = new T[_capacity >>= 1]; //容量減半
for (int i = 0; i < _size; i++) _elem[i] = oldElem[i]; //復制原向量內容
delete[] oldElem; //釋放原空間
}
template <typename T>
void Vector<T>::bubbleSort(Rank lo, Rank hi) {
while (!bubble(lo, hi--));
}
template<typename T> bool Vector<T>::bubble(Rank lo, Rank hi) {
bool sorted = true;
while (++lo < hi) {
if (_elem[lo-1] > _elem[lo]) {
sorted = false;
swap(_elem[lo-1], _elem[lo]);
}
}
return sorted;
}
template <typename T> Vector<T>& Vector<T>::operator= (Vector<T> const& V) { //深復制
   if (_elem) delete[] _elem; //釋放原有內容
   copyFrom(V._elem, 0, V.size()); //整體復制
   return *this; //回傳當前物件的參考，以便鏈式賦值
}
template <typename T> T & Vector<T>::operator[] (Rank r) //多載下標運算子
{ return _elem[r]; } // assert: 0 <= r < _size

template <typename T> const T & Vector<T>::operator[] (Rank r) const //僅限于做右值
{ return _elem[r]; } // assert: 0 <= r < _size
template < typename T> //元素型別
 void Vector<T>::copyFrom(T const* A, Rank lo, Rank hi) { //以陣列區間A[lo, hi)為藍本復制向量
    _elem = new T[_capacity = 2 * (hi - lo)]; _size = 0; //分配空間，規模清零
    while (lo < hi) //A[lo, hi)內的元素逐一
       _elem[_size++] = A[lo++]; //復制至_elem[0, hi - lo)
}

int main() {
Vector<int> A;

for (int i = 0; i < 10; i++) {
A[i] = rand();
}
A.bubbleSort(0,A.size()-1);
for (int i = 0; i < 10; i++) {
cout << A[i] << " ";
}

return 0;
}

uj5u.com熱心網友回復：

邏輯錯誤，你的_size一直是0

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/169710.html

標籤：C++ 語言

上一篇：第十八章 Java I/O系統

下一篇：順序表的基本操作 ；順序表的實作