排序

对于排序。有一点很容易忽略的是排序算法的稳定性

　　排序算法稳定性的简单形式化定义为：如果A_i = A_j，排序前A_i在A_j之前，排序后A_i还在A_j之前，则称这种排序算法是稳定的。通俗地讲就是保证排序前后两个相等的数的相对顺序不变。

冒泡排序法是两两依次比较，并做交换，交换的次数多。

选择排序法是每次循环找出最值，循环结束后将最值调整到合适位置，交换的次数少。
 

1、冒泡排序

#include<iostream>
using namespace std;
int main(){
	int a[5]={23,6,9,10,3};
	int i,j;
	int temp;
	for(i=0;i<4;i++){ //i表示冒泡的轮数，明白一个常识，n个数最多比较n-1轮就能得出答案，所以这里i<4 其次：外层循环控制比较轮数
		for(j=0;j<5;j++){ //j表示数组的下标，从a[0]开始，与相邻的数进行比较，如果后面的数大
				  //则进行两个数的交换 ，其实这里j应该是小于4，因为a[3]
				  //与a[4]进行比较，a[4]后面没有数 （内层循环控制每轮的比较和交换）
								 
			if(a[j]>a[j+1]){
				temp=a[j];
			        a[j]=a[j+1];
				a[j+1]=temp;	
			}
		}
	}
	for(i=0;i<5;i++){
		cout<<a[i]<<" ";
	}
	
	
	
	
	return 0;
}

void写函数定义返回类型

#include<stdio.h>
void Swap(int A[], int i, int j)
{
    int temp = A[i];
    A[i] = A[j];
    A[j] = temp;
}

void BubbleSort(int A[], int n)
{
    for (int j = 0; j < n - 1; j++)         // 每次最大元素就像气泡一样"浮"到数组的最后
    {
        for (int i = 0; i < n - 1 - j; i++) // 依次比较相邻的两个元素,使较大的那个向后移
        {
            if (A[i] > A[i + 1])            // 如果条件改成A[i] >= A[i + 1],则变为不稳定的排序算法
            {
                Swap(A, i, i + 1);
            }
        }
    }
    	
}
int main()
{
    int A[] = { 6, 5, 3, 1, 8, 7, 2, 4 };    // 从小到大冒泡排序
    int n = sizeof(A) / sizeof(int);
    BubbleSort(A, n);
    printf("冒泡排序结果：");
    for (int i = 0; i < n; i++)
    {
        printf("%d ", A[i]);
    }
    printf("\n");
    return 0;
}

公式化：N代表数组长度：sizeof（变量名称）/ sizeof（变量类型）

int（i=0 ；i = N - 1；i++）

int(int j = 0;j < N-i-1;j++)

2、选择排序

#include<iostream>
using namespace std;
int main(){
	int a[4]={6,3,4,7};
	int temp;
	int i,j;
	for(i=0;i<4;i++){ //表示当前所要进行比较的值 a[0]
		for(j=i+1;j<4;j++){ //表示这个值后面的每个数值 a[1] a[2] a[3]
			if(a[i]<a[j]){ //如果要比较的值小于它后面的值，就交换 
				temp=a[i];  // a=3,b=4  
				a[i]=a[j];
				a[j]=temp;
			} 
		}
	}
	for(i=0;i<4;i++){
		cout<<" "<<a[i];
	}
	
	return 0;
} 

#include <stdio.h>

// 分类 -------------- 内部比较排序
// 数据结构 ---------- 数组
// 最差时间复杂度 ---- O(n^2)
// 最优时间复杂度 ---- O(n^2)
// 平均时间复杂度 ---- O(n^2)
// 所需辅助空间 ------ O(1)
// 稳定性 ------------ 不稳定

void Swap(int A[], int i, int j)
{
    int temp = A[i];
    A[i] = A[j];
    A[j] = temp;
}

void SelectionSort(int A[], int n)
{
    for (int i = 0; i < n - 1; i++)         // i为已排序序列的末尾
    {
        int min = i;
        for (int j = i + 1; j < n; j++)     // 未排序序列
        {
            if (A[j] < A[min])              // 找出未排序序列中的最小值
            {
                min = j;
            }
        }
        if (min != i)
        {
            Swap(A, min, i);    // 放到已排序序列的末尾，该操作很有可能把稳定性打乱，所以选择排序是不稳定的排序算法
        }
    }
}

int main()
{
    int A[] = { 8, 5, 2, 6, 9, 3, 1, 4, 0, 7 }; // 从小到大选择排序
    int n = sizeof(A) / sizeof(int);
    SelectionSort(A, n);
    printf("选择排序结果：");
    for (int i = 0; i < n; i++)
    {
        printf("%d ", A[i]);
    }
    printf("\n");
    return 0;
}

使用选择排序为一列数字进行排序的宏观过程：　　

　　选择排序是不稳定的排序算法，不稳定发生在最小元素与A[i]交换的时刻。

　　比如序列：{ 5, 8, 5, 2, 9 }，一次选择的最小元素是2，然后把2和第一个5进行交换，从而改变了两个元素5的相对次序。

3、插入排序

#include<iostream>
using namespace std;
int InsertSort(int a[], int n)
{
    for (int j = 1; j < n; j++)
    {
        int key = a[j]; //待排序第一个元素
        int i = j - 1;  //代表已经排过序的元素最后一个索引数
        while (i >= 0 && key < a[i])
        {
            //从后向前逐个比较已经排序过数组，如果比它小，则把后者用前者代替，
            //其实说白了就是数组逐个后移动一位,为找到合适的位置时候便于Key的插入
            a[i + 1] = a[i];
            i--;//从后往前，所以i--
        }
        a[i + 1] = key;//找到合适的位置了，赋值,在i索引的后面设置key值。
    }//可以代几个数字比较1-（2 8 6）  2-（5 6）
}
int main() {
    int d[] = { 12, 15, 9, 20, 6, 31, 24 };
    cout << "输入数组  { 12, 15, 9, 20, 6, 31, 24 } " << endl;
    InsertSort(d,7);
    cout << "排序后结果：";
    for (int i = 0; i < 7; i++)
    {
        cout << d[i]<<" ";
    }
 
}

进阶的排序走：https://www.cnblogs.com/eniac12/p/5329396.html