选择排序(C++，Java，Python实现）
排序算法之选择排序,选择排序，选择排序的基本思想描述为：每一趟在n-i+1(i=1,2,…,n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。具体来说，假设长度为n的数组arr，要按照从小到大排序，那么先从n个数字中找到最小值min1，如果最小值min1的位置不在数组的最左端(也就是min1不等于arr[0])，则将最小值min1和arr[0]交换，接着在剩下的n-1个数字中找到最小值min2，如果最小值min2不等于arr[1]，则交换这两个数字，依次类推，直到数组arr有序排列。
算法过程
举个栗子（第一趟的排序过程）
原始序列：3、44、38、5、47、15、36、 26、27、2、46、4、19、50、48
1）在进行选择排序过程中分成有序和无序两个部分，开始都是无序序列
结果：3、44、38、5、47、15、36、 26、27、2、46、4、19、50、48
2）从无序序列中取出最小的元素2，将2同无序序列第一个元素交换，此时产生仅含一个元素的有序序列，无序序列减一
结果：{2、} {44、38、5、47、15、36、 26、27、3、46、4、19、50、48
3）从无序序列中取出最小的元素3，将3同无序序列第一个元素交换，此时产生仅两个元素的有序序列，无序序列减一
结果：{2、3、} {38、5、47、15、36、 26、27、44、46、4、19、50、48}
4）从无序序列中取出最小的元素4，将4同无序序列第一个元素交换，此时产生含三个元素的有序序列，无序序列减一
结果：{2、3、4、} {5、47、15、36、 26、27、44、46、38、19、50、48}
5）从无序序列中取出最小的元素5，5此时是无序序列最小的，不用交换
结果：{2、3、4、5、} {47、15、36、 26、27、44、46、38、19、50、48}
6）从无序序列中取出最小的元素15，将15同无序序列第一个元素交换，此时产生含五个元素的有序序列，无序序列减一
结果：{2、3、4、5、15、} {47、36、 26、27、44、46、38、19、50、48}
7）依次重复上述操作，直到无序序列只有最后一个元素
8）最后一个元素50肯定是最大元素，无序排序直接生产一个有序的序列
结果：{2、3、4、5、19、26、27、36、38、44、46、47、48、50}
最后如果还没有理解这个过程的话，小编放上一个动图，让大家更深入的理解这个过程：
接下来分析完了插入排序的算法，我们就到了分享代码的这个激动人心的时刻了：
插入排序C++实现代码：
#include <iostream>
using namespace std;
#include <vector>
#include <time.h>
vector<int> get_random(int n, int N);
const int MAX_NUM=10000;
int data[100];//定义一个产生数组储存100个随机数
void SelectSort(int n);//选择排序
void output(int n);
void Swap(int i,int j);
int main()
{
srand((unsigned int)time(0));
vector<int> randsample=get_random(100,MAX_NUM);//产生100个0-MAZX_NUM的随机数,每次产生的随机数不一样
int size=randsample.size();
//输出最开始时未排序时的顺序:
cout<<"随机数的顺序："<<endl;
for(int i=0;i<randsample.size();i++)
{
cout<<randsample[i]<<" ";
}
cout<<endl;
clock_t start,finish;//定义一个测量一段程序运行时间的前后值
double totaltime;//总的运行时间
//测试选择排序
cout<<"执行选择排序后:"<<endl;
for(int i=0;i<randsample.size();i++)
{
data[i]=randsample[i];
}
start=clock();
SelectSort(size);
finish=clock();
output(size);
totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
cout<<"运行时间："<<totaltime<<endl;
}
//产生随机数的函数
vector<int> get_random(int n, int N)
{
vector<int> vec(N);//N代表初始状态分配的空间大小
vector<int> out_vec;
for(int i=0;i<N;++i)
{
vec[i]=i;
}
for (int i=0;i<n;++i)
{
int rand_value=rand()%N;
out_vec.push_back(vec[rand_value]);
vec[rand_value]=vec[N-1];//将数组vec的元素
N--;
}
return out_vec;
}
//直接选择排序
void SelectSort(int n)
{
int i,j;
int count=0;
int count1=0;
for(i=0;i<n;i++)
{
int k=i;//在data[i]到data[n-1]找最小排序码元素
for(j=i+1;j<n;j++){
if(data[j]<data[k]){
count++;//当前具有最小排序码的元素
k=j;
}
}
if(k!=i)
Swap(i,k);//交换
count1++;
}
cout<<"比较次数: "<<count<<" 移动次数: "<<count1<<endl;
}
void output(int n)
{
for(int i=0;i<n;i++)
{
cout<<data[i]<<" ";
}
cout<<endl;
}
//交换函数
void Swap(int i,int j)
{
int tem;
tem = data[j];
data[j]= data[i];
data[i] = tem;
}
插入排序Java代码实现
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class SelectSort
{
public static void main(String[] args)
{
Object []arr = getRandomNumList(100,0,10000).toArray();
int[] ins = new int [100] ;
System.out.println("排序前：");
for(int i = 0; i < arr.length; i++) {
String s=arr[i].toString();
ins[i]= Integer.parseInt( s );
System.out.println(ins[i]);
}
System.out.println("排序后：");
int[] ins2 = selectsort(ins);
for(int i = 0; i < arr.length; i++) {
System.out.println(ins2[i]);
}
}
public static int[] selectsort(int[] data){
int i,j;
int n = data.length-1;
for(i=0;i<n;i++)
{
int k=i;//在data[i]到data[n-1]找最小排序码元素
for(j=i+1;j<n;j++){
if(data[j]<data[k]){//当前具有最小排序码的元素
k=j;
}
}
if(k!=i)
{
int tem;
tem=data[k];
data[k]=data[i];
data[i]=tem;
}
}
return data;
}
//定义生成随机数并且装入集合容器的方法
//方法的形参列表分别为：生成随机数的个数、生成随机数的值的范围最小值为start(包含start)、值得范围最大值为end(不包含end) 可取值范围可表示为[start,end)
public static List getRandomNumList(int nums,int start,int end){
//1.创建集合容器对象
List list = new ArrayList();
//2.创建Random对象
Random r = new Random();
//循环将得到的随机数进行判断，如果随机数不存在于集合中，则将随机数放入集合中，如果存在，则将随机数丢弃不做操作，进行下一次循环，直到集合长度等于nums
while(list.size() != nums){
int num = r.nextInt(end-start) + start;
if(!list.contains(num)){
list.add(num);
}
}
return list;
}
}
插入排序Python代码实现
import random
def sort(arr):
for j in range(len(arr)-1):
minIndex = j
for i in range(j+1,len(arr),1):
if(arr[i] < arr[minIndex]):
minIndex = i
arr[j],arr[minIndex] = arr[minIndex],arr[j]
def main():
arr =[]
while(len(arr)<100):
x=random.randint(0,10000)
if x not in arr:
arr.append(x)
sort(arr)
print(arr)
if __name__ == "__main__":
main()
算法分析：
直接选择排序的排序码比较次数KCN与元素的初始排列无关。第i趟选择具有最小排序码元素所需的比较次数总是n-i-1次，此处假定整个待排序元素序列有n个元素。因此，总的排序码比较次数为:
=n*(n-1)/2
元素的移动次数与元素序列的初始排列有关。当这组元素的初始状态是按其排序码从小到大有序的时候，元素的移动次数RMN=0，达到最少；而最坏情况是每一趟都要进行交换，总的元素移动次数为RMN=3（n一1)。它对一类重要的元素序列具有较好的效率，这就是元素规模很大，而排序码却比较小的序列。因为对这种的序列进行排序，移动操作所花费的时间要比比较操作的时间大得多，而其他算法移动操作所花费的时间要比比较操作的时间大的多，而其他算法移动操作次数都要比选择排序来得多。直接选择排序是一种不稳定的排序方法。
以上就是本次给大家分享的选择排序的几种实现,如果有什么不足之处欢迎大家指出，留言，互相学习，共同进步。花了几个小时整理，希望得到大家的支持,你的支持就是我前进的动力,下面我会持续更新其他的排序算法，敬请期待！想要了解其他相关内容也可以访问我的个人博客相逢的博客（里面有hexo搭建博客等相关内容）
