基础的排序

给你一个整数数组 nums，请你将该数组升序排列。

1.直接插入排序

将待排序的对象插入到前面已经排序好的对象中，遍历即可。

int* sortArray(int* nums, int numsSize, int* returnSize){
    //直接插入排序
    int i, j, temp;
    *returnSize = numsSize;     

    for(i = 1; i < numsSize; ++i){
        if(nums[i] < nums[i-1]){
            temp = nums[i];
            for(j = i-1; j >= 0 && nums[j] > temp; --j){
                nums[j+1] = nums[j];
            }
            nums[j+1] = temp;
        }
    }
    return nums;

2.选择排序

直接从所有中选择最小的那个，放到前面。

void swap(int *a, int *b){
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

int* sortArray(int* nums, int numsSize, int* returnSize){
    *returnSize = numsSize;

    for(int i=0; i < numsSize-1; ++i){
        int min = i;
        for(int j=i+1; j < numsSize; ++j)
            if(nums[j] < nums[min])
                min = j;
        if(min != i)
            swap(&nums[i], &nums[min]);
    }

    return nums;
}

3.希尔排序

选择不同的步长进行排序，缩短时间复杂度。

int* sortArray(int* nums, int numsSize, int* returnSize){
    int d, i, j, temp;                          //d为步长
    *returnSize = numsSize;

    for(d = numsSize/2; d >= 1; d = d/2){
        for(i = d; i < numsSize; ++i){
            if(nums[i] < nums[i-d]){
                temp = nums[i];
                for(j = i-d; j>=0 && temp<nums[j]; j-=d)
                    nums[j+d] = nums[j];
                nums[j+d] = temp;
            }
        }
    }

    return nums;
}

4.冒泡排序

选择最大的放到后面。

void swap(int *a, int *b){              
    int temp = *a;
    *a = *b;
    *b = temp;
}

int* sortArray(int* nums, int numsSize, int* returnSize){
    *returnSize = numsSize;
    
    for(int i=numsSize-1; i >= 0; --i){
        bool flag = false;
        for(int j=0; j < i; ++j){
            if(nums[j+1] < nums[j]){
                swap(&nums[j+1], &nums[j]);
                flag = true;
            }
        }
        if(flag == false)
            break;
    }

    return nums;
}

5.快速排序

int Partition(int* nums, int low, int high){
    if(low < high){
        int pivot = nums[low];
        while(low < high){
            while(low < high && nums[high] >= pivot)
                --high;
            nums[low] = nums[high];
            while(low < high && nums[low] <= pivot)
                ++low;
            nums[high] = nums[low];
        }
        nums[low] = pivot;
    }

    return low;
}

void QuickSort(int* nums, int low, int high){
    if(low >= high)
        return;
    int pivotpos = Partition(nums, low, high);
    QuickSort(nums, low, pivotpos-1);
    QuickSort(nums, pivotpos+1, high);
}

int* sortArray(int* nums, int numsSize, int* returnSize){
    QuickSort(nums, 0, numsSize-1);
    *returnSize = numsSize;

    return nums;
}

6.归并排序

void merge(int* nums, int low, int mid, int high, int* arr){
	int i, j, k;
    for(k = low; k <= high; ++k)
    	arr[k] = nums[k];
    for(i = low, j = mid+1, k = i; i <= mid && j <= high; ++k){
        if(arr[i] <= arr[j])
        	nums[k] = arr[i++];
        else
        	nums[k] = arr[j++];
    }
    while(i <= mid)
    	nums[k++] = arr[i++];
    while(j <= high)
    	nums[k++] = arr[j++];
}

void mergeSort(int* nums, int low, int high, int* arr){
	if(low < high){
        int mid = (low + high) / 2;
        mergeSort(nums, low, mid, arr);
        mergeSort(nums, mid+1, high, arr);
        merge(nums, low, mid, high, arr);
    }
}

int* sortArray(int* nums, int numsSize, int* returnSize){
	int* arr = (int*)malloc(sizeof(int) * numsSize);
    *returnSize = numsSize;
	
    mergeSort(nums, 0, numsSize-1, arr);

    return nums;
}

再补充