选择排序与冒泡排序C++

选择排序

选择排序思想：

从头至尾扫描序列，若为升序，第一次找出最小的一个元素，和第一个元素交换，第二次从剩下的元素中继续找出最小的元素，对第二个元素交换，往后一直按照当前规律来选择和交换，最终得到一个有序序列。

图解：

例子:

main.h 文件

#pragma once
#include <vector>		//
#include <algorithm>	//含了所有vector、list、set、map操作能想到的一些函数，
						//如查找，替换、排序、计数等

//输出容器中的值
void showVector();

//选择排序
void selectSort();
void selectSort1();

//冒泡排序
void bubblingSort();

class MyClass
{
public:
	MyClass(int num) { MyNum = num; }
	
	int getMyNum();
private:
	int MyNum;
};

main.cpp 文件

#include <iostream>
#include "main.h"
#include <time.h>	//用于刷新随机数的	

using namespace std;

//创建一个用来储存数据的vector
vector<MyClass *> myVector;

void main()
{
	//刷新随机因子
	srand(time(0));
	int num;
	//为容器添加数据
	for (int i = 0; i < 6; i++)
	{
		//生成10以内的随机数
		num = rand() % 10;
		//创建class指针并为MyNum赋值
		MyClass* myclass = new MyClass(num);
		//添加进容器
		myVector.push_back(myclass);
	}
	//输出容器内的值
	showVector();
	//换行
	cout << endl;
	//进行选择排序
	selectSort();
	//输出
	showVector();
	cout << endl;
}

//获取MyNum
int MyClass::getMyNum()
{
	return MyNum;
}

//输出内容
void showVector()
{
	vector<MyClass *>::iterator ite = myVector.begin();
	cout << "输出的数值为：";
	for (ite; ite != myVector.end(); ite++)
	{
		cout << (*ite)->getMyNum() << "\t";
	}
}

//选择排序
void selectSort()
{
	//使用容器用下标遍历，好像有点不太及格的样子。。。
	for (int i = 0; i < myVector.size() - 1; i++)
	{
		int index = i;
		for (int j = i + 1; j < myVector.size(); j++)
		{
			if (myVector[index]->getMyNum() > myVector[j]->getMyNum())
			{
				index = j;
			}
			cout << "i = " << i << " j= " << j << " index = " << index << endl;
		}
		MyClass * temp = myVector[index];
		myVector[index] = myVector[i];
		myVector[i] = temp;
	}
}

//使用迭代器版的（选择排序）：虽然交换的时候还是用到了下标，就想问问大佬有没有更简单的写法。
void selectSort1()
{
	vector<MyClass *>::iterator ite = myVector.begin();
	int i = 0,index = 0,j = 0;
	vector<MyClass *>::iterator ite2;

	for (ite; ite != myVector.end() - 1; ite++)
	{
		index = i;
		j = i + 1;
		ite2 = ite;

		vector<MyClass *>::iterator ite1 = ite + 1;

		for (ite1; ite1 != myVector.end(); ite1++)
		{
			//判断
			if ((*ite2)->getMyNum() > (*ite1)->getMyNum())
			{
				//标记
				index = j;
				ite2 = ite1;
			}
			++j;
		}
		//进行交换
		MyClass* temp = myVector[i];
		myVector[i] = myVector[index];
		myVector[index] = temp;
		++i;
	}
}

//冒泡排序
void bubblingSort()
{
}

冒泡排序

冒泡排序思想：

比较相邻的元素（升序）。如果第一个比第二个大，就交换他们两个。如果第一个不大于第二个，从第二个开始比较第三个，然后重复该操作直至排序完成。

图解：

例子：
接着上方选择排序。

void bubblingSort()
{
	//设定一个标志位：为false时，还有得交换，为true时，已经是有序的了
	bool ok;
	//为什么这里是i = 1？因为为了防止下面myVector[j+1]超出数组的范围。
	//那我将第一个for循环i = 0，myVector.size()-1不也一样是循环这么多遍那么多遍，
	//为什么myVector[j+1]还是会超出。
	//因为第二个循环的长度和i有关，i的变化影响第二个循环长度；举个例子：
	//数组长度为3，那么第一个for循环第一次循环i = 0，第二个for循环会循环三次
	//第二个for循环第一次循环myVector[0]跟myVector[1]都没有越界，
	//第二个for循环第二次循环myVector[1]跟myVector[2]也没有越界，
	//第二个for循环第三次循环myVector[2]跟myVector[3]就越界了，这也正是为什么i要从1开始的原因。
	//如果就是想让i从0开始，第一个for循环myVector.size() -1在第二个for循环myVector.size() - i - 1就好了。
	for (int i = 1; i < myVector.size(); i++)
	{
		ok = true;
		for (int j = 0; j < myVector.size() - i; j++)
		{
			if (myVector[j]->getMyNum() > myVector[j + 1]->getMyNum())
			{
				//进行交换
				MyClass * temp = myVector[j];
				myVector[j] = myVector[j + 1];
				myVector[j + 1] = temp;
				ok = false;	
			}
		}
		if (ok == true)
		{
			break;
		}
	}
}