mysorts

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>

#define SIZE 10

using namespace std;

void bubble(int *num)
{
    for (int i = 0; i < SIZE; ++i)
    {
        int flag = 0;
        for (int j = 0; j < SIZE - i - 1; ++j)
        {
            if (num[j] > num[j+1])        // 不可以为>=,否则为不稳定的排序
            {
                swap(num[j+1], num[j]);
                flag = 1;
            }
        }

        if (!flag)
        {
            break;
        }
    }
}

void insert(int *num)
{
    for (int i = 1; i < SIZE; ++i)
    {
        int value = num[i];
        int j = i - 1;
        for (; j >= 0; --j)         // >=
        {
            if (num[j] > value)
            {
                num[j+1] = num[j];
            }
            else
            {
                break;
            }
        }

        num[j+1] = value;
    }
}

void select(int *num)
{
    for (int i = 0; i < SIZE - 1; ++i)
    {
        int min = i;
        for (int j = i + 1; j < SIZE; ++j)
        {
            if (num[j] < num[min])
            {
                min = j;
            }
        }

        if (min != i)
        {
            swap(num[min], num[i]);
        }
    }
}

#if 1
void merge_sort(int *num, int mid, int left, int right)
{
    int *temp_num = (int *)malloc((right - left + 1) * sizeof(int));

    int i = left, j = mid + 1;
    int k = 0;
    for (;i <= mid && j <= right;)
    {
        if (num[i] < num[j])
        {
            temp_num[k++] = num[i++]; 
        }
        else
        {
            temp_num[k++] = num[j++];
        }
    }

    if (i > mid)
    {
        while (j <= right)
        {
            temp_num[k++] = num[j++];
        }
    }
    else
    {
        while (i <= mid)
        {
            temp_num[k++] = num[i++];
        }    
    }
    
    // memcpy((num + left), temp_num, sizeof(temp_num));             // error ?
    memcpy((num + left),temp_num,(right - left + 1)*sizeof(int));    // correct !  
    // ！！！ num+left 而不是num，因为这个num是最一开始传进来的数组！！！

    free(temp_num);
}
#endif

#if 0
void merge_sort(int a[],int middle,int left,int right)
{
    int *tmp = (int*)malloc((right - left + 1)*sizeof(int));

	int i = left;
	int j = middle + 1;
    int k = 0;

	while(1)
	{
	    if((i > middle) || (j > right))
	    {
			break;
	    }

		if (a[i] > a[j])
		{
			tmp[k++] = a[j++];
		}
		else
		{
			tmp[k++] = a[i++];
		}
	}

	if (i > middle)
	{
		while(j <= right)
		{
			tmp[k++] = a[j++];
		}
	}
	else
	{
		while(i <= middle)
		{
			tmp[k++] = a[i++];
		}
	}

	memcpy((a + left),tmp,(right - left + 1)*sizeof(int));

	free(tmp);

	return  ;
}
#endif

void merge(int *num, int left, int right)
{
    int p = left + (right - left) / 2;

    if (left >= right)
    {
        return;
    }

    merge(num, left, p);
    merge(num, p+1, right);
    merge_sort(num, p, left, right);
}

int quick_sort(int num[], int left, int right)
{
    int i = left, j = left;               // left而不是0
    int k = right;
 
    for (; j < right; ++j)
    {
        if (num[j] < num[k])
        {
            if (i != j)
            {
                swap(num[i], num[j]);
            }
            ++i;
        }       
    }

    if (i != right)
    {
        swap(num[i], num[right]);
    }

    return i;
}

void quick(int num[], int left, int right)
{
    // int q = left + (right - left) / 2;     // ！！！由quick_sort返回区分点的位置！！！

    if (left >= right)
    {
        return;
    }

    int q = 0;

    q = quick_sort(num, left, right);
    quick(num, left, q - 1);                  // ！！！一定是q-1而不能是q！！！
    quick(num, q + 1, right);
}

int main()
{
    srand(time(nullptr));
    int nums[SIZE];

    for (int i = 0; i < SIZE; i++)
    {
        nums[i] = rand() % SIZE;
        cout << nums[i] << " ";
    }
    cout << endl;

    // bubble(nums);
    // insert(nums);
    // select(nums);
    // merge(nums, 0, SIZE-1);
    // quick(nums, 0, SIZE - 1);

    cout << "   orderrd" << endl;
    for (int i = 0; i < SIZE; i++)
    {
        // nums[i] = rand() % 10;
        cout << nums[i] << " ";
    }
    cout << endl;

    return 0;
}