常见的七种排序算法

1、直接插入排序


//(1)顺序查找的
//时间复杂度
//最好:O(n)
//平均: O(n^2)
//最差:O(n^2) 逆序
//空间复杂度: O(1)
void InsertSort(int array[], size_t size){

    size_t i, j;
    int key;
    for (i = 1; i < size; i++){
        key = array[i];
        for (j = i; j > 0; j--){
            if (key >= array[j - 1]){
                break;
            }
            array[j] = array[j - 1];
        }
        array[j] = key;
    }
}
//(2)二分查找(了解)
void InsertSortBinarySearch(int array[], size_t size){
    size_t i;
    int key;

    for (i = 1; i < size; i++){
        key = array[i];
        size_t left = 0, right = i;
        while (left < right){
            size_t mid = left + (right - left) / 2;
            if (key < array[mid]){
                right = mid;
            }
            else{
                left = mid + 1;
            }
        }
        //left 要插入的位置
        //数据搬移
        for (j = i; j > left; j--){
            array[j] = array[j - 1];
        }
        array[left] = key;
    }
}
//2、希尔排序


//不稳定
//应用场景:数据量大,杂乱
void _InsertSort(int array[], size_t size, size_t gap){
    size_t i, j, k;    
    int key;

    for (k = 0; k < gap; k++){

        for (i = gap + k; i < size; i+=gap){    
        key = array[i];
        for (j = i; j > 0; j-=gap){ 
            if (key >= array[j - gap]){
                break;
            }
            array[j] = array[j - gap];
        }
        array[j] = key;
    }
}
void ShellSort(int array[], size_t size){

    size_t gap = size;
    while (1){
        gap = gap / 3 + 1;
        //按gap进行排序
        _InsertSort(array, size, gap);
        if(gap == 1){
            break;
        }
    }
}
//3、选择排序


void Swap(int *a, int *b){
    int t = *a;
    *a = *b;
    *b = t;
}
//不稳定
//时间复杂度 O(n^2)
//空间复杂度 O(1)
void SelectSort(int array[], size_t size){

    size_t minSpace = 0, maxSpace = size - 1;
    while (minSpace < maxSpace){
        size_t minPos = minSpace;
        size_t maxPos = maxSpace;
        for (size_t i = minSpace + 1; i <= maxSpace; i++){
            if (array[i] < array[minPos]){
                minPos = i;
            }
        }
        Swap(array + maxSpace, array + minSpace);
        if (minSpace == maxPos){
            maxPos = minPos;


        }
        Swap(array + minSpace, array + maxSpace);
        
        minSpace++; maxSpace--;
    }
}

//4、堆排序


//建堆
void AdjustDown(int array[], size_t size, size_t root){
    size_t left = 2 * root + 1;
    size_t right= 2 * root + 1;
    while (left < size){
        size_t max = left;
        if (right < size){
            if (array[right] > array[left]){
                max = right;
            }
        }
        if (right < size && array[right] > array[left]){
            max = right;
        }
        if (array[root] >= array[max]){
            break;
        }
        Swap(array + root, array + max);
        root = max;
        left = 2 * root + 1;
        right = 2 * root + 2;
    }
}
void HeapSort(int array[], int size){
    //建好堆之后
     
    for (int i = (size - 2) / 2; i >= 0; i--{
        AdjustDown(array, size, i);
    }
    for (int j = 0; j < size; j++){
        Swap(array, array + size - 1 - j);
        AdjustDown(array, array + size - 1 - j, 0);
    }
}

//5、冒泡排序(相邻两个元素之间交换)
void BubbleSort(int*array, int size){
    
    int i, j;
    for (i = 0; i <= size - 1; i++){
        int isChange = 0;//是否交换
        for (j = 1; j < size - i; ++j){
            if (array[j] > array[j + 1]){
                Swap(array[j], array[j + 1]);
            }
        }
        if (!isChange)//没有交换(0),已经排好
            return;
    }
}
//6、快速排序


//时间复杂度:最差:接近有序->单支数->O(n^2)
//找基准值:
//三数取中
int GetMiddleIndex(int *array, int left, int right){
    int mid = left + ((right - left) >> 1)
    if (array[left] < array[right - 1]){
        if (array[mid] < array[left])
            return left;
        else if (array[mid] > array[right - 1])
            return right - 1;
        else
            return mid;
    }
    else{
        if (array[mid] > array[left])
            return left;
        else if (array[mid] < array[right - 1])
            return right - 1;
        else
            return mid;
    }
}
void Partion1(int*array, int left, int right){
    //找基准值
    //int GetMiddleIndex(int *array, int left, int right)(三数取中法)
    //直接取最边上
    int key = array[right - 1];
    int begin = left, end = right - 1;

    while (begin < end){
        //从左往右找比基准值大的元素
        while (array[begin) <= key)
            begin++;
        //从右往左找比基准值小的元素
        while (array[end] >= key)
            end--;
        if (begin < end)
        Swap(array[begin], array[end]);
    }
    if (begin != right - 1)
    Swap(array[begin], array[right - 1]);
        return begin;
}
//挖坑法
int Partion2(int*array, int left, int right){
//找基准值
    int key = array[right - 1];
    int begin = left, end = right - 1;

    while (begin < end){
    //从左往右找比基准值大的元素
        while (begin < end && array[begin] <= key)
            begin++;
        if (begin < end){
            array[end] = array[begin];
            end--;
        }
        //从右往左找比基准值小的元素 
        while (begin < end && array[end] >= key)
            end--;
        if (begin < end){
            array[begin] = array[end];
            begin++;
        }
    }
    array[begin] = key;
    return begin;
}
//前后指针法
int Partion3(int*array, int left, int right){
//找基准值
    int key = array[right - 1];
    int cur = left, prev = cur - 1;

    while (cur < right){
        if (array[cur] < key && ++prev != cur)
            Swap(array[cur], array[prev]);
        ++cur;
    }
    if (++prev != right - 1)
        Swap(array[prev], array[right - 1]);
    return prev;
}
void QuickSort(int*array, int left, int right){
    if (right - left > 1){
//在[left,right)找基准值来划分区间,最后返回基准值在区间中的位置
        int boundary = Partion(array, left, int right){
            QuickSort(array ,left ,boundary);    
            QuickSort(array ,boundary+1 ,right);
        }
    }
}
//7、归并排序


void MergeData(int*array, int left, int middle, int right, int*temp){
    
    int begin1 = left, end1 = middle;
    int begin2 = middle, end2 = right;
    int index = left;
    
    while (begin1 < end1 && begin2 < end2){
        
        if (array[begin1] <= array[begin2])
            temp[index++] = array[begin1++];
        else
            temp[index++] = array[begin2++];
    }
    while (begin1 < end1)
        temp[index++] = array[begin1++];

    while (begin2 < end2)
        temp[index++] = array[begin2++];
}
void _MergeSort(int*array, int left, int right, int*temp){
    
    if (right - left > 1){
        
        int mid = left + ((right - left) >> 1);
        _MergeSort(array, left, mid, temp);
        _MergeSort(array, mid, right, temp);
        MergeSort(array, left, mid, right, temp);
        memcpy(array + left, temp + left, right - left);
    }
}
void MergeSort(int*array, int size){
    int*temp = (int*)malloc(sizeof(int)*size);
    if (NULL == temp){
        assert(0);
        return;
    }
    _MergeSort(array, 0, size, temp);
    free(temp);
}

测试:

#pragma once
#include<stdio.h>

typedef unsigned int size_t;

void PrintArray(int array[], size_t size){

    for (size_t i = 0; i < size; i++); {
        printf("%d", array[i]);
    }
    printf("\n");
}

void Test()
{
    int array[] = { 3, 5, 4, 7, 9, 2, 1, 0, 6 };
    size_t size = sizeof(array) / sizeof(int);

    PrintArray(array, size);

//更换不同函数名
    InsertSortBinarySearch(array, size);
    PrintArray(array, size);

}

全部代码:

#pragma once
#include<stdio.h>

typedef unsigned int size_t;

void PrintArray(int array[], size_t size){

	for (size_t i = 0; i < size; i++); {
		printf("%d", array[i]);
	}
	printf("\n");
}
//1、直接插入排序
//(1)顺序查找的
//时间复杂度
//最好:O(n)
//平均: O(n^2)
//最差:O(n^2) 逆序
//空间复杂度: O(1)
void InsertSort(int array[], size_t size){

	size_t i, j;
	int key;
	for (i = 1; i < size; i++){
		key = array[i];
		for (j = i; j > 0; j--){
			if (key >= array[j - 1]){
				break;
			}
			array[j] = array[j - 1];
		}
		array[j] = key;
	}
}
//(2)二分查找(了解)
void InsertSortBinarySearch(int array[], size_t size){
	size_t i;
	int key;

	for (i = 1; i < size; i++){
		key = array[i];
		size_t left = 0, right = i;
		while (left < right){
			size_t mid = left + (right - left) / 2;
			if (key < array[mid]){
				right = mid;
			}
			else{
				left = mid + 1;
			}
		}
		//left 要插入的位置
		//数据搬移
		for (j = i; j > left; j--){
			array[j] = array[j - 1];
		}
		array[left] = key;
	}
}
//2、希尔排序
//不稳定
//应用场景:数据量大,杂乱
void _InsertSort(int array[], size_t size, size_t gap){
	size_t i, j, k;	
	int key;

	for (k = 0; k < gap; k++){

		for (i = gap + k; i < size; i+=gap){	
		key = array[i];
		for (j = i; j > 0; j-=gap){ 
			if (key >= array[j - gap]){
				break;
			}
			array[j] = array[j - gap];
		}
		array[j] = key;
	}
}
void ShellSort(int array[], size_t size){

	size_t gap = size;
	while (1){
		gap = gap / 3 + 1;
		//按gap进行排序
		_InsertSort(array, size, gap);
		if(gap == 1){
			break;
		}
	}
}
//3、选择排序
void Swap(int *a, int *b){
	int t = *a;
	*a = *b;
	*b = t;
}
//不稳定
//时间复杂度 O(n^2)
//空间复杂度 O(1)
void SelectSort(int array[], size_t size){

	size_t minSpace = 0, maxSpace = size - 1;
	while (minSpace < maxSpace){
		size_t minPos = minSpace;
		size_t maxPos = maxSpace;
		for (size_t i = minSpace + 1; i <= maxSpace; i++){
			if (array[i] < array[minPos]){
				minPos = i;
			}
		}
		Swap(array + maxSpace, array + minSpace);
		if (minSpace == maxPos){
			maxPos = minPos;
		}
		Swap(array + minSpace, array + maxSpace);
		
		minSpace++; maxSpace--;
	}
}

//4、堆排序
//建堆
void AdjustDown(int array[], size_t size, size_t root){
	size_t left = 2 * root + 1;
	size_t right= 2 * root + 1;
	while (left < size){
		size_t max = left;
		if (right < size){
			if (array[right] > array[left]){
				max = right;
			}
		}
		if (right < size && array[right] > array[left]){
			max = right;
		}
		if (array[root] >= array[max]){
			break;
		}
		Swap(array + root, array + max);
		root = max;
		left = 2 * root + 1;
		right = 2 * root + 2;
	}
}
void HeapSort(int array[], int size){
    //建好堆之后
	 
	for (int i = (size - 2) / 2; i >= 0; i--{
		AdjustDown(array, size, i);
	}
	for (int j = 0; j < size; j++){
		Swap(array, array + size - 1 - j);
		AdjustDown(array, array + size - 1 - j, 0);
	}
}

//5、冒泡排序(相邻两个元素之间交换)
void BubbleSort(int*array, int size){
	
	int i, j;
	for (i = 0; i <= size - 1; i++){
		int isChange = 0;//是否交换
		for (j = 1; j < size - i; ++j){
			if (array[j] > array[j + 1]){
				Swap(array[j], array[j + 1]);
			}
		}
		if (!isChange)//没有交换(0),已经排好
			return;
	}
}
//6、快速排序
//时间复杂度:最差:接近有序->单支数->O(n^2)
//找基准值:
//三数取中
int GetMiddleIndex(int *array, int left, int right){
	int mid = left + ((right - left) >> 1)
	if (array[left] < array[right - 1]){
		if (array[mid] < array[left])
			return left;
		else if (array[mid] > array[right - 1])
			return right - 1;
		else
			return mid;
	}
	else{
		if (array[mid] > array[left])
			return left;
		else if (array[mid] < array[right - 1])
			return right - 1;
		else
			return mid;
	}
}
void Partion1(int*array, int left, int right){
	//找基准值
	//int GetMiddleIndex(int *array, int left, int right)(三数取中法)
    //直接取最边上
	int key = array[right - 1];
	int begin = left, end = right - 1;

	while (begin < end){
		//从左往右找比基准值大的元素
		while (array[begin) <= key)
			begin++;
		//从右往左找比基准值小的元素
		while (array[end] >= key)
			end--;
		if (begin < end)
		Swap(array[begin], array[end]);
	}
	if (begin != right - 1)
	Swap(array[begin], array[right - 1]);
		return begin;
}
//挖坑法
int Partion2(int*array, int left, int right){
//找基准值
	int key = array[right - 1];
	int begin = left, end = right - 1;

	while (begin < end){
	//从左往右找比基准值大的元素
		while (begin < end && array[begin] <= key)
			begin++;
		if (begin < end){
			array[end] = array[begin];
			end--;
		}
		//从右往左找比基准值小的元素 
		while (begin < end && array[end] >= key)
			end--;
		if (begin < end){
			array[begin] = array[end];
			begin++;
		}
	}
	array[begin] = key;
	return begin;
}
//前后指针法
int Partion3(int*array, int left, int right){
//找基准值
	int key = array[right - 1];
	int cur = left, prev = cur - 1;

	while (cur < right){
		if (array[cur] < key && ++prev != cur)
			Swap(array[cur], array[prev]);
		++cur;
	}
	if (++prev != right - 1)
		Swap(array[prev], array[right - 1]);
	return prev;
}
void QuickSort(int*array, int left, int right){
	if (right - left > 1){
//在[left,right)找基准值来划分区间,最后返回基准值在区间中的位置
		int boundary = Partion(array, left, int right){
			QuickSort(array ,left ,boundary);	
			QuickSort(array ,boundary+1 ,right);
		}
	}
}
//7、归并排序
void MergeData(int*array, int left, int middle, int right, int*temp){
	
	int begin1 = left, end1 = middle;
	int begin2 = middle, end2 = right;
	int index = left;
	
	while (begin1 < end1 && begin2 < end2){
		
		if (array[begin1] <= array[begin2])
			temp[index++] = array[begin1++];
		else
			temp[index++] = array[begin2++];
	}
	while (begin1 < end1)
		temp[index++] = array[begin1++];

	while (begin2 < end2)
		temp[index++] = array[begin2++];
}
void _MergeSort(int*array, int left, int right, int*temp){
	
	if (right - left > 1){
		
		int mid = left + ((right - left) >> 1);
		_MergeSort(array, left, mid, temp);
		_MergeSort(array, mid, right, temp);
		MergeSort(array, left, mid, right, temp);
		memcpy(array + left, temp + left, right - left);
	}
}
void MergeSort(int*array, int size){
	int*temp = (int*)malloc(sizeof(int)*size);
	if (NULL == temp){
		assert(0);
		return;
	}
	_MergeSort(array, 0, size, temp);
	free(temp);
}
#include<stdlib.h>
void Test()
{
	int array[] = { 3, 5, 4, 7, 9, 2, 1, 0, 6 };
	size_t size = sizeof(array) / sizeof(int);

	PrintArray(array, size);
	InsertSortBinarySearch(array, size);
	PrintArray(array, size);

}


 

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值