冒泡排序与快速排序

交换排序包括直接选择排序与快速排序两类

一,冒泡排序

    估计是大家做练习题,笔试最多的排序算法了.

   

void bubbleSort(int data[], int len)
    {
        for(int i = 1; i <= len - 1; i++) //每交换一轮,均会有一个最大的冒泡到最右边.
        {
            for(int j = 0; j < len - 1; j++)
            {
                if(data[j] > data[j + 1])
                {
                    int tmp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = tmp;
                }
            }
        }
    }

 

void bubbleSort(int data[], int len)
    {
//利用标志位来控制循环早点结束,若遍历一次交换次数为0说明是有序的,可以提前结束.
        bool swapped = true;
        while(swapped)
        {
            swapped = false;
            for(int j = 0; j < len - 1; j++)
            {
                if(data[j] > data[j + 1])
                {
                    int tmp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = tmp;
                    swapped = true;
                }
            }
        }
    }

 

 

 

二,快速排序

   目前比较流行,也是公认较好的排序算法,其利用了分治的算法思想,首先选取一个pivot,将小于pivot的记录放在左边,其余放在右边,并不断递归对左右两边的序列进行快速排序.

void quickSort(int data[], int left, int right)
    {
        if(left >= right) return;
        int pivotIndex = (left + right)/2;
        pivotIndex = partition(data, left, right, pivotIndex);
        quickSort(data, left, pivotIndex - 1);
        quickSort(data, pivotIndex + 1, right);
    }
//将小于data[pivotIndex]的放在左边,其余放在右边,并返回中间位置   
int partition(int data[], int left, int right, int pivotIndex)
    {
        int storeIndex = left;
        int pivot = data[pivotIndex];
        data[pivotIndex] = data[right];
        data[right] = pivot;
        for(int i = left; i < right; i++)
        {
            if(data[i] < pivot)
            {
                int tmp = data[storeIndex];
                data[storeIndex] = data[i];
                data[i] = tmp;
                storeIndex++;
            }
        }
        data[right] = data[storeIndex];
        data[storeIndex] = pivot;
        return storeIndex;
    }