经典排序算法笔记

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量1.1w 收藏
点赞数
分类专栏： 排序算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43914658/article/details/109703326
版权

冒泡排序

冒泡排序是所有排序算法中最简单、最基本的一种。冒泡排序法的思路就是交换排序，通过相邻元素比较交换来达到排序的目的，其算法实现与“冒泡”过程相似。
时间复杂度：O(n^2)
空间复杂度：O(k)

//package com.wu.demo;

public class BubbleSort {
	public static void main(String[] args) {
		int[] numbers = {1,3,6,4,8,2,7,10,9,5,5};
		System.out.println("冒泡排序前：");
		for(int e : numbers) {
			System.out.print(e+" ");
		}
		System.out.println();
		for(int i = 1;i<numbers.length;i++) { // 最多遍历数组长度减一就可以了
			for(int j = 0;j<=numbers.length-i-1;j++) { // 最大值往数组后推(冒泡) 当然有效范围也要减一
				if(numbers[j]>numbers[j+1]) {
					// 交换两个数值
					numbers[j] = numbers[j]^numbers[j+1];
					numbers[j+1] = numbers[j]^numbers[j+1];
					numbers[j]  = numbers[j]^numbers[j+1];
				}
			}
		}
		System.out.println("冒泡排序后：");
		for(int e : numbers) {
			System.out.print(e+" ");
		}
	}
}

结果显示：

在这里插入图片描述

选择排序

也是比较简单的排序算法，思路比较直观，选择排序算法在每一步选取最小值来重新排序，从而达到排序的目的。
时间复杂度：O(n^2)
空间复杂度：O(k)

//package com.wu.demo;

public class SelectionSort {
	public static void main(String[] args) {
		int[] numbers = {1,3,6,4,8,2,7,10,9,5,5};
		System.out.println("选择排序前：");
		for(int e : numbers) {
			System.out.print(e+" ");
		}
		System.out.println();
		for(int i = 0;i < numbers.length-1;i++) { 
			int temp = i; // 记录最小值的下标
			for(int j = i+1;j<numbers.length;j++) {
				if(numbers[j]<numbers[temp]) {
					temp = j;
				}
			}
			if(temp != i) {
				numbers[temp] = numbers[temp]^numbers[i];
				numbers[i] = numbers[temp]^numbers[i];
				numbers[temp] = numbers[temp]^numbers[i];
			}
		}
		System.out.println("选择排序后：");
		for(int e : numbers) {
			System.out.print(e+" ");
		}
	}
}

结果显示：

在这里插入图片描述

插入排序

通过对未排序的数据逐个插入合适的位置而完成的排序工作，插入排序算法的思路也比较简单，使用较为广泛。
时间复杂度：O(n^2)
空间复杂度：O(k)

//package com.wu.demo;

public class InsertSort {
	public static void main(String[] args) {
		int[] numbers = {1,3,6,4,8,2,7,10,9,5,5};
		System.out.println("插入排序前：");
		for(int e : numbers) {
			System.out.print(e+" ");
		}
		System.out.println();
		for(int i = 1;i<numbers.length;i++) {
			int temp = numbers[i];
			int j = i - 1;
			for(;j>=0;j--) {
				if(numbers[j] > temp) {
					numbers[j+1]  = numbers[j];
				}
				else {
					break; // 此处有坑
				}
			}
			numbers[j+1] = temp;
		}
		System.out.println("插入排序后：");
		for(int e : numbers) {
			System.out.print(e+" ");
		}
	}
}

结果显示：

在这里插入图片描述

希尔排序

整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
时间复杂度：O(n^(3/2))
空间复杂度：O(k)

//package com.wu.demo;

public class ShellSort{	
	public static void main(String[] args) {
		int[] numbers = {1,3,6,4,8,2,7,10,9,5,5};
		System.out.println("希尔排序前：");
		for(int e : numbers) {
			System.out.print(e+" ");
		}
		System.out.println();
		int gap = numbers.length;
		while(gap>1) {
			gap /= 2;
			// 对于每一组遍历
			for(int i = 0;i<gap;i++) {
				// 对该组数字未排序部分遍历
				for(int j = i+ gap;j<numbers.length;j += gap) {  // 此处有坑
					// 记录未排序部分的第一个数字
					int temp = numbers[j];
					// 以下为已排序部分的遍历
					int k = j-gap;
					for(; k >= 0;k-=gap) {  
						if(temp < numbers[k]) {
							numbers[k+gap] = numbers[k];
						}else{
							break;	// 此处有坑
						}
					}
					numbers[k+gap] = temp;
				}
			}
		}
		System.out.println("希尔排序后：");
		for(int e:numbers) {
			System.out.print(e+" ");
		}
	}
}

结果显示：

在这里插入图片描述

快速排序

和冒泡算法类似，都是基于交换排序的思想，但是快速排序对冒泡排序进行了改进，从而具有更高的执行效率。
时间复杂度：O(nlogn)
空间复杂度：O(k)

//package com.wu.demo;

public class QuickSort {
	public static void quickSort(int[] numbers,int left,int right) {
		if(right <= left) {
			return;
		}
		// 返回分界值下标
		int border  = partSort(numbers,left,right);
		// 递归调用左边部分
		quickSort(numbers,left,border-1);
		// 递归调用右边部分
		quickSort(numbers,border+1,right);
	}
	
	
	public static int partSort(int[] numbers,int left,int right) {
		// 确定基准值
		int base = numbers[left];
		while(left < right) {
			// 右边找到其小于等于base的相应下标   这里先从队尾开始
			while(numbers[right] >= base && right>left) {
				right--;
			}
			// 将right位置的值赋值给left位置
			numbers[left] = numbers[right]; 
			// 左边找到其大于等于base的相应下标
			while(numbers[left] <= base && left<right) {
				left++;
			}
			// 将left位置的值赋值给right位置
			numbers[right] = numbers[left];
		}
		// 最后还要将base赋值给left位置
		numbers[left] = base;
		return left;
	}
	public static void main(String[] args) {
		int[] numbers = {1,3,6,4,8,2,7,10,9,5,5};
		System.out.println("快速排序前：");
		for(int e : numbers) {
			System.out.print(e+" ");
		}
		System.out.println();
		QuickSort.quickSort(numbers,0,numbers.length-1);
		System.out.println("快速排序后：");
		for(int e:numbers) {
			System.out.print(e+" ");
		}
	}
}

结果显示：

在这里插入图片描述

归并排序

归并排序 (merge sort) 是一类与插入排序、交换排序、选择排序不同的另一种排序方法。归并的含义是将两个或两个以上的有序表合并成一个新的有序表。归并排序有多路归并排序、两路归并排序 , 可用于内排序，也可以用于外排序。这里仅对内排序的两路归并方法进行讨论。

时间复杂度：O(nlogn)
空间复杂度：O(n)

//package com.wu.demo;
public class MergerSort{
	public static void mergerSort(int[] numbers , int left , int right){
	        if(left < right){
	            int mid = (left + right)/2;
	            mergerSort(numbers,left,mid);
	            mergerSort(numbers,mid+1,right);
	            Merger(numbers,left,mid,right);
	        }
	
	    }
    public static void Merger(int[] numbers ,int left ,int mid , int right){
        int[] temp = new int[right - left + 1]; // 辅助数组
        int i = left;
        int j = mid + 1;
        int k = 0;
        while(i<=mid && j<=right){
            if(numbers[i] < numbers[j]){
                temp[k++] = numbers[i++];
            }else{
                temp[k++] = numbers[j++];
            }
        }
        while(i<=mid){
            temp[k++] = numbers[i++];
        }
        while(j<=right){
            temp[k++] = numbers[j++];
        }
        System.arraycopy(temp,0,numbers,left,right- left + 1);
    }
	public static void main(String[] args){
	        int[] numbers = {1,3,6,4,8,2,7,10,9,5,5};
	        System.out.println("归并排序前：");
	        for(int e : numbers) {
	            System.out.print(e+" ");
	        }
	        System.out.println();
	        MergerSort.mergerSort(numbers,0,numbers.length-1);
	        System.out.println("归并排序后：");
	        for(int e:numbers) {
	            System.out.print(e+" ");
	        }
	    }
)

结果显示：

在这里插入图片描述

所有算法消耗时间测试：

package com.wu;

import java.util.Random;
public class MyArrayList{
    /**
     * 冒泡排序
     * @param numbers 待排序的数组
     * @return 已经排序好的数组
     */
    public static void bubbleSort(int[] numbers) {
        for(int i = 1;i<numbers.length;i++) { // 最多遍历数组长度减一就可以了
            for(int j = 0;j<=numbers.length-i-1;j++) { // 最大值往数组后推(冒泡) 当然有效范围也要减一
                if(numbers[j]>numbers[j+1]) {
                    // 交换两个数值
                    numbers[j] = numbers[j]^numbers[j+1];
                    numbers[j+1] = numbers[j]^numbers[j+1];
                    numbers[j]  = numbers[j]^numbers[j+1];
                }
            }
        }
    }

    /**
     * 选择排序
     * @param numbers 待排序数组
     * @return 已经排序好的数组
     */
    public static void seclectionSort(int[] numbers) {
        for(int i = 0;i < numbers.length-1;i++) {
            int temp = i; // 记录最小值的下标
            for(int j = i+1;j<numbers.length;j++) {
                if(numbers[j]<numbers[temp]) {
                    temp = j;
                }
            }
            if(temp != i) {
                numbers[temp] = numbers[temp]^numbers[i];
                numbers[i] = numbers[temp]^numbers[i];
                numbers[temp] = numbers[temp]^numbers[i];
            }
        }
    }

    /**
     * 插入排序
     * @param numbers 待排序的数组
     * @return 已经排序好的数组
     */
    public static void insertSort(int[] numbers) {
        for(int i = 1;i<numbers.length;i++) {
            int temp = numbers[i];
            int j = i - 1;
            for(;j>=0;j--) {
                if(numbers[j] > temp) {
                    numbers[j+1]  = numbers[j];
                }
                else {
                    break; // 此处有坑
                }
            }
            numbers[j+1] = temp;
        }
    }

    /**
     * 希尔排序
     * @param numbers 待排序的数组
     * @return 已经排序好的数组
     */
    public static void shellSort(int[] numbers) {
        int gap = numbers.length;
        while(gap>1) {
            gap /= 2;
            // 对于每一组遍历
            for(int i = 0;i<gap;i++) {
                // 对该组数字未排序部分遍历
                for(int j = i+ gap;j<numbers.length;j += gap) {  // 此处有坑
                    // 记录未排序部分的第一个数字
                    int temp = numbers[j];
                    // 以下为已排序部分的遍历
                    int k = j-gap;
                    for(; k >= 0;k-=gap) {
                        if(temp < numbers[k]) {
                            numbers[k+gap] = numbers[k];
                        }else{
                            break;	// 此处有坑
                        }
                    }
                    numbers[k+gap] = temp;
                }
            }
        }
    }

    /**
     * 快速排序
     * @param numbers 待排序的数组
     * @param left 数组的起始位置
     * @param right 数组的结尾位置
     */
    public static void quickSort(int[] numbers,int left,int right) {
        if(right <= left) {
            return;
        }
        // 返回分界值下标
        int border  = partSort(numbers,left,right);
        // 递归调用左边部分
        quickSort(numbers,left,border-1);
        // 递归调用右边部分
        quickSort(numbers,border+1,right);
    }
    public static int partSort(int[] numbers,int left,int right) {
        // 确定基准值
        int base = numbers[left];
        while(left < right) {
            // 右边找到其小于等于base的相应下标   这里先从队尾开始
            while(numbers[right] >= base && right>left) {
                right--;
            }
            // 将right位置的值赋值给left位置
            numbers[left] = numbers[right];
            // 左边找到其大于等于base的相应下标
            while(numbers[left] <= base && left<right) {
                left++;
            }
            // 将left位置的值赋值给right位置
            numbers[right] = numbers[left];
        }
        // 最后还要将base赋值给left位置
        numbers[left] = base;
        return left;
    }

    /**
     * 归并排序
     * @param numbers
     * @param left
     * @param right
     */
    public static void MergerSort(int[] numbers , int left , int right){
        if(left < right){
            int mid = (left + right)/2;
            MergerSort(numbers,left,mid);
            MergerSort(numbers,mid+1,right);
            Merger(numbers,left,mid,right);
        }

    }
    public static void Merger(int[] numbers ,int left ,int mid , int right){
        int[] temp = new int[right - left + 1]; // 辅助数组
        int i = left;
        int j = mid + 1;
        int k = 0;
        while(i<=mid && j<=right){
            if(numbers[i] < numbers[j]){
                temp[k++] = numbers[i++];
            }else{
                temp[k++] = numbers[j++];
            }
        }
        while(i<=mid){
            temp[k++] = numbers[i++];
        }
        while(j<=right){
            temp[k++] = numbers[j++];
        }
        System.arraycopy(temp,0,numbers,left,right- left + 1);
    }

    public static void main(String[] args) {
        int[] numbers = new int[100000];
        Random random = new Random(0);
        for(int i = 0 ; i<100000;i++) {
            numbers[i] = random.nextInt(1000)+1;
        }
        int[] temp = new int[100000];

        System.arraycopy(numbers, 0, temp, 0, temp.length);
        long start1 = System.currentTimeMillis();
        MyArrayList.bubbleSort(temp);
        long end1 = System.currentTimeMillis();
        System.out.println("冒泡排序时间花销："+(end1-start1)+"ms");

        System.arraycopy(numbers, 0, temp, 0, temp.length);
        long start2 = System.currentTimeMillis();
        MyArrayList.seclectionSort(temp);
        long end2 = System.currentTimeMillis();
        System.out.println("选择排序时间花销："+(end2-start2)+"ms");

        System.arraycopy(numbers, 0, temp, 0, temp.length);
        long start3 = System.currentTimeMillis();
        MyArrayList.insertSort(temp);
        long end3 = System.currentTimeMillis();
        System.out.println("插入排序时间花销："+(end3-start3)+"ms");

        System.arraycopy(numbers, 0, temp, 0, temp.length);
        long start4 = System.currentTimeMillis();
        MyArrayList.shellSort(temp);
        long end4 = System.currentTimeMillis();
        System.out.println("希尔排序时间花销："+(end4-start4)+"ms");

        System.arraycopy(numbers, 0, temp, 0, temp.length);
        long start5 = System.currentTimeMillis();
        MyArrayList.quickSort(temp,0,temp.length-1);
        long end5 = System.currentTimeMillis();
        System.out.println("快速排序时间花销："+(end5-start5)+"ms");

        System.arraycopy(numbers,0,temp,0,temp.length);
        long start6 = System.currentTimeMillis();
        MyArrayList.MergerSort(temp,0,temp.length-1);
        long end6 = System.currentTimeMillis();
        System.out.println("归并排序时间花销："+(end6-start6)+"ms");

    }
}

运行结果：

在这里插入图片描述

一夜星尘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cuda 排序算法笔记
jacke121的专栏
03-30 2682
Thrust是cuda自带的c++库，cuda安装好之后，这个库也默认安装好了。 这个库基本是采用类似STL的接口方式，因此对于开发者非常友好，开发者不再需要关注内存与显存相关的问题了。 排序入门例子 #include <thrust/host_vector.h> #include <thrust/device_vector.h> #include <thrust/generate.h> #include <thrust/sort.h> #incl..
排序算法笔记1
08-04
这篇笔记主要讨论了不同类型的排序算法，包括它们的时间复杂度、空间复杂度以及稳定性。下面将详细阐述这些知识点。 首先，我们来看时间复杂度。时间复杂度是衡量算法效率的重要指标，它描述了算法运行时间与输入...
十大经典排序算法【算法思想+图解+代码】【数据结构与算法笔记】
魚肉的博客
01-22 5872
排序算法还不懂？十大经典排序算法详解。【算法思想+图解+代码】冒泡排序，插入排序，选择排序，快速排序……看完你绝对能手撕各种排序算法。
排序算法笔记
qq_36438102的博客
02-09 348
选择排序、冒泡排序、插入排序、归并排序、堆排序、快排
【尚硅谷】Java数据结构与算法笔记07 - 排序算法
知不足而奋进，望远山而前行
01-13 1万+
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较 相邻元素的值, 若发现逆序则交换, 使值较大的元素逐渐从前移向后部, 就象水底下的气泡一样逐渐向上冒。优化。
算法导论：排序算法笔记
imcy的博客
11-29 376
排序算法相关笔记
排序算法笔记--摩尔投票算法
Jing_Hua
07-15 1528
摩尔投票算法是一种用于在数组中查找出现次数超过一半的元素的有效算法。算法的核心思想是利用候选元素和计数器进行投票，通过消除不同元素之间的抵消来找到出现次数超过一半的元素。
【算法】C#实现经典排序算法总结（附动图）
好学若饥，谦卑若愚。
01-31 3129
自行整理的C#常见算法笔记。
leetcode排序算法-学习笔记
roymustang的博客
02-09 1127
文章目录1简介稳定性：就地性：自适应性：2冒泡算法2.1算法简介2.2效率优化3 快速排序3.1 算法解析3.2算法特性3.3 算法优化Tail Call ：随机基准数：practise剑之40 最小k个数冒泡算法--超出时间限制快速排序 1简介 稳定性： 根据 相等元素 在数组中的 相对顺序 是否被改变，排序算法可分为「稳定排序」和「非稳定排序」两类。 「稳定排序」在完成排序后，不改变 相等元素在数组中的相对顺序。例如：冒泡排序、插入排序、归并排序、基数排序、桶排序。 「非稳定排序」在完成排序后，相等素
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
经典算法笔记1
08-03
两种经典算法是Prim算法和Kruskal算法。Prim算法从一个节点开始，逐步扩展最小权重边来构建MST；Kruskal算法则每次选择最小权重且不形成环的边，直到添加n-1条边形成树。 【单源最短路（不含BFS）】 单源最短路...
算法笔记1_算法笔记PAT_算法笔记_
10-01
《算法笔记1_算法笔记PAT_算法笔记》是一份针对浙江大学计算机科学与技术学院机试以及PAT（Programming Ability Test）考试的学习参考资料，主要以C/C++编程语言为载体，深入讲解了各种算法的设计与实现。...
算法笔记3_算法笔记_浙大_
09-30
排序算法如冒泡排序、插入排序、选择排序、快速排序、归并排序以及堆排序；搜索算法如二分查找、深度优先搜索（DFS）和广度优先搜索（BFS）。 2. **数据结构**：数据结构是算法的基础，笔记中会详细讲解线性结构...
算法笔记.胡凡
03-23
《算法笔记.胡凡》是一本深入浅出的算法学习资料，主要针对想要提升算法能力的读者，无论你是初学者还是有一定基础的程序员，都能从中受益。这本书通过丰富的实例和清晰的代码，帮助读者理解并掌握各种算法的核心...
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 619
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 676
后缀表示法。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 271
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
秋招力扣刷题——从前序与中序遍历序列构造二叉树
qq_50604294的博客
07-04 213
给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。：两种代码的结束条件以及分割的右区间处理方式不同，后者更容易理解一点。
读书笔记1
08-08
这篇读书笔记主要涵盖了《算法》一书中的部分内容，特别是经典八大排序算法的介绍。笔记作者是软工181班的林鑫，于2020年4月15日至6月2日阅读并整理了相关知识。 1. 冒泡排序 (Bubble Sort) 冒泡排序是一种基础的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值