第五部分 排序算法综合介绍

已于 2022-10-29 16:22:07 修改
阅读量422 收藏 2
点赞数 2
分类专栏： 计算机基础知识 文章标签： 排序算法
于 2020-05-08 16:22:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiayinggudeng/article/details/105999638
版权

目录

一、插入排序

     1、直接插入排序

     2、二分插入排序

     3、希尔排序

二、交换排序

    1、冒泡排序

     2、快速排序

三、选择排序

     1、简单选择排序

      2、堆排序

四、归并排序

五、编程题

排序算法平均时间复杂度空间复杂度稳定性备注
直接插入排序O(n^2)O(1)1小规模数据
冒泡排序O(n^2)O(1)1小规模数据
简单选择排序O(n^2)O(1)0小规模数据
希尔排序O(log_2{n})O(1)0中等大小规模数据
快速排序O(log_2{n})O(logn)0n 很大时，且有序程度高时
堆排序O(log_2{n})O(1)0n 很大时，且有序程度低时
归并排序O(log_2{n})O(n)1n 比较小时选取
基数排序O(log_2{RB})O(log_2{RB})1R为0-9，B为基数（个十百）
计数排序（桶排序）O(n)O(n)0范围比较小

一、插入排序

      从无序区中选取第一个元素，按关键字大小，插入有序区适当位置。

     1、直接插入排序

      将无序区中的元素，通过顺序查找，依次和有序区的元素进行比较，并插入适当位置。

      Java 版本

	public static int[] InsertSort(int[] nums) {
		
		for(int i=1; i<nums.length; i++) {
			
			int temp = nums[i], j = 0;
			for(j=i; temp < nums[j-1] && j>0; j--)
				nums[j] = nums[j-1];
			
			nums[j] = temp;
		}
		return nums;
	}

      Python 版本 

def sortArray(self, nums):

    for i in range(1, len(nums)):
        temp = nums[i]
        index = i
        for j in range(i, 0, -1):
            if temp < nums[j-1]:
                nums[j] = nums[j-1]
                index = j - 1
        nums[index] = temp
    return nums

     2、二分插入排序

      插入的位置，采用二分查找确定。

      Java 版本

	public static int[] BinaryInsertSort(int[] nums) {
		
		for(int i=1; i<nums.length; i++) {
			
			int temp = nums[i], j = 0;
			int left=0, right=i-1;
			
	        while(left <= right){
	        	
	            int mid=(left+right)/2;
	            if (temp > nums[mid])
	                left = mid+1;
	            else
	            	right = mid-1;
	        }
	        
			for(j=i; j>left; j--) 
				nums[j] = nums[j-1];
			
			nums[j] = temp;			
		}
		return nums;
	}

      Python 版本 

def function(nums):
    for i in range(1, len(nums)):

        temp = nums[i]
        index = i
        low = 0
        high = i-1

        while low <= high:
            mid = int((low + high) / 2)

            if nums[mid] < temp:
                low = mid + 1
            else:
                high = mid - 1

        for j in range(i, low, -1):
            nums[j] = nums[j - 1]
            index = j - 1
        nums[index] = temp

     3、希尔排序

      将代拍数组分成若干小组，间隔为步长 d 的元素在同一组，每个小组内部进行直接插入排序。逐步减少步长，重复，直至步长为1，并且数组有序。

	public static int[] sort(int[] nums){
		
		int n = nums.length;
		for(int gap=n/2; gap>0; gap = gap/2){
			
			for(int j = gap; j < n; j++){
				
				for(int i=j; i >= gap && nums[i-gap] > nums[i]; i -= gap){
					
					int temp = nums[i-gap];
					nums[i-gap] = nums[i];
					nums[i] = temp;
				}
			}
		}
		return nums;
	}

二、交换排序

    1、冒泡排序

      将待排数组从后往前两两比较相邻元素，逆序交换，直到数组有序。

      Java 版本

	public static int[] BubbleSort(int[] nums) {
		
		for(int i=0; i<nums.length; i++) {

			for(int j=nums.length-1; j>i; j--) {  // for(int j=i; j>0; j--) {
				
				if(nums[j-1] > nums[j]) {
					int temp = nums[j];
					nums[j] = nums[j-1];
					nums[j-1] = temp;
				}
			}
		}
		return nums;
	}

      Python 版本

def sortArray(self, nums):

    for i in range(0, len(nums)):
        for j in range(len(nums)-1, i-1, -1):
            if nums[j] < nums[j-1]:
                nums[j], nums[j-1] = nums[j-1], nums[j]
    
    return nums

     2、快速排序

      从数组中选取一个元素为基准元素，让每个元素依次和基准元素比较，比基准元素大的，交换到基准元素之后，比基准元素小的，交换到基准元素之前。

      再分别对基准元素前后的两组元素，重复上述操作，直到有序。

      Java 版本

// 递归快排
    public static void RecursiveSort(int[] nums, int low, int high) {
		
		if(low >= high)
			return;
		
		int mid = partition(nums, low, high);
		RecursiveSort(nums, low, mid-1);
		RecursiveSort(nums, mid+1, high);
	}
	
// 栈快排
	public static void StackSort(int[] nums, int low, int high) {
		
		Stack<Integer> stack = new Stack<Integer>();
		
		stack.push(high);
		stack.push(low);
		
		while(!stack.isEmpty()) {
			
			int left = stack.pop();
			int right = stack.pop();
			
			int mid = partition(nums, left, right);
			
			if(left < mid) {
				stack.push(mid-1);
				stack.push(left);
			}
			
			if(mid < right) {
				stack.push(right);
				stack.push(mid+1);
			}
		}
	}
	
	public static int partition(int[] nums, int low, int high) {
		
		int index = low;
		
		for(int i=low; i<high; i++) {
			
			if(nums[i] < nums[high]) {
				int temp = nums[i];
				nums[i] = nums[index];
				nums[index++] = temp;
			}
		}
		int temp = nums[high];
		nums[high] = nums[index];
		nums[index] = temp;
		return index;
	}

      Python 版本

def stack_sort(nums, low, high):
    stack = []

    stack.append(high)
    stack.append(low)

    while len(stack) > 0:

        left = stack.pop()
        right = stack.pop()
        mid = partition(nums, left, right)

        if left < mid:
            stack.append(mid - 1)
            stack.append(left)

        if mid < right:
            stack.append(right)
            stack.append(mid + 1)


def recursive_sort(nums, low, high):
    if low >= high:
        return

    mid = partition(nums, low, high)
    recursive_sort(nums, low, mid-1)
    recursive_sort(nums, mid+1, high)


def partition(nums, low, high):
    index = low
    for i in range(low, high):
        if nums[i] < nums[high]:
            nums[index], nums[i] = nums[i], nums[index]
            index += 1
    nums[index], nums[high] = nums[high], nums[index]
    return index

三、选择排序

     1、简单选择排序

      每次从无序区中选择最小的元素，和数组的第 i 个元素进行交换，直到全部有序。

      Java 版本

	public static int[] SelectSort(int[] nums) {
		
		for(int i=0; i<nums.length; i++) {
			int index = i;
			for(int j=i; j<nums.length; j++) {
				
				if(nums[index] > nums[j]) {
					index = j;
				}
			}
			int temp = nums[index];
			nums[index] = nums[i];
			nums[i] = temp;
		}
		return nums;
	}

       Python 版本

def sortArray(self, nums):

    for i in range(0, len(nums)):
        temp = nums[i]
        index = i
        for j in range(i+1, len(nums)):
            if temp > nums[j]:
                temp = nums[j]
                index = j
        nums[i], nums[index] = nums[index], nums[i]

    return nums

      2、堆排序

      将待排数组，看成完全二叉树，每次都通过比较父节点和左右子结点的大小，将最大/小的元素调整到根节点。重复，直到数组有序。

      Java 版本

    public static void heapSort(int[] nums) {
    	
        for (int i = (nums.length - 1)/2; i >= 0; i--)
            adjustHeap(nums, i, nums.length);

        for (int i = nums.length - 1; i > 0; i--) {

            int temp = nums[i];
            nums[i] = nums[0];
            nums[0] = temp;

            adjustHeap(nums, 0, i);
        }
    }

    private static void adjustHeap(int[] nums, int parent, int length) {  // 小根堆

        int temp = nums[parent];
        int maxlChild = 2 * parent + 1;

        while (maxlChild < length) {
            
            if (maxlChild+1 < length && nums[maxlChild] < nums[maxlChild+1])
            	maxlChild++;

            if (temp >= nums[maxlChild])
                break;

            nums[parent] = nums[maxlChild];

            parent = maxlChild;
            maxlChild = 2 * maxlChild + 1;
        }
        nums[parent] = temp;
    }

       Python 版本

def adjust_heap(self, nums, parent, length):
    temp = nums[parent]

    max_child = 2 * parent + 1

    while max_child < length:

        if max_child + 1 < length and nums[max_child] < nums[max_child+1]:
            max_child += 1
        
        if temp >= nums[max_child]:
            break

        nums[parent] = nums[max_child]
        parent = max_child
        max_child = max_child * 2 + 1
    
    nums[parent] = temp


def sortArray(self, nums):

    half = len(nums) // 2

    for i in range(half, -1, -1):
        adjust_heap(nums, i, len(nums))
    
    for i in range(len(nums)-1, 0, -1):
        nums[0], nums[i] = nums[i], nums[0]
        adjust_heap(nums, 0, i)

    return nums

四、归并排序

      通过递归思想，将数组分成两半，然后，递归合并两个有序子数组合。

      Java 版本

    public static int Merge(int[] nums, int left, int right) {
    	
    	if(left == right) return 0;
    		
		int mid = (left + right) / 2;
		
		int count = Merge(nums, left, mid) + Merge(nums, mid+1, right);
		count = megerSort(nums, left, mid, right, count);
		
		return count;
    }

	private static int megerSort(int[] nums, int left, int mid, int right, int count) {
		
		int len_l = mid - left + 1, len_r = right - mid;
		
		int[] l = new int[len_l];
		int[] r = new int[len_r];
		
		for(int i=0, k=left; i<len_l; i++)
			l[i] = nums[k++];
		
		for(int i=0, k=mid+1; i<len_r; i++)
			r[i] = nums[k++];
		
		int i, j, k;
		for(i=len_l-1,j=len_r-1,k=right; i>=0 && j>=0; k--) {
			
			if(l[i] > r[j]) {
				count += j + 1;  // 求逆序对，只多了这一行代码
				nums[k] = l[i--];
			}
			else
				nums[k] = r[j--];			
		}
		
		for(int x=i; x>=0; x--)
			nums[k--] = l[x];

		for(int x=j; x>=0; x--)
			nums[k--] = r[x];

		return count;
	}

      Python 版本

def merge_sort(nums, low, mid, high):
    left = []
    right = []

    for i in range(low, mid+1):
        left.append(nums[i])
    for i in range(mid+1, high+1):
        right.append(nums[i])

    index_l = 0
    index_r = 0
    index_nums = low

    while index_l < len(left) and index_r < len(right):
        if left[index_l] > right[index_r]:
            nums[index_nums] = right[index_r]
            index_r += 1
        else:
            nums[index_nums] = left[index_l]
            index_l += 1
        index_nums += 1

    if index_l < len(left):
        nums[index_nums] = left[index_l]
        index_l += 1
        index_nums += 1
    if index_r < len(right):
        nums[index_nums] = right[index_r]
        index_r += 1
        index_nums += 1
    print(nums)


def merge(nums, low, high):
    if low == high:
        return

    mid = int((low + high) / 2)
    merge(nums, low, mid)
    merge(nums, mid + 1, high)
    merge_sort(nums, low, mid, high)

五、编程题

问题描述：在一组字符串中，找到所有具有某个字符串前缀字符串，比如application、apple、eyes、cats等。如果要匹配的字符串是app，则符合匹配条件的有application、apple。

博客链接：百度面试题-字符串前缀匹配（二分法） - neyer - 博客园 

夏影孤灯
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java基础系列-《流程控制--循环结构》
09-08 1406
前言： 张浩Java考试成绩未达到自己的目标。为了表明自己勤奋学习的决心，他决定写一百遍“好好学习，天天向上！”根据前面学习的内容我们知道System.out.println(“好好学习，天天向上！”)可以将这句话打印出来，但是现在是要打印100次，那是不是我们需要写100次呢？答案肯定是否定的，在java中我们要避免写重读的代码，我们要尽量“偷懒”让代码能重复使用。那如何才能写一次输出语句，让它运行100次呢？接下来我们就要学习流程控制中的--循环结构。 一、什么是循环结构 1.循环简单理解就是重读
针对所有常见排序算法的综合比较分析
qq_43519428的博客
12-13 1348
今天，秋风瑟瑟，略感微凉，废话不说，正文开始： 首先除去已知的时间复杂度和空间复杂度之外，需要了解到的一个重要的概念就是排序的稳定性。 稳定性定义：相同个体的元素再排序前后，相对位置不发生改变，则代表该算法具备稳定性，反之则不具备稳定性。 了解概念之后，我们逐一分析各种排序算法的稳定性！！！ 选择排序： 工作原理：从待排序的数据中挑选出最小或最大的元素交换存储到开始的位置，再从剩余的数据中挑选最大或最小的元素放置已排序位置之后，依次类推，每次都需要两两之间相互比较,直到最后一个元素，结束排序。 因此时间复杂
leetcode双指针系列1： LC26删除有序数组中的重复项，LC674最长连续递增序列，LC27移除元素，LC80 删除有序数组中的重复项II，LC 283 移动零，LC75 颜色分类
Bismarckczy的博客
05-18 214
双指针思想通常用来解决数组或者字符串的子序列问题， 使用双指针，左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。 在循环中，判断条件都是右指针所在位置，如果满足，会对右指针位置进行处理，然后放到左指针位置。 leetcode 26 删除有序数组中的重复项 leetcode 75 颜色分类 leetcode 80 删除有序数组中的重复项 II leetcode 283 移动零 都可以用上述的思想解决问题。即，确定好已经处理好的部分，和将要处理的部分。 ............
排序算法综合整理
HappyCode
05-16 856
排序算法综合整理 文章目录排序算法综合整理一、直接插入排序思想：二、希尔排序思想：三、归并排序怎样求逆序数四、快速排序五、堆排序六、计数排序七、桶排序八、基数排序 一、直接插入排序思想： 从小到大排序：从第二个数开始，若非递增，则插入前面有序序列中，该位置前面一位小于它，后面一位大于它； 二分插入排序：因为前面序列有序，则可用二分找到该位置； 用了二分可以减少比较大小的次数 撸代码： #include<stdio.h> int main() { int a[10]={56
常见七大排序算法总结--超详细适合初学者
qq_41219243的博客
07-26 1620
一、排序算法的概念以及应用 （一）概念 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。 （二）分类 内部排序：数据元素全部放在内存中的排序。 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。 （三）应用 1.淘宝京东商品的销量排名 2.各大高校的综合实力排名 3.以及各大城市GDP排名 4.外卖评分以及百度竞价排名 （四）常见的排序算法 二、排序算法的实现（升序排列） （一）
C语言排序法介绍-综合文档
05-22
交换法排序，也被称为冒泡排序，是一种简单直观的排序算法。它通过比较相邻元素并交换位置来逐步将最大的元素“冒”到数组的末尾。在给定的代码中，使用两个嵌套循环实现这一过程。外层循环控制排序轮数，内层循环...
C语言排序法介绍.rar-综合文档
05-11
在"**C语言排序法介绍.docx**"文档中，你将会找到关于这些排序算法的详细解释、伪代码和可能的C语言实现示例，帮助你进一步理解和实践这些知识。通过学习和实践，你可以提升编程技能，为解决更复杂的计算问题打下...
基本排序算法综合实验.docx
05-07
3. 对每组记录，使用插入排序算法排序 4. 重复步骤 2 和 3，直到增量 h 为 1 ShellSort1 算法的时间复杂度是 O(n log n)，比 InsertSort1 和 InsertSort2 更高效。 本实验报告涵盖了基本排序算法的实验条件、源...
数据结构综合课设排序算法时间.docx
03-26
在数据结构综合课设中，排序算法的比较是一项重要的任务，涉及到多个经典的排序算法，包括直接插入排序、希尔排序、直接选择排序、堆排序、冒泡排序和快速排序。这些算法各有特点，适用场景和效率也有所不同。 1. *...
常见的排序算法.pptx
06-03
冒泡排序是一种简单直观的排序算法，其基本思想是通过重复遍历待排序的数列，比较相邻元素并根据需要进行交换，使得每个元素逐步向其最终位置移动。具体步骤如下： 1. 从数列的第一个元素开始，比较相邻的元素。 2....
数据结构 排序综合
06-13
数据结构 排序 利用随机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序。 （1）至少采用三种方法（希尔排序、快速排序、堆排序）实现上述问题求解； （2）统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法； （3）统计每种算法所用的比较次数和交换次数，最后列表显示；
各种排序的综合——综合排序
11-20
jian dan pai xu\n"); mao pao pai xu\n"); kuai su pai xu\n"); gui bing pai xu\n"); dui pai xu\n"); exit\n");
综合排序算法
01-10
冒泡，快速，希尔等排序问题，网络转载，供大家分享
排序算法的综合实例（源程序+设计文档）
10-27
29. 排序综合（限1 人完成） 利用随机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序。 要求： 1) 至少采用三种方法实现上述问题求解（提示，可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序）。并把排序后的结果保存在不同的文件中。 2) 统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法。 3) 如果采用4种或4种以上的方法者，可适当加分。 PS：采用了直接选择排序算法、冒泡排序、希尔排序、直接插入排序这四种排序算法。
排序算法基础、改进综合
03-08
排序算法基础、改进综合： //冒泡排序 //定向冒泡[鸡尾酒]排序 //选择排序 //改进的选择排序 //直接插入排序 //二分插入排序 //希尔排序 //自顶向下地归并排序 //自底向上地归并排序 //堆排序 //快速排序 //改进的快速排序：三向切分快速排序
8种常见的排序算法-----你值得掌握（很细，很全）
一个计算机爱好者学习历程
01-21 3499
一、排序的概念 排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。 例如： 内部排序：数据元素全部放在内存中的排序。 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存
表的综合排序算法+二叉排序树(附原理分析)
ThegreatHaige的博客
09-10 569
一.多个排序法的综合实验日志 实验要求： 综合排序问题【问题描述】分别采用表结构、树结构和散列结构（可选）对一定规模的数据集进行排序。 [任务要求: 至少采用四种排序方法实现随机生成1000个数值的排序（可采用的排序方法有插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序、归并排序）。并把排序后的结果保存在不同的文件中。 统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法。 3.问题分析和任务定义： ①需求分析：在该部分中叙述本课程设计要完成的任务
综合排序总结
mabiao6822的博客
06-20 3343
如果给你一个数组，长度很长，综合排序会先进行一个判断，判断数组里面放的数据类型是什么样的，是基础类型(int,double,char,float,short)还是你自定义的类型(student)。 如果装的是基础类型的数据，则会用快排(不稳定)； 原因是：基础类型根本不用区分原始顺序，相同值无差异。 如果数据的类型是你自己定义的(student)类型，则会用归并排序(稳定)。 原因是：对一个班级，...
python的排序综合
baidu_15113429的博客
08-08 287
排序学习
DataStructure课程 C语言 数据结构的全部代码实现（C语言）第10章 排序 共115页.pptx
01-23
6. 各种排序方法的综合比较：对比分析上述排序算法的特点、效率以及适用场景，帮助理解不同方法的优缺点。 7. 外部排序 (External Sort)：针对大规模数据处理，当无法一次性加载到内存时，如何在磁盘与内存间进行...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值