010 排序: 冒泡 选择

 

/*
目录:
   一 冒泡排序   
   二 选择排序
*/

 

一 冒泡排序

void BubbleSort(int *p, int nCount)
{
    int nOutLoop, nInLoop;

    nOutLoop = 0;                    // 外层循环 : 计数变量
    while (nOutLoop < nCount - 1)    // 控制次数 - 外层循环
    {
        nInLoop = 0;                // 每次内层 : 循环开始 - 数组首部
        while (nInLoop < nCount - 1 - nOutLoop)    // 控制次数 : 内层循环 - 比较次数
        {
            if (p[nInLoop] > p[nInLoop + 1])    // 数据比较 : 排序顺序 - 从小到大
            {
                int nTemp = p[nInLoop];
                p[nInLoop] = p[nInLoop + 1];
                p[nInLoop + 1] = nTemp;
            }
            ++nInLoop;
        }
        ++nOutLoop;
    }
}


int main(int argc, char *argv[])
{
    int nNum[] = {1, -2, 9, 5, 22, -1};
    int nCount = sizeof(nNum) / sizeof(nNum[0]);
    
    BubbleSort(nNum, nCount);

    int nLoop = 0;
    while (nLoop < nCount)
    {
        printf("%d ", nNum[nLoop]);
        ++nLoop;
    }

    return 0;
}

/*
// result
-2 -1 1 5 9 22
*/

 

/*
    冒泡算法: 
        1 循环次数: 外层(n-1); 内层(n-1-外层次数)。
        2 冒泡: 把每次内层循环结果(最大/最小值)，放在最后面。
        3 顺序: 正序/倒序。
        
        
        3 顺序: 正序/倒序 。
          交换: if{}判断后数值，放最后面。 
                1 大于交换(大数放后): 正序。
                2 小于交换(小数放后); 倒序。
*/

 

 

二 选择排序

void SelectSort(int *p, int nCount)
{
    int nOutLoop, nMin, nInLoop;

    nOutLoop = 0;
    while (nOutLoop < nCount - 1)
    {
        nMin = nOutLoop;            // 默认最小 : 外层循环 - 数组头部
        nInLoop = nOutLoop + 1;     // 每次内层 : 循环开始 - 默认值最小值+1 
        while (nInLoop < nCount)    // 控制次数 : 内层循环 - 比较次数
        {
            if (p[nMin] > p[nInLoop])    // 数据比较 : 排序顺序 - 从小到大
            {
                nMin = nInLoop;
            }
            ++nInLoop;
        }

        if (nMin != nOutLoop)    // 数据交换 : 最小值 - 数组头部
        {
            int nTemp = p[nMin];
            p[nMin] = p[nOutLoop];
            p[nOutLoop] = nTemp;
        }

        ++nOutLoop;
    }
}

int main(int argc, char *argv[])
{
    int nNum[] = {1, -2, 9, 5, 22, -1};

    int nCount = sizeof(nNum) / sizeof(nNum[0]);
    SelectSort(nNum, nCount);

    int nLoop = 0;
    while (nLoop < nCount)
    {
        printf("%d ", nNum[nLoop]);
        ++nLoop;
    }

    return 0;
}
/*
// result
-2 -1 1 5 9 22
*/

 

/*
1 循环次数: 外层(n-1); 内层(n-1-外层次数)。
2 选择: 把每次内层循环结果(最大/最小值)，放在最前面。
3 顺序: 正序/倒序。


1 循环次数:
    问题1: 内循环为什么不是 nInLoop < nCount - 1 - nOutLoop;
    答案1: j = i + 1; j不是从零开始。
        
3 顺序: 正序/倒序 。
  交换: if{}判断后数值，放最前面。
        1 大于交换(小数放前): 正序。
        2 小于交换(小数放后); 倒序。
*/

 

 

/*
排序算法 - 算法本身特性决定的
    冒泡排序: 每次比较后，不相等进行交换。
    选择排序: 每次比较后，不相等先指向，最后交换。

顺序:
    冒泡: 大于交换(交换最大，放在最后) 
    选择: 大于交换(指向最小，放在最前)
*/