算法02

荷兰国旗问题，给定一个数组，将小于num的数放在左边，等于num的数放在中间，大于num的数放在右边

code：

 void hlflags(int *l, int num, int size)//第一个参数是一个数组，第二个参数是比较值num，第三个参数是数组的长度
 {
    int p1 = -1, p2 = size;  //下标小于等于p1都是小于num的数字，p2相反
    int index = 0;
    for (int i = 0; i < 10; i++)
        {
            cout << l[i] << "   ";
        }
    cout << endl;
    while (index != p2)
        {
            if (l[index] == num)
                {
                    index++;
                }
            else if (l[index] < num)
                {
                    int item = l[index];
                    l[index] = l[++p1];
                    l[p1] = item;
                    index++;    //小于的时候这个下标也要加1
                }
            else
                {
                    int item = l[index];
                    l[index] = l[--p2];
                    l[p2] = item;
                }
            cout << "index:" << index << " p1:" << p1 << "  p2:" << p2 << endl;
        }
}

理解了荷兰国旗问题之后我们就可以使用荷兰国旗的思想来实现快速排序：

经典快排：

void quicksort(int *arr, int l, int r)//第一个参数是数组，第二个参数是左边界，第三个参数是右边界
{
    if (l < r)
    {
        int a = partition(arr, l, r);
        quicksort(arr, l, a - 1);
        quicksort(arr, a + 1, r);
    }
}

int partition(int *arr, int l, int r)
{
    int less = l - 1;
    int more = r;
    while(l < more)
    {
        if (arr[l] < arr[r])
        {
            swap(arr[l++], arr[++less]);
        }
        else if (arr[l] > arr[r])
        {
            swap(arr[l], arr[--more]);
        }
        else
        {
            l++;
        }
    }
    swap(arr[r], arr[more]);
    return more;
}

经典快速排序每次递归只能解决一个数，我们可以对做一下改进，每次递归的时候返回一个数组区间，该区间内的数的大小等于被比较的数

改进后的快速排序：

void quicksort(int *arr, int l, int r)
{
    if (l < r)
    {
        int *a = partition(arr, l, r);
        quicksort(arr, l, a[0]);
        quicksort(arr, a[1]+1, r);
        delete[] a;
    }
}

int* partition(int *arr, int l, int r)
{
    int less = l - 1;
    int more = r;
    while(l < more)
    {
        if (arr[l] < arr[r])
        {
            swap(arr[l++], arr[++less]);
        }
        else if (arr[l] > arr[r])
        {
            swap(arr[l], arr[--more]);
        }
        else
        {
            l++;
        }
    }
    swap(arr[r], arr[more]);
    int *a = new int[2];
    a[0] = less;
    a[1] = more;
    return a;
}

上面两种快速排序由于被比较的数每次都是最后一个，所以以上两种快速排序和数据状况有关系，所以我们可以采用随机数的方式每次随机选择被比较的数

随机快速排序：

void quicksort(int *arr, int l, int r)
{
    if (l < r)
    {
        int *a = partition(arr, l, r);
        quicksort(arr, l, a[0]);
        quicksort(arr, a[1]+1, r);
        delete[] a;
    }
}

int* partition(int *arr, int l, int r)
{
    int less = l - 1;
    int more = r;

    srand(time(NULL));
    int t = int(rand()) % (r - l + 1) + l;
    swap(arr[t], arr[r]);
    //这三行代码就实现了随机快速排序
    while(l < more)
    {
        if (arr[l] < arr[r])
        {
            swap(arr[l++], arr[++less]);
        }
        else if (arr[l] > arr[r])
        {
            swap(arr[l], arr[--more]);
        }
        else
        {
            l++;
        }
    }
    swap(arr[r], arr[more]);
    int *a = new int[2];
    a[0] = less;
    a[1] = more;
    return a;
}

根据期望值，这种随机快速排序的时间复杂度是 log(n)*n ,额外空间复杂度是 log(n).

接下来讲一下堆排序，一个堆就是一个完全二叉树，不了解二叉树没有关系，我们可以使用数组来模拟一颗二叉树，直接上代码：

堆排序：

void heapinsert(int *arr, int len)  //数组   数组的长度  作用数形成一个大根堆
{
    for (int i = 1; i < len; i++)
    {
        int index = i;
        while (index > 0)
        {
            if (arr[index] > arr[(index - 1) / 2])
            {
                swap(arr[index], arr[(index - 1) / 2]);
                index = (index - 1) / 2;
                continue;
            }
            break;
        }
    }
}

void heapify(int *arr, int index,int heapsize)  //数组，数组中哪个数不满足大根堆的下标  数组长度
{
    int left = index * 2 + 1;
    while (left < heapsize)
    {
        int largest = left + 1 < heapsize&&arr[left + 1] > arr[left] ? left + 1 : left;
        largest = arr[index] > arr[largest] ? index : largest;
        if (largest == index)
        {
            break;
        }
        swap(arr[index], arr[largest]);
        index = largest;
        left = index * 2 + 1;
    }
}

void heapsort(int *arr, int len)  //数组  数组长度
{
    if (len <= 2)
    {
        return;
    }
    heapinsert(arr, len);
    swap(arr[0], arr[--len]);
    while (len >= 1)
    {
        heapify(arr, 0, len);
        swap(arr[0], arr[--len]);
    }
}