常见的七种排序算法

最新推荐文章于 2023-10-15 19:05:32 发布
最新推荐文章于 2023-10-15 19:05:32 发布
阅读量448 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41445507/article/details/83307018
版权

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);

}


 

Ronin'Mr Zeng
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
7种VB排序算法
05-12
摘要:VB源码,算法相关,排序算法　　七种常见的VB排序算法示例程序，演示了冒泡排序法、插入排序法、Bucket排序法、选择排序法、Shell排序法、快速排序法、Heap排序法这7种常见的VB排序算法示例，选择对应算法，可能查看对应结果，十分有参考价值的实用程序。
vb内部排序7大算法
OrganicNeptune的博客
12-22 6918
信息技术 VB程序整理排序算法（以数组a(n)降序为例）1、冒泡排序（Bubble Sort）1.0 性质总结1.1 基本思想1.2 具体步骤1.3 代码实现1.4改进的冒泡排序2、直接选择排序(Straight Select Sort)2.0 性质总结2.1 基本思想2.2 具体步骤2.3 代码实现3、直接插入排序(Straight Insertion Sort)3.0 性质总结3.1 基本思想...
PHP 实现冒泡排序算法 （php7.1数组赋值）
dmedaa的博客
11-07 438
冒泡排序 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 算法原理 比较相邻的元素。如果第一个比第二个大，就交换他们
VB实现6大排序算法---动态过程展示（建议收藏）
「 刘一哥与GIS的故事」
06-25 2979
VB实现6大排序算法：插入排序、基数排序、快速排序、希尔排序、选择排序、归并排序。可以随机生成指定个数的数据，显示排序过程，给出排序结果，计算排序算法消耗的时间。 生成随机数： 排序结果： 插入排序： 选择排序： 归并排序： 快速排序： 希尔排序： 基数排序： 核心代码 VERSION 1.0 CLASS BEGIN MultiUse = -1 'True Persistable = 0 'NotPersistable DataBindingBehavior = 0 '.
VB-快速排序
BXA
08-10 3999
快速排序（QuickSort） 快速排序 像归并排序，快速排序是分而治之算法。它选择一个元素作为支点和周围的采摘支点给定的数组分区。 有迹象表明，挑支点以不同的方式快速排序的许多不同的版本。 总是挑一个元素作为支点。 总是挑最后一个元素为支点（下实现） 选择一个随机元素作为支点。 挑选位数作为支点。 在快速排序的关键过程是分区（）。分区目标，给定一个数组和X数组作为支点的元素，将X个
java常见八种排序算法
06-29
本篇文章将详细探讨Java中常见的八种排序算法，每一种都有其独特的特性和适用场景。 1. **冒泡排序(Bubble Sort)** 冒泡排序是最基础的排序算法之一，通过不断交换相邻的逆序元素来逐步完成排序。它的时间复杂度为...
python实现五种常见排序算法
12-21
以下是用Python实现的五种常见排序算法： 1. 冒泡排序（Bubble Sort）： ```python def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+...
Java常见的排序算法
最新发布
03-27
Java中常见的排序算法有以下几种： 冒泡排序（Bubble Sort）：通过比较相邻元素的大小，将较大的元素逐渐向后移动，直到整个序列有序。 选择排序（Selection Sort）：每次遍历数组，找到最小（或最大）的元素，将其...
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
几种常见的排序算法及其实现
11-20
排序算法是计算机科学中最基本且常见的算法之一。排序的目标是将一组数据按照升序或降序的方式进行排列。在实际编程中，选择适当的排序算法对于提高程序性能和效率至关重要...下面简要介绍几种常见的排序算法及其实现。
VB中三种排序方法
12-11
用冒泡法，选择法，比较法三种方法对一组数进行排序。
VB排序代码（7种经典排序算法已优化）
08-05
VB排序代码---7种经典排序算法已优化---可记录各种排序的时间及循环次数。
七种常见的VB排序算法示例程序
01-11
七种常见的VB排序算法示例程序 包含常见的几种算法,只不过用VB来实现
VBA七种排序算法
Eternal_Whispers的博客
10-19 1862
VBA排序算法
从vb的角度看几种简单的排序法
热门推荐
张伟光
07-29 1万+
老农看代码，比如老农看一亩地里的一棵苗，可以用哪一行，哪一列来形容，放在计算机里，即用i，j表示，然后老农所看到的一亩地，就可以用a（i）来表示，如果要形容这是我家的地，就需要再上升一个档次，用a（J）来形容了，可以无限延伸下去……. 一、冒泡排序法（左为原理图，右为代码） 二、选择排序法（左为原理图，右为代...
VBA中数组的排序
m0_74737305的博客
10-15 1459
使用冒泡排序算法对一个整数数组进行升序排序。冒泡排序的基本思想是比较数组中相邻的元素，并交换它们，直到整个数组变得有序。
从VB来看-InsertionSort（VB插入排序）
BXA
08-04 4852
插入排序（Insertion Sort） 它是通过不断将未排序数据插入有序序列，一次次循环加入待排序数据扩充有序序列部分，来达到最终的排序目的。很像我们平时发牌时一张张整牌的过程：我的习惯是先把最左边第一张作为有序部分，之后每拿取一张牌进行大小比较，按照升序或降序的方式整理好手里的牌（构建整个有序部分)。 在众多算法的使用对比中，通常在量级小于千的情况下使用插入排序还是令人满意的。 时间复杂度
排序算法解析：12种常见排序算法详解
"12种排序算法详解，包括插入排序、二分插入排序、希尔排序、选择排序、冒泡排序、鸡尾酒排序、快速排序、堆排序、归并排序、桶排序、计数排序和基数排序。每种算法都有基本介绍、原理分析、图解/演示、代码实现和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值