1

我正在尝试为我的 while 循环比较两个字符串，这是我的代码片段：

//variables
string pivot, array[10];
int rightBoundary;

//loop
while( pivot < array[rightBoundary])

此代码来自快速排序教程，但我试图将其转换为使用字符串。

所以我的问题是进行这种比较的最佳方法是什么。

目前我收到此错误（quickSortNumbers.exe 中 0x774215de 处的未处理异常：0xC0000005：访问冲突读取位置 0x965b7214。）

和帮助将是非常感谢:)

编辑：抱歉应该刚刚上传了我所有的代码，我认为问题实际上可能是字符串数组。这是我所有的代码：

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

#define array1_SIZE 5                //change the array1 size here

void Printarray1(string* array1, int n);
void QuickSort(string* array1, int startIndex, int endIndex);
int Splitarray1(string* array1, string pivot, int startIndex, int endIndex);
void swap(string &a, string &b);

int main(void)
{
    string array1[array1_SIZE];
    int i;

    for( i = 0; i < array1_SIZE; i++)               //array1 elements input
    {
        cout<<"Enter an integer : ";
        cin>>array1[i];
    }

    cout<<endl<<"The list you input is : "<<endl;
    Printarray1(array1, array1_SIZE);
    QuickSort(array1,0,array1_SIZE - 1);    //sort array1 from first to last element
    cout<<endl<<"The list has been sorted, now it is : "<<endl;
    Printarray1(array1, array1_SIZE);

    cin.get();
    cin.get();
    int read;
    cin >> read;
    return 0;
}

/* This function swaps two numbers
  Arguments :
           a, b - the numbers to be swapped
  */
void swap(string &a, string &b)
{
    string temp;
    temp = a;
    a = b;
    b = temp;
}

/* This function prints an array1.
  Arguments :
           array1 - the array1 to be printed
           n - number of elements in the array1
  */
void Printarray1(string* array1, int n)
{
    int i;

    for( i = 0; i < n; i++) 
    {   
        cout << array1[i] << '\t';
    }
}

/* This function does the quicksort
  Arguments :
           array1 - the array1 to be sorted
           startIndex - index of the first element of the section
           endIndex - index of the last element of the section
  */
void QuickSort(string* array1, int startIndex, int endIndex)
{
    string pivot = array1[startIndex];  //pivot element is  the leftmost element
    int splitPoint;

    if(endIndex > startIndex)       //if they are equal, it means there is
        //only one element and quicksort's job
        //here is finished
    {
        splitPoint = Splitarray1(array1, pivot, startIndex, endIndex);
        //Splitarray1() returns the position where
        //pivot belongs to
        array1[splitPoint] = pivot;
        QuickSort(array1, startIndex, splitPoint-1);   //Quick sort first half
        QuickSort(array1, splitPoint+1, endIndex);   //Quick sort second half
    }
}

/* This function splits the array1 around the pivot
  Arguments :
           array1 - the array1 to be split
           pivot - pivot element whose position will be returned
           startIndex - index of the first element of the section
           endIndex - index of the last element of the section
  Returns :
         the position of the pivot
  */
int Splitarray1(string* array1, string pivot, int startIndex, int endIndex)
{
    int leftBoundary = startIndex;
    int rightBoundary = endIndex;

    while(leftBoundary < rightBoundary) //shuttle pivot until the     boundaries meet
    {
        while( pivot < array1[rightBoundary]//keep moving until a lesser element is found
               && rightBoundary > leftBoundary)   //or until the  leftBoundary is reached
        {
            rightBoundary--;                        //move left
        }
        swap(array1[leftBoundary], array1[rightBoundary]);
        //Printarray1(array1, array1_SIZE);          //Uncomment this line for study

        while( pivot >= array1[leftBoundary]          //keep moving until a greater or equal element is found
               && leftBoundary < rightBoundary)   //or until the rightBoundary is reached
        {
            leftBoundary++;                      //move right
        }
        swap(array1[rightBoundary], array1[leftBoundary]);
        //Printarray1(array1, array1_SIZE);          //Uncomment this line for study
    }
    return leftBoundary;                              //leftBoundary is the split point because
    //the above while loop exits only when 
    //leftBoundary and rightBoundary are equal
}
4

2 回答 2

2

您可能有一个越界错误，可能是由于未初始化rightBoundary. 使用比较运算符可以完美地比较字符串。

#include <iostream>
using std::cout;

#include <string>
using std::string;

int main()
{
    string s1 = "hello";
    string s2 = "world!";

    string lower = s1 < s2 ? s1 : s2;

    cout << lower; //prints "hello"
}

要在不担心大小写的情况下进行比较，您可以使用lexicographical_compare自己的比较器功能：

#include <algorithm>
using std::lexicographical_compare;

#include <cctype>
using std::tolower;

#include <iostream>
using std::cout;

#include <string>
using std::string;

bool nocase_compare (char one, char two)
{
    return tolower (one) < tolower (two);
}

int main()
{
    string s1 = "Hello";
    string s2 = "happy";

    if (lexicographical_compare (s1.begin(), s1.end(), s2.begin(), s2.end(), nocase_compare))
        cout << s1;
    else
        cout << s2;
    //prints "happy" even though 'H' < 'h'
}

如果你真的想使用 < 和 >，你将不得不为string实现你的operator<and版本做一个小包装器operator>。在string使用默认实现的那些lexicographical_compare。

于 2012-04-21T15:21:09.187 回答
1

使用 < 比较字符串很好，但如果你想要字母顺序，可能不是你所期望的，因为如果你想要字典顺序，所有小写字母都在大写字母之前，你应该使用 lexicographical_compare 代替。

您的代码崩溃的原因是您没有为 rightBoundary 分配任何初始值，您应该这样做：

int rightBoundary = 0;

因为否则 rightBoundary 将具有任意初始值，该初始值极有可能大于“数组”的大小并导致越界访问。

于 2012-04-21T15:23:02.433 回答