数据结构与算法-排序

冒泡排序

1. 第一个数与第二个数对比，第一个数大于第一个数就调换，接着第二个数跟第三个数对比，第二个数大于第三个数就调换，如此类推到最后一个数。
   
   
2. 第一个数与第二个数对比，第一个数大于第一个数就调换，接着第二个数跟第三个数对比，第二个数大于第三个数就调换，如此类推到倒数第二个数。
   
3. 如此类推……
   
   其实每一次遍历完成就是将当前区间内的最大值往最前靠。
   时间复杂度为O(n2)，空间复杂度为O(1)
   

void BubbleSort(int* pArray, int nCount) {
    if(pArray == NULL || nCount == 0) {
        return ;
    }
    for(int i=0; i<nCount; i++) {
        for(int j=0; j<nCount-1-i; j++) {
            if(pArray[j] > pArray[j+1]) {
                int nTmp = pArray[j];
                pArray[j] = pArray[j+1];
                pArray[j+1] = nTmp;
            }
        }
    }
}

插入排序

• 将数组分为两个区间，一个区间为有序区间，另一个区间为无序区间，从无序区间拿一个一个数跟有序区间的数对比，然后插入到相应到位置上。
  

1. 从第二个数开始，第二个数跟第一个数做对比，插入到相应位置，接着第三个数跟第一、二个数对比，插入到相应位置，如此类推到最后一个数
   
   
2. 插入之前，需要将当前的数之前的数与插入位置的数往后移动一位，空出一个位置插入当前的数
   时间复杂度为O(n2)，空间复杂度为O(1)
   

void InsertionSort(int* pArray, int nCount) {
    if(pArray == NULL || nCount == 0) {
        return ;
    }
    for(int i=1; i<nCount; i++) {
        int nTmp = pArray[i];
        int j = i-1;
        for(; j>=0; j--) {
            if(nTmp < pArray[j]) { //数往后移动一位
                pArray[j+1] = pArray[j];
            }
            else {
                break;
            }
        }
        //插入当前的数
        pArray[j+1] = nTmp;
    }
}

选择排序

• 每次找到无序区间内的最小值，调换到有序数组的区间内。
  

1. 从第一位开始找到数组里面的最小值，与第一位的数调转
   
2. 从第二位开始找到数组里面的最小值，与第二位的数调转
   
3. 如此类推到最后一位数
   
   时间复杂度为O(n2)，空间复杂度为O(1)

void SelectionSort(int* pArray, int nCount) {
    if(pArray == NULL || nCount == 0) {
        return ;
    }
    for(int i=0; i<nCount-1; i++) {
        int nMin = pArray[i];
        int nMinIndex = i;
        for(int j=i+1; j<nCount; j++) {
            if(nMin > pArray[j]) {
                nMin = pArray[j];
                nMinIndex = j;
            }
        }
        pArray[nMinIndex] = pArray[i];
        pArray[i] = nMin; 
    }
}