我的选择排序用 0 替换了数组中的一些数字

Question

This is the complete code that I wrote: ( [ nums in the function] and [ arr in main] is the array that needs to be sorted, size is the amount of numbers in the array, min is the smallest number in the unsorted part)

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

void sort(vector <int> &nums, int size){
    int min = 0;
    for(int i=0;i<size;i++){
        min = i;
        for(int j=i+1;j<size;j++){
            if(nums[j]<nums[min]){
                min = j;                //comparing
            }
        }
        nums[i] = nums[min] + nums[i];      //swaping
        nums[min] = nums[i] - nums[min];
        nums[i] = nums[i] - nums[min];
    }
}

int main(){
    cout<<"\nEnter Numbers:\n";
    vector <int> arr;
    int num;
    while(cin>>num){
        arr.push_back(num);
    }
    sort(arr,arr.size());
    cout<<"\nSorted:\n";
    for(int i=0;i<arr.size();i++){
        cout<<arr[i]<<" ";
    }
}

I'm writing a code that simply sorts the given array. But after trying to debug and find solutions online, I can't figure out which part is wrong. These are some examples of my results:

Enter Numbers:
9 8 7 6 1 2 3 4 5 ^Z

Sorted:
1 2 3 4 5 6 0 0 0

Enter Numbers:
6 4 8 7 2 3 5 ^Z

Sorted:
2 3 4 5 0 7 0

Enter Numbers:
9 8 7 6 5 4 3 2 1 ^Z

Sorted:
1 2 3 4 0 0 0 0 0

This is the result when I added a for loop under the swapping part to show what every round has done to the array:

Enter Numbers:
9 8 7 6 1 2 3 4 5 ^Z

1 8 7 6 9 2 3 4 5 
1 2 7 6 9 8 3 4 5 
1 2 3 6 9 8 7 4 5 
1 2 3 4 9 8 7 6 5 
1 2 3 4 5 8 7 6 9 
1 2 3 4 5 6 7 8 9 
1 2 3 4 5 6 0 8 9
1 2 3 4 5 6 0 0 9
1 2 3 4 5 6 0 0 0

Sorted:
1 2 3 4 5 6 0 0 0

Enter Numbers:
6 4 8 7 2 3 5 ^Z

2 4 8 7 6 3 5
2 3 8 7 6 4 5
2 3 4 7 6 8 5
2 3 4 5 6 8 7
2 3 4 5 0 8 7
2 3 4 5 0 7 8
2 3 4 5 0 7 0

Sorted:
2 3 4 5 0 7 0

9 8 7 6 5 4 3 2 1 ^Z

1 8 7 6 5 4 3 2 9
1 2 7 6 5 4 3 8 9
1 2 3 6 5 4 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 0 6 7 8 9
1 2 3 4 0 0 7 8 9
1 2 3 4 0 0 0 8 9
1 2 3 4 0 0 0 0 9
1 2 3 4 0 0 0 0 0

Sorted:
1 2 3 4 0 0 0 0 0

Please help, thanks.

Answer 1

Your swapping logic doesn't handle the case where the smallest remaining element is the first unsorted element (ie, i == min ). Consider what each line does in this case:

        nums[i] = nums[min] + nums[i];      //nums[i] will be doubled
        nums[min] = nums[i] - nums[min];    // nums[min] is subtracted from itself, making it 0
        nums[i] = nums[i] - nums[min];      // nums[i] is subtracted from itself gain, but 0-0 is still 0

The goal of avoiding a temporary isn't bad by itself, but you do have this nasty edge case. You'd either have to detect the edge case or just bite the bullet and deal with a temporary. You could also call std::swap , but that likely uses a temporary as well.

The advantage to using a temporary or std::swap is that this code would be easier to make generic for other types (especially via std::swap ). In addition, std::swap can be specialized for types to avoid temporaries if possible, and if this is actually a bottleneck.