选择法+冒泡法

(1,2,3,4表示第几趟排序)
简单选择排序和冒泡排序的特征归纳_算法

冒泡法:

简单选择排序和冒泡排序的特征归纳_升序_02

选择法:

简单选择排序和冒泡排序的特征归纳_升序_03

code

选择排序法_实数排序: (升序版)

/* 选择排序法_实数排序: (升序版)
有助于增强理解的特征:最大比较区间的次数为n-1次 ;最小长度比较区间比较的次数为1次.*/
void sort_select_float(float *a,int n_elements)
/* 在内部计数数组的元素个数要求传入的数组有做结尾处理/规整的初始化,干脆就调用该函数之前计数下元素个数 */
{
int min = 0 ;
int j = 0;
float temp = 0;
/*LHS表示关系表达式的左边;RHS表示关系表达式的右边;
选中排序:每趟排序共用同一个LHS;单趟排序中:*/
for(int i = 0;i < n_elements - 1;i++)
{
min = i;
/* 找到最小元素所在位置,这里比较边界是将左边界收缩,而右边界不变. */

/*指出比较范围和比较对象*/
/*每一趟:外重循环从LHS∈[0,n-2]中选定一个LHS,
内重循环控制该趟排序的一系列比较中,使RHS∈[LHS+1,n-1]全部依次与该趟指定的这个LHS作比较 */
for( j = i+1 ; j < n_elements ;j++)
{
if(a[min] > a[j])
{
min = j;
}
}
/* 交换元素 */
if(min != i)/* 最终的得到的min和初始值i比较,看是否变化了,当然,也可不比较直接交换. */
{
/* 注意不是a[i]和a[j]交换(bubble才这样.) */
temp = a[i];
a[i] = a[min];
a[min] = temp;

//printf("%f ",a[i]);
}

/*监视每一趟的排序结果.
for(int i = 0;i < n_elements - 1;i++) printf("%f ",a[i]);
printf("\n\n"); */
}
}

冒泡排序

void bubble_int_sort(int *p, int n)
{
void swap_int_pointer(int *a, int *b);
/*冒泡法不需要设立最值flag. */
for (int i = 0; i < n - 1; i++)
{
/* RHS = LHS+1 ∈ [1,n-1]
单趟比较中:*/
for (int j = 0; j <= n - 2 - i; j++)/*内重循环控制各趟排序的一系列比较中:控制LHS从[0,n-2-i]从0取遍n-2-i(i由外重循环弹出的表示现在是第i趟排序) ;比较表达式的右边RHS = LHS+1 */ /* RHS∈[1,n-1] */
{
/*通过改变'<'为'>',可以从降序转为升序; 通过监视*(p+j)和*(p+j+1)可以知道当前(第j组)相邻量的值的情况 */
if (*(p + j) < *(p + j + 1)) /*或者写作if(p[j] < p[j+1])也可以*/
{
swap_int_pointer(p + j, p + j + 1);
}
}
}
}
/* 数字版swap() */
void swap_int_pointer(int *a, int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}

降序版

c++降序版代码示例

#include <iostream>

void bubble_int_sort(int *elem_array_p, int size)
{
void swap_int_pointer(int *a, int *b);
/*冒泡法不需要设立最值flag. */
/* 外层循环控制比较的趟数rounds(或者称为回合数) */
for (int round_i = 0; round_i < size - 1; round_i++)
{
/* RHS = LHS+1 ∈ [1,size-1]
单趟比较中:
该趟剩余待排序元素个数为remains=size-round_i*/
int remains = size - round_i;
int times_to_compare = remains - 1;
/* 这样,内层便利将会为该round(回合)的排序过程中做times_to_compare次比较. 可以举三个元素构成的待排序列来感受一下
内层循环的条件表达式的编写可以基于本回合需要比较的次数来编写.
循环变量left_j也可以理解为本回合的比较次数计数器/或每次被比较的两个元素的左侧元素.*/
for (int left_j = 0; left_j < times_to_compare; left_j++) /*内重循环控制各趟排序的一系列比较中:控制LHS从[0,size-2-round_i]从0取遍size-2-round_i(round_i由外重循环弹出的表示现在是第round_i趟排序) ;比较表达式的右边RHS = LHS+1 */ /* RHS∈[1,size-1] */
{
int *left = elem_array_p + left_j;
int *right = left + 1;
/*通过改变'<'为'>',可以从降序转为升序; 通过监视*(elem_array_p+left_j)和*(elem_array_p+left_j+1)可以知道当前(第left_j组)相邻量的值的情况 */
if (*left > *right)
{
swap_int_pointer(left, right);
}
}
}
}
/* 数字版swap() */
void swap_int_pointer(int *a, int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
using namespace std;
int main()
{
/* 在这个数组里填充您要排序的整数序列 */
int test_arr[] = {6, 8, 2, 0, 1, 70};
int size = sizeof(test_arr) / sizeof(test_arr[0]);
bubble_int_sort(test_arr, size);
for (int round_i = 0; round_i < size; round_i++)
{
cout << test_arr[round_i] << endl;
}
}