我理解的三种经典排序算法

最新推荐文章于 2022-07-13 10:07:42 发布
最新推荐文章于 2022-07-13 10:07:42 发布
阅读量184 收藏
点赞数 1
分类专栏： 算法 文章标签： eclipse java c语言 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Justice_Wzy/article/details/119768871
版权

话不多说，直接开始

1.选择排序

        原理：遍历数组选择符合条件的数进行互换。对这个某个数组进行排序，首先定住第一个数，从第二个数开始往后找，找到一个比第一个数小的数进行互换，整个数组遍历完之后，定住第二个数，从第三个数字开始往后找...以此类推。

                                           👇--------------👇

        例如：                        [ 3, 2, 5, 9, 4, 1, 10, 6]

                                        

        第二层循环结束1次后 [ 1, 2, 5, 9, 4, 3, 10, 6]

                                                    👇-------👇

        第二层循环结束2次后 [ 1, 2, 5, 9, 4, 3, 10, 6]

                                                        👇👇

        第二层循环结束3次后 [ 1, 2, 3, 9, 4, 5, 10, 6]

                                                            👇👇

        第二层循环结束4次后 [ 1, 2, 3, 4, 9, 5, 10, 6]

                                                                👇-----👇

        第二层循环结束5次后 [ 1, 2, 3, 4, 5, 9, 10, 6]

                                                                     👇-👇

        第二层循环结束6次后 [ 1, 2, 3, 4, 5, 6, 10, 9]

        第二层循环结束7次后 [ 1, 2, 3, 4, 5, 6, 9, 10]

        代码实现

        Java版

public class Demo{
    public static void main(String[] args){
        
        int[] array = {3, 2, 5, 9, 4, 1, 10, 6};
        int temp, mark;
        // 快捷版
        for(int i=0; i < array.length-1; i++){
            
            mark = i;
            
            for(int j = i+1; j < array.length; j++){
                
                if(array[j] < array[mark]){
                    mark = j;
                }
            }

            if(mark != i){
                temp = array[i];
                array[i] = array[mark];
                array[mark] = temp;
            }

        }

        /*
        蠢一点的方法：虽然代码少了，但是速度相对慢了
        for(int i=0; i < array.length-1; i++) {
        	
        	for(int j=i+1; j < array.length; j++) {
        		if(array[i] > array[j]) {
        			temp = array[i];
        			array[i] = array[j];
        			array[j] = temp;
        		}
        	}
        }
        */
    }
}

        C语言版

#include<stdio.h>
#include<stdlib.h>

int main()
{
    int array[] = {3, 2, 5, 9, 4, 1, 10, 6};
    int temp, mark;
    for(int i=0; i<7; i++)
    {
        mark = i;
        for(int j=0; j<8; j++)
        {
            if(array[mark] > array[j]) mark = j;
        }
    
        if(mark != i)
        {
            temp = array[mark];
            array[mark] = array[i];
            array[i] = temp;
        }
    }
    
    return 0;
}

 2.冒泡排序

        原理：遍历数组的过程中，比较本元素和下一个元素的大小，如果大于下一个元素，则与下一个元素互换，否则不进行处理。这样讲可能比较抽象，换一个形象一点的例子：不知道你们幼儿园或者小学还是什么时候有没有试过就是，当老师说，高的排后面，矮的排前面的时候，每个人如果看到自己比前面的人矮的时候，就会和前面的人互换位置，经历数次之后便能达到效果，这就是冒泡排序的基本原理。

        例如：

        第一次冒泡

                         [ 3, 2, 5, 9, 4, 1, 10, 6]

                          👆-👆

                         [ 2, 3, 5, 9, 4, 1, 10, 6]

                                      👆-👆

                         [ 2, 3, 5, 4, 9, 1, 10, 6]

                                          👆-👆

                         [ 2, 3, 5, 4, 1, 9, 10, 6]

                                                    👆-👆

                         [ 2, 3, 5, 4, 1, 9, 6, 10]

        第二次冒泡

                                    ↓--↓

                         [ 2, 3, 5, 4, 1, 9, 6, 10]

                                        ↓--↓

                         [ 2, 3, 4, 5, 1, 9, 6, 10]

                                                ↓--↓

                         [ 2, 3, 4, 1, 5, 9, 6, 10]

                         [ 2, 3, 4, 1, 5, 6, 9, 10]

        第三次冒泡

                         [ 2, 3, 4, 1, 5, 6, 9, 10]

                                    ↑--↑

                         [ 2, 3, 1, 4, 5, 6, 9, 10]

        第四次冒泡

                         [ 2, 3, 1, 4, 5, 6, 9, 10]

                                ↑--↑

                         [ 2, 1, 3, 4, 5, 6, 9, 10]

        第五次冒泡

                         [ 2, 1, 3, 4, 5, 6, 9, 10]

                           ↑--↑

                         [ 1, 2, 3, 4, 5, 6, 9, 10]

        代码实现

        Java版：这是小编接触冒泡排序时，书上的示例，但是觉得这个好像不太好，所以有了下面的版本

public class Demo{
    public static void main(String[] args){
        int[] array = { 3, 2, 5, 9, 4, 1, 10, 6};
        hubbleSort(array);
    } 
   public static void hubbleSort(int[] array) {
		int len = array.length;
		int temp;
		for(int i=0; i<len; i++) {
			for(int j=0; j<len-1; j++) {
				if(array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
    }
}

        Java的小编改版

public class Demo{
    public static void main(String[] args){
        int[] array = { 3, 2, 5, 9, 4, 1, 10, 6};
        my_hubbleSort(array);
    }
    public static void my_hubbleSort(int[] array) {
		int len = array.length;
		int C = 1;
		int temp;
		while(C != 0) {
			C = 0;
			for(int i=0; i < len-1; i++) {
				if(array[i+1] < array[i]) {
					temp = array[i+1];
					array[i+1] = array[i];
					array[i] = temp;
					C++;
				}
			}
		}
	}
}

        C语言版#1

#include<stdio.h>
#include<stdlib.h>

int main()
{
    int array[] = {3, 2, 5, 9, 4, 1, 10, 6};
    hubbleSort(array, 8);
    return 0;
}

void hubbleSort(int array[], int len) 
{
	int temp;
	for(int i=0; i<len; i++) 
    {
		for(int j=0; j<len-1; j++) 
        {
			if(array[j] > array[j+1]) 
            {
				temp = array[j];
				array[j] = array[j+1];
				array[j+1] = temp;
			}
		}
	}
}

        C语言版#2

#include<stdio.h>
#include<stdlib.h>

void my_hubbleSort(int array[], int len);

int main()
{
    int array[] = {3, 2, 5, 9, 4, 1, 10, 6};
    my_hubbleSort(array, 8);
    return 0;
}

void my_hubbleSort(int array[], int len) 
{
	int C = 1;
	int temp;
	while(C != 0) 
    {
		C = 0;
		for(int i=0; i < len-1; i++) 
        {
			if(array[i+1] < array[i]) 
            {
				temp = array[i+1];
				array[i+1] = array[i];
				array[i] = temp;
				C++;
			}
		}
	}
}

3.快速排序

运行原理：

        1.1把数组的第一个数作为基准key

        1.2定义两个标记，head=0和tail=数组的长度-1

        2.1在数组的尾部往前，寻找比key小的数并赋值给数组的第head个数，往前找的同时tail也往前移动( tail--)，而且head < tail ，找到后跳出循环

        2.2在数组的头部往后，寻找比key大的数并赋值给数组的第tail个数，往前找的同时head也往后移动( head++ )，而且head < tail ，找到后跳出循环

        3 把2.1和2.2放入while(head < tail）{} 的循环中，最后跳出循环时令 数组的第head个数 = 基准key，并return head，把这个功能封装在函数selectStandard(int[] array, int head, int tail){}中

        4. 定义quickSort() 递归调用 selectStandard函数

        quickSort(int[] array, int head, int tail){

                if(head < tail){

                        int standard = return head的函数;

                        quickSort(array, head, standard-1);

                        quickSort(array, standard+1, tail);

                }

        }

        例如

                 

                head                       tail

                  ↓                            ↓

                [ 3, 2, 5, 9, 4, 1, 10, 6]

                  ↑

                key

第一次        key = 3

1.        (   1 比 3 小

                head             tail

                   ↓                  ↓

                 [ 3, 2, 5, 9, 4, 1, 10, 6]

-------------------------------------------------------

                head             tail

                  ↓                  ↓

                [ 1, 2, 5, 9, 4, 1, 10, 6]

-------------------------------------------------------

2.        （   5  比  3 大

                       head      tail

                          ↓          ↓

                [ 1, 2, 5, 9, 4, 1, 10, 6]

------------------------------------------------------

                       head      tail

                          ↓          ↓

                [ 1, 2, 5, 9, 4, 5, 10, 6]

------------------------------------------------------

3.

                       head      tail

                          ↓          ↓

                [ 1, 2, 5, 9, 4, 5, 10, 6]

------------------------------------------------------

未找到比3小的数，最终

         [ 1, 2, 3, 9, 4, 5, 10, 6]

        并返回2

第二次的1，数组0~1正序无需排序

第二次的2，数组3~7依旧乱序

                     head           tail

                       ↓                ↓

         [ 1, 2, 3, 9, 4, 5, 10, 6]

                       ↑

                     key

key = 9

        1.    ( 6  比 9 小)

                     head           tail

                       ↓                ↓

         [ 1, 2, 3, 9, 4, 5, 10, 6]

---------------------------------------------------

                     head           tail

                       ↓                ↓

         [ 1, 2, 3, 6, 4, 5, 10, 6]

--------------------------------------------------

2.           ( 10 比 9 大

                                head  tail

                                    ↓    ↓

         [ 1, 2, 3, 6, 4, 5, 10, 6]

------------------------------------------------

                                head  tail

                                    ↓    ↓

         [ 1, 2, 3, 6, 4, 5, 10, 10]

-------------------------------------------------

3.        无比9小的数，最终

         [ 1, 2, 3, 6, 4, 5, 9, 10]

        并return 6

第三次的1右边正序

第三次的2左边乱序

                    head  tail

                       ↓      ↓

         [ 1, 2, 3, 6, 4, 5, 9, 10]

                       ↑

                     key

key  =  6

1.     5 比6小

                    head  tail

                       ↓      ↓

         [ 1, 2, 3, 6, 4, 5, 9, 10]

----------------------------------------------

                    head  tail

                       ↓      ↓

         [ 1, 2, 3, 5, 4, 5, 9, 10]

----------------------------------------------

2.        未找到比6大的数，结果

         [ 1, 2, 3, 5, 4, 6, 9, 10]

        并return5

第四次

                 head  tail

                      ↓   ↓

         [ 1, 2, 3, 5, 4, 6, 9, 10]

同理。。。。。

结果

         [ 1, 2, 3, 4, 5, 6, 9, 10]

        代码实现

        Java版

public class Demo{
public static void main(String[] args){
        int[] array = { 3, 2, 5, 9, 4, 1, 10, 6};
        quickSort(array, 0, array.length-1);
    }
 
	public static int selectStandard(int[] array, int head, int tail) {
		int key = array[head];
		while(head < tail) {
			
			while(head < tail) {
				if(array[tail] < key) {
					array[head] = array[tail];
					break;
				}
				tail--;
		    }
			
			while(head < tail) {
				if(array[head] > key) {
					array[tail] = array[head];
					break;
				}
				head++;
			}
			
		}
		array[head] = key;
		return head;
	}
	
	public static void quickSort(int[] array, int head, int tail) {
		
		if(head < tail) {
			int standard = selectStandard(array, head, tail);
			quickSort(array, head, standard-1);
			quickSort(array, standard+1, tail);
		}
	}
}

        C语言版

#include <stdio.h>
#include <stdlib.h>

void quickSort(int array[], int head, int tail);
int selectStandard(int array[], int head, int tail);

int main()
{
    int array[] = { 3, 2, 5, 9, 4, 1, 10, 6};
    quickSort(array, 0, 7);
    return 0;
}
 
int selectStandard(int array[], int head, int tail) 
{
	int key = array[head];
	while(head < tail) 
    {
		while(head < tail) 
        {
			if(array[tail] < key) 
            {
				array[head] = array[tail];
				break;
			}
			tail--;
		}
			
		while(head < tail) 
        {
			if(array[head] > key) 
            {
				array[tail] = array[head];
				break;
			}
			head++;
		}
			
	}
	array[head] = key;
	return head;
}
	
void quickSort(int array[], int head, int tail) 
{
	if(head < tail) 
    {
		int standard = selectStandard(array, head, tail);
		quickSort(array, head, standard-1);
		quickSort(array, standard+1, tail);
	}
}

快速排序总结：其实小编只知道快速排序的运行原理，但是并不知道快速排序为啥快。知其然也知其所以然，但是不知其所以然的所以然。

小编还有许多需要改进的地方，望各路高手指出并进行指导。

Justice_Wzy
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
经典排序算法（C语言实现）.zip
10-10
本项目“经典排序算法（C语言实现）”提供了C语言版本的多种常见排序算法实现，对于学习和理解排序算法有极大的帮助。下面我们将深入探讨这些排序算法的核心原理及其C语言实现。 1. 冒泡排序（Bubble Sort） 冒泡...
三种线性排序算法Java实现
08-07
学习和理解这三种排序算法，不仅可以提高编程能力，也有助于在面对不同问题时选择合适的排序方法，提升算法效率。在实际项目中，可以根据数据特点灵活运用这些算法，优化程序性能。通过阅读并理解这些Java源代码，你...
算法
aikenqiu5098的博客
11-26 1158
排序算法(一)3种简单排序(选择，冒泡，插入) 　　排序是数据处理中十分常见且核心的操作，虽说实际项目开发中很小几率会需要我们手动实现，毕竟每种语言的类库中都有n多种关于排序算法的实现。但是了解这些精妙的思想对我们还是大有裨益的。本文简单温习下最基础的三类算法：选择，冒泡，插入。 　　先定义个交换数组元素的函数，供排序时调用 /** * 交换...
三种经典排序算法
sangjunhong的博客
12-29 405
1.选择排序 /** * 选择排序 * @param nums * @return */ public static int[] sort(int[] nums){ for(int i=0;i<nums.length-1;i++){ for (int j=i+1;j<nums.length;j++){ if(nums[i]>nums[j]){
三大经典排序算法
qq_43069222的博客
03-21 305
冒泡排序 function bubble(arr){ //外层循环控制比较的轮数 for(var i=0;i<arr.length-1;i++){ //内层循环控制每轮比较的次数 for(var j=0;j<arr.length-1-i;j++){ //如果当前项大于后一项就交换 if(arr[j]>arr[j+1]){ var temp=arr[j...
经典的三种排序算法
ZLH_HHHH的博客
11-22 1058
归并排序：归并排序。可以说分治策略用在了排序问题上。我们每次将数组分成两半。递归的排序这两半。然后用线性时间将其合并起来。变成一个完整的有序数组。复杂度分析：T(n)=2T(n2)+O(n)T(n)=2T(\frac{n}{2})+O(n)显然最多展开log2nlog_2n层。所以总时间复杂度：O(nlogn)O(nlogn)堆排序：如果不知道堆这个数据结构的同学。可以自行学习。（百度一大把）通过不
【算法】三大经典排序算法
qq_53499304的博客
03-19 620
算法之三大经典排序汇总
C语言程序练习，包含几种经典的排序算法
05-08
- 通过阅读《算法导论》、《C Primer Plus》等经典书籍，可以深入理解排序算法的原理和实现。 - 实践是学习编程的最佳方式，通过编写和调试代码，可以加深对排序算法的理解。 总之，C语言提供的底层控制能力使得...
Python实现经典排序算法.rar
最新发布
01-11
本资源"Python实现经典排序算法.rar"包含了一系列用Python编写的经典排序算法的源代码，这对于学习和理解排序算法的原理及其在Python中的实现极具价值。 首先，让我们来探讨一下排序算法的基本概念。排序算法是一种...
MFC 基于C＋＋语言的三种基本排序算法的动态演示
08-30
通过这个教学演示，学习者不仅可以掌握C++和MFC的基本用法，还能深入理解排序算法的原理和实现。对于初学者来说，这是一个很好的实践项目，可以提高编程能力和算法理解。同时，对于有一定经验的开发者，这个项目也...
【排序算法一】3大经典的排序算法：冒泡排序、选择排序、插入排序
Mike_honor的博客
07-13 678
前言：冒泡排序、选择排序、插入排序是3大最基础的排序算法，其实算法只要有一个清晰的思路，那么算法的代码实现就会非常简单、有逻辑。下面，小编带领大家去分析一下怎样去理解这三种排序算法的思路才更能深刻掌握它们，另外，非常欢迎读者对文章内容进行批评指正，谢谢!目录1、冒泡排序1.1算法思路1.2代码实现2、选择排序2.1算法思路2.2代码实现3、插入排序3.1算法思路3.2代码实现 .........
经典的三种排序方法
zhonzxad的博客
04-10 750
经典的三种排序算法归并排序：归并排序。可以说分治策略用在了排序问题上。我们每次将数组分成两半。递归的排序这两半。然后用线性时间将其合并起来。变成一个完整的有序数组。复杂度分析：T(n)=2T(n2)+O(n)显然最多展开log2n层。所以总时间复杂度：O(nlogn)堆排序：如果不知道堆这个数据结构的同学。可以自行学习。（百度一大把）通过不停到调整堆来做到排序。每次将堆顶最小元素与堆最中后一个元素...
三大经典排序 | 冒泡排序，选择排序，快速排序
huhaishen的专栏
04-18 2348
前言 排序算法是日常使用最频繁的一个算法，生活中也很常见什么排队呀按照高矮次序呀，分数按照一个从高到低的排序等等，但是如果是要设计出来面对基数很大又要很快的排序方法这就是需要很大难度了，先给大家看看排序的种类有哪些，和其对应的时间空间复杂度。 最后一栏有个稳定性给看官解释一下： 稳定：如果 a 原本在 b 前面，而 a=b，排序之后 a 仍然在 b 的前面。 不稳定：如果 a 原本在 b 的前面，而 a=b，排序之后 a 可能会出现在 b 的后面。 今天主要给大家介绍三种排序方法，并附上可.
用5分钟熟悉3种经典排序算法，浅显易懂！
weixin_34021089的博客
08-09 313
若干年前pony在腾讯产品暨技术峰会上就说过：“我们希望的产品经理是从技术晋升而来的。”技术是实施手段，产品最终还是要靠技术来实现，产品还是不能远离技术。 那么不想通过枯燥的代码来理解几大排序算法，本文通过动态可视化图来解析冒泡排序、选择排序及插入排序。 排序算法最终目的是让无序的数据组合变成有序的数据组合。 一、冒泡法 从字面上能理解， “冒泡”即...
十大经典排序算法系列(一) 三种冒泡排序之 普通 js版本
11-24 166
Bubble Sort     原理 1 比较相邻索引的元素(0,1)(1,2)(2,3)依据条件交换位置.以此类推到最后一个 2 得出数组中最大的元素, 并交换位置到最后一个索引位. 3 再让总索引值减 1, 让最大元素不进入下轮比较. 4 重复上面直到结果 时间复杂度 O(n2) 'use strict' var arr = [0, 333, 1, 12, 123, 22, 2, ...
常见的三种排序算法
qq_44986938的博客
11-29 3890
常见的三种排序算法：冒泡排序，选择排序，插入排序 - 冒泡排序（稳定）： 重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 //两两比较 int main() { int i,j; int temp; int buf[N]={78,78,56,78,89}; for(i=0; i<N-1; i++) //决定里面的循环循环几轮 { for(j=0; j<N-1-i;
三种常用的排序算法
傲笑风的博客
08-23 3645
总结常用的三种排序方法： 排序一、选择排序二、冒泡法三、快速排序 一、选择排序 选择排序是每个元素与其后面的元素逐一进行比较和交换，时间复杂度是：O(n*n)。 def selectionSort(nums): n = len(nums) if n<2: return nums for i in range(n-1): for j in range(i+1, n): if nums[i]>nums[j]:
三种简单排序算法及其对比
max
03-04 615
三种简单排序算法及其对比 代码： class ArraySort {     private long[] a;     private int nElems;     public ArraySort(int max)     {         a = new long[max];         nElems=0;     }     public
十大经典排序算法总结（Java实现+动画）
热门推荐
meibenxiang的博客
06-19 5万+
最近在梳理《数据结构与算法》的内容，在网上看了几篇不错的文章，现在根据自己的理解重新整理一下十大经典排序算法。实际生产中，最好的算法一定是结合数据集本身的特点（大小，长度，是否已经基本有序等等）来选择的，不要拘泥于算法本身。 我参考的文章有：https://www.cnblogs.com/guoyaohua/p/8600214.html，https://blog.csdn.net/liang_g...
C语言探索：8种经典排序算法详解及稳定性分析
深入浅出-C语言8种经典排序算法是一份针对C语言初学者的实用教程，主要讲解了在C语言中常见的八种排序算法，包括冒泡排序、选择排序、插入排序、快速排序以及它们各自的特性。这里我们逐一剖析： 1. 冒泡排序：冒泡...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值