冒泡排序 以及 k 法优化

一般优化：

此种方法，优化在：循环一次，找到一个最大的放在末尾，下次再找，它的区间就会减1（由第一个倒数第二个）
以此类推，优化在减少了待找区间的大小（即内层循环的趟数）

代码分析：

#include<stdio.h>
#include<stdlib.h>

int a[] = { 1,5,4,2,6,7,8,9,3,0 };
int len = sizeof(a) / sizeof(a[0]);

void Swap(int*x, int*y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}


void Bubble_Sort(int a[], int len)
{
    int flag = 0;//定义一个标志，如果数组原本有序，不用再进行排序

    for (int i = 0; i < len - 1; i++)
    {


        for (int j = 0; j < len - i - 1; j++)
        {
            if (a[j] > a[j + 1])
                Swap(&a[j], &a[j + 1]);
                flag=1;
        }
    }
    if (flag == 0)
        {
            break;
        }

}

void print()
{
    for (int i = 0; i < len; i++)
    {
        printf("%d", a[i]);
    }
}

int main()
{

    print();
    printf("\n");
    Bubble_Sort(a, len);
    print();
    system("pause");
    return 0;
}

---

---

更加优化：（k法）

k法更加优化在：一般优化一次区间只是减1，而k法优化一次区间可以减1（或N）

代码分析：

#include<stdio.h>
#include<stdlib.h>

int a[] = { 1,5,4,2,6,7,8,9,3,0 };
int len = sizeof(a) / sizeof(a[0]);

void Swap(int*x, int*y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

void Bubble_Sort(int a[], int len)
{

    int k=len-1;
    int m = 0;

    for (int i = 0; i < len-1; i++)
    {
        int flag = 0;

        for (int j = 0; j < k; j++)
        {
            if (a[j] > a[j + 1])
            {
                Swap(&a[j], &a[j + 1]);
                m = j;
                flag = 1;
            }
            if (flag == 0)
            {
                break;
            }
        }

        k = m;
        //不能直接 k=j,如果数组后面数据本就有序，k会前移到有序位置，而j会走到范围的尾才结束，这样没有实现优化
    }
}
void print()
{
    for (int i = 0; i < len; i++)
    {
        printf("%d", a[i]);
    }
}

int main()
{

    print();
    printf("\n");
    Bubble_Sort(a, len);
    print();
    system("pause");
    return 0;

}