（更新中）经典八大排序Python和java实现

最新推荐文章于 2024-08-03 21:30:41 发布
最新推荐文章于 2024-08-03 21:30:41 发布
阅读量143 收藏
点赞数
分类专栏： 计算机基础知识 文章标签： 排序算法 java python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21583139/article/details/105936213
版权

插入排序

（1）直接插入排序
python实现
def InsertSort(list1):
    for i in range(1,len(list1)):
        temp = list1[i]
        j = i-1
        while j>=0 and list1[j]>temp:
            list1[j+1] = list1[j]
            list1[j] = temp
            j-=1
        else:
            list1[j+1] = temp
    return list1

list1 = [2,5,1,4,7,3,0,8,9]
print(InsertSort(list1))
java实现
import java.util.Arrays;
public class Sort {
    public static void main(String []args) {
		int[] arr = new int[]{49,38,65,97,76,13,27,49,55,4};
		InsertSort(arr);
        System.out.println(Arrays.toString(arr));
    }
	
	public static void InsertSort(int[] arr){
		for(int i = 1,len = arr.length;i<len;i++){
			if (arr[i]<arr[i-1]){
				int temp = arr[i];
				int j;
				for (j=i-1;j>=0 && arr[j]>temp;j--){
					arr[j+1] = arr[j];
				}
			arr[j+1] = temp;
			}
		}
	}	
}
（2）折半插入排序
python实现
#折半插入排序
def HalfSort(list1):
    for i in range(1,len(list1)):
        if list1[i]<list1[i-1]:
            low,high,temp = 0,i-1,list[i]
            while low<=high:#找到位置
                mid = (high+low)/2
                if list1[mid] > temp:
                    high = mid-1
                else:
                    low = mid + 1
            j = i-1
            while j >= low:#移位
                list1[j+1] = list1[j]
                j-=1
            list1[low] = temp#放入位置
        # print(list1)#可以查看逻辑，尽管和插入排序结果一样，但是内部实现是不同的
    return list1

list1 = [2,5,1,4,7,3,0,8,9]
print(HalfSort(list1))
java实现
import java.util.Arrays;
public class Sort {
    public static void main(String []args) {
		int[] arr = new int[]{49,38,65,97,76,13,27,49,55,4};
		HalfSort(arr);
        System.out.println(Arrays.toString(arr));
    }
	
	public static void HalfSort(int[] arr){
		int n = arr.length;
		for(int i = 1;i<n;i++){
			if(arr[i]<arr[i-1]){
				int temp = arr[i];
				int low = 0;
				int high = i-1;
				while(low <= high){
					int mid = (low+high)/2;
					if (arr[mid]>temp){
						high = mid-1;
					}else{
						low = mid+1;
					}
				}
				//移位
				for(int j = i-1;j>=low;j--){
					arr[j+1] = arr[j];
				}
				arr[low] = temp; 
			}
		}  	
	}	
}
（3）希尔排序
python实现
# 希尔排序
def ShellSort(list1):
    length = len(list1)
    step = int(length / 2)
    while step>=1:
        i = step
        while i <length:
            if list1[i] < list1[i-step]:
                temp = list1[i]
                j = i-step
                while (list1[j] > temp and j >= 0):#移位
                    list1[j+step] = list1[j]
                    j-=step
                list1[j+step] = temp#放进位置
            i+=1
        step=int(step/2)
        print(list1)
    return list1

list1 = [2,5,1,4,7,3,0,8,9]
list1 = [49,38,65,97,76,13,27,49,55,4]
print(ShellSort(list1))
java实现
希尔排序
import java.util.Arrays;
public class Sort {
	public static void main(String[] args) {
		int[] array =new int[]{2,5,1,4,7,3,0,8,9};
	    int n = array.length;
		for(int step = n/2;step>0;step/=2){
			for(int i=step;i<n;i++){	
				for(int j = i-step;j>=0 ;j-=step){  
					if (array[j]>array[j+step]){
						int temp = array[j+step];
					    array[j+step] = array[j];
						array[j] = temp;
	                 }
				}	
			}
		} 
		System.out.println(Arrays.toString(array));
	}		
}
或者如下改进，减少交换次数
import java.util.Arrays;
public class HelloWorld {
	public static void main(String[] args) {
		int[] array =new int[]{49,38,65,97,76,13,27,49,55,04};
	    int n = array.length;
		for(int step = n/2;step>0;step/=2){
			for(int i=step;i<n;i++){
				if (array[i]<array[i-step]){
					int temp = array[i];
					int j;
					for(j = i-step;j>=0&&array[j]>temp;j-=step){ 		
						array[j+step] = array[j];
                    }
					array[j+step] = temp;		
				}
			}
			System.out.println(Arrays.toString(array));
		}  
	}		
}

比较排序（交换排序）

（1）冒泡排序
Python实现
#未改进的冒泡排序
def BubbleSort(list1):
	length = len(list1)
	for i in range(length):
	    for j in range(1,length-i):
	        if list1[j] < list1[j-1]:
	            temp = list1[j]
	            list1[j] = list1[j-1]
	            list1[j-1] = temp
	    print(list1)
	return list1

list1 = [49,38,65,97,76,13,27,49,55,4]
print(BubbleSort(list1))
改进的冒泡排序Python（只要某一趟没有发生数据交换意味着排序结束，无需再空跑）
#改进的冒泡排序
def BubbleSort(list1):
    length = len(list1)
    for i in range(length):
        flag = False
        for j in range(1,length-i):
            if list1[j] < list1[j-1]:
                temp = list1[j]
                list1[j] = list1[j-1]
                list1[j-1] = temp
                flag = True
        if flag == False:
            break
        print(list1)
    return list1

list1 = [49,38,65,97,76,13,27,49,55,4]
print(BubbleSort(list1))
或者使用while循环
#使用while循环的冒泡排序
def BubbleSort(list1):
    length = len(list1)
    flag = True
    while flag:
        flag = False
        for j in range(1,length):
            if list1[j] < list1[j-1]:
                temp = list1[j]
                list1[j] = list1[j-1]
                list1[j-1] = temp
                flag = True
        print(list1)
        length -= 1
    return list1

list1 = [49,38,65,97,76,13,27,49,55,4]
print(BubbleSort(list1))
java实现（未改进）
//冒泡排序（未改进）
import java.util.Arrays;
public class Sort {
	public static void main(String[] args) {
		int[] array =new int[]{49,38,65,97,76,13,27,49,55,04};
	    int n = array.length;
		for(int i = 0;i<n;i++){
			for(int j=1;j<n-i;j++){
				if (array[j]<array[j-1]){
					int temp = array[j];
					array[j] = array[j-1];
					array[j-1] = temp;		
				}
			}
		System.out.println(Arrays.toString(array));
		}  
	}	
}
java实现（改进）
//冒泡排序（改进）
import java.util.Arrays;
public class HelloWorld {
	public static void main(String[] args) {
		int[] array =new int[]{49,38,65,97,76,13,27,49,55,04};
	    int n = array.length;
		for(int i = 0;i<n;i++){
			boolean flag = false;
			for(int j=1;j<n-i;j++){
				if (array[j]<array[j-1]){
					int temp = array[j];
					array[j] = array[j-1];
					array[j-1] = temp;
					flag = true;
				}
			}
			if (!flag){
				break;
			}
		System.out.println(Arrays.toString(array));
		}  
	}	
}
或者while循环
import java.util.Arrays;
public class Sort {
	public static void main(String[] args) {
		int[] array =new int[]{49,38,65,97,76,13,27,49,55,04};
	    int len = array.length;
	    boolean flag = true;
	    while (flag) {
	        flag = false;
	        for (int i = 0; i < len - 1; i++) {
	            if (array[i] > array[i + 1]) {
	                int temp = array[i + 1];
	                array[i + 1] = array[j];
	                array[i] = temp;
	                flag = true;
	            }
	        }
	        len--;
	        System.out.println(Arrays.toString(array));
	    }
    }
}
（2）快速排序（默认第一个元素是枢轴值）
Python实现
#快速排序,默认第一个元素是枢轴值
def QuickSort(list1,low,high):
    if low < high:
        pivot = Separate(list1,low,high)
        QuickSort(list1,low,pivot-1)
        QuickSort(list1,pivot+1,high)
    return list1

def Separate(list1,low,high):
    pivot = list1[low]
    while low<high:
        while low < high and list1[high]>= pivot:
            high-=1
        list1[low] = list1[high]
        while low < high and list1[low]<pivot:
            low+=1
        list1[high] = list1[low]
    list1[low] = pivot
    return low

list1 = [49,38,65,97,76,13,27,49,55,4]
length = len(list1)
result = QuickSort(list1,0,length-1)
print(list1)
java实现
//快速排序
import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        QuickSort(new int[]{39,28,55,87,66,3,17,39});
    }

    public static void QuickSort(int[] arr){
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    public static void quickSort(int[] arr,int left,int right){
        int middle;
        if(left < right){
            middle = partition(arr,left,right);
            quickSort(arr,left,middle-1);
            quickSort(arr,middle+1,right);
        }
    }

    public static int partition(int[] arr,int left,int right){
        int pivot = arr[left];
        while(left < right){
            while(left<right && arr[right] >= pivot)
                right--;
            arr[left] = arr[right];
            while(left < right && arr[left]<= pivot)
                left++;
            arr[right] = arr[left];
        }
        arr[left] = pivot;
        return left;
    }
}

3选择排序

（1）简单选择排序
Python实现
def SelectSort(list1):
    n = len(list1)
    for i in range(0,n-1):#注意这里是n-1，因为最后一个数一定是最大的，所以可以少比一趟
        min = i#存储下标
        for j in range(i+1,n):
            if list1[j] < list1[min]:
                min = j
        if min!=i:
            temp = list1[i]
            list1[i] = list1[min]
            list1[min] = temp
        print(list1)
    return list1

list1 = [49,38,65,97,76,13,27,49,55,4]
print(SelectSort(list1))
java实现
import java.util.Arrays;
public class Sort {
    public static void main(String []args) {
		int[] arr = new int[]{49,38,65,97,76,13,27,49,55,4};
		selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }
	
	public static void selectSort(int[] array) {
	    int n = array.length;
	    for (int i = 0; i < n; i++) {
	        int minIndex = i;
	        for (int j = i + 1; j < n; j++) {
	            if (array[minIndex] > array[j]) {
	                minIndex = j;
	            }
	        }
	        if (i != minIndex) {
	            int temp = array[i];
	            array[i] = array[minIndex];
	            array[minIndex] = temp;
	        }
	    }
	}
}
（2）堆排序大顶堆（大根堆）
Python实现（尽管有相应的第三方库，为了更好的了解这种二叉树数据结构，还是自己写一个吧）
#堆排序
def Heap_Sort(arr):
    n = len(arr)
    max_index = n-1
    i = int((max_index-1)/2)
    while i>=0:
        AdjustHeap(arr,n,i)
        i-=1
    j = n-1
    while j>0:
        arr[0],arr[j] = arr[j],arr[0]
        AdjustHeap(arr,j,0)
        j-=1
    return arr

def AdjustHeap(arr,n,i):#创建堆，调整堆
    leftchild = 2*i+1
    rightchild = 2*i+2
    largest_index = i
    if (leftchild<n and arr[leftchild]>arr[largest_index]):
        largest_index = leftchild
    if (rightchild<n and arr[rightchild]>arr[largest_index]):
        largest_index = rightchild
    if largest_index!=i:
        arr[i],arr[largest_index] = arr[largest_index],arr[i]
        AdjustHeap(arr,n,largest_index)

list1 = [49,38,65,97,76,13,27,49,55,4]
print(Heap_Sort(list1))
java实现
//堆排序
import java.util.Arrays;
public class HelloWorld {
    public static void main(String []args) {
		int[] arr = new int[]{49,38,65,97,76,13,27,49,55,4};
		heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }
	
	public static void heapSort(int[] array) {
		// 1. 创建最大堆：从最后一个节点的父节点开始
		int lastIndex = array.length - 1;
		int startIndex = (lastIndex - 1) / 2;
		for (int i = startIndex; i >= 0; i--) {
			maxHeap(array, array.length, i);
		}
		// 2. 排序：末尾与头交换，逐一找出最大值，最终形成一个递增的有序序列
		for (int i = array.length - 1; i > 0; i--) {
			int temp = array[0];
			array[0] = array[i];
			array[i] = temp;
			maxHeap(array, i, 0);
		}
	}
 
	private static void maxHeap(int[] data, int heapSize, int index) {
		// 左子节点
		int leftChild = 2 * index + 1;
		// 右子节点
		int rightChild = 2 * index + 2;
		// 最大元素下标
		int largestIndex = index;
		// 分别比较当前节点和左右子节点，找出最大值
		if (leftChild < heapSize && data[leftChild] > data[largestIndex]) {
			largestIndex = leftChild;
		}
		if (rightChild < heapSize && data[rightChild] > data[largestIndex]) {
			largestIndex = rightChild;
		}
		// 如果最大值是子节点，则进行交换
		if (largestIndex != index) {
			int temp = data[index];
			data[index] = data[largestIndex];
			data[largestIndex] = temp;
			// 交换后，其子节点可能就不是最大堆了，需要对交换的子节点重新调整
			maxHeap(data, heapSize, largestIndex);
		}
	}
}
（3）二路归并排序
Python实现
#二路归并排序
def MergeSort(arr,low,high):
    mid = int((high + low) / 2)
    if (low<high):
        MergeSort(arr,low,mid)
        MergeSort(arr,mid+1,high)
        Merge(arr,low,mid,high)
    return arr

def Merge(arr,low,mid,high):
    temp = [0]*(high-low+1)
    i,j,k = low,mid+1,0
    while(i<=mid and j<=high):
        if arr[i]<arr[j]:
            temp[k] = arr[i]
            i+=1
        else:
            temp[k] = arr[j]
            j+=1
        k+=1
    #如果两个表长度不一样，剩余的有序部分全部复制到temp表
    while(i<=mid):
        temp[k] = arr[i]
        k = k+1
        i = i+1
    while(j<=high):
        temp[k] = arr[j]
        j+=1
        k+=1
    #将排好序的temp表数据替换到原来的表中
    for m in range(len(temp)):
        arr[m+low] = temp[m]

list1 = [49,38,65,97,76,13,27,49,55,4]
length = len(list1)
print(MergeSort(list1,0,length-1))
java实现
二路归并排序
import java.util.Arrays;
public class HelloWorld {
    public static void main(String []args) {
		int[] arr = new int[]{49,38,65,97,76,13,27,49,55,4};
		mergeSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
	
	public static void mergeSort(int[] array, int low, int high) {
		int middle = (low + high) / 2;
		if (low < high) {
			mergeSort(array, low, middle);
			mergeSort(array, middle + 1, high);
			merge(array, low, middle, high);
		}
	}
 
	public static void merge(int[] array, int low, int middle, int high) {
		int[] temp = new int[high - low + 1];
		int i = low;
		int j = middle + 1;
		int k = 0;
		while (i <= middle && j <= high) {
			if (array[i] < array[j]) {
				temp[k++] = array[i++];
			} else {
				temp[k++] = array[j++];
			}
		}
		while (i <= middle) {
			temp[k++] = array[i++];
		}
		while (j <= high) {
			temp[k++] = array[j++];
		}
		for (int m = 0; m < temp.length; m++) {
			array[m + low] = temp[m];
		}
	}
}
落墨画雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python习题集3、for循环的使用
rjswsq1998的博客
07-16 1781
1.打印以下图形 * * * * * * * * * * * * * * * for i in range(5, 0, -1): print('*' * i) 2.打印以下图形 * * * * * * * * * * * * * * * for i in range(5, 0, -1): print(('*' * i).rjust(5, ' ')) 3.打印以下图形 * * * * * * * * * .
python归并排序函数详解_python 实现归并排序算法
weixin_39568926的博客
12-16 820
python数据结构与算法总结python常用的数据结构与算法就分享到此处，本月涉及数据结构与算法的内容有如下文章：《数据结构和算法对python意味着什么？》《顺序表数据结构在python中的应用》《python实现单向链表数据结构及其基本方法》《python实现单向循环链表数据结构及其方法》《python实现双向...文章python之战2019-04-241168浏览量算法基础：五大排序算法...
java中Arrays.sort()实现原理
weixin_34152820的博客
05-07 2021
2019独角兽企业重金招聘Python工程师标准>>> ...
排序算法：选择排序（Python）
热门推荐
m0_61661179的博客
10-08 6万+
在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
快速排序(Quick sort)
LittleSheep肖恩
07-21 164
package com.ww.algorithm.sort.exchange; import org.junit.Test; import java.util.Arrays; import java.util.HashMap; import java.util.Map; import java.util.Stack; /** * 快速排序：快速排序是从冒泡排序演变而来的算法，但是比冒泡排序要高效的多，所以叫快速排序。快速排序之所以快速，是因为它用了分治法。同冒泡排序一样， * 快速排序也属于交换排
快速排序
凯凯王的技术生涯
02-07 232
文章目录快速排序是什么快速排序 快速排序是什么 快速排序是冒泡排序的一种改进，是一种通过比较进行交换的排序，选择一个标定点，通过一趟排序将要排序的数据分割成为大于标定点的元素和小于标定点的元素，然后对分为的两部分递归上面的操作，直到剩下最后一个元素，这个时候整个数据就成了有序序列。 Partition算法 首先选择数组中的一个元素作为标定点元素，比如用把最左边索引为l的元素v定义为标定点，通过...
八大排序算法（python语言实现）
bky01的博客
09-19 2469
一、冒泡排序： 冒泡排序 def bubbleSort(arr): “”" :param arr: :return: “”" for i in range(1, len(arr)): for j in range(0, len(arr) - i): if arr[j] > arr[j + 1]: arr[j], arr[j + 1] = arr[j + 1], arr[j] return a...
python实现冒泡排序完整算法_利用python实现冒泡排序算法实例代码
weixin_39610759的博客
11-28 1095
利用python实现冒泡排序算法实例代码冒泡排序冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。冒泡排序算法的运作如下：1、比较相邻的元素。如果第一个比第二个大（升...
DSAlgorithms：使用Java，Python和C ++编程语言进行实践的数据结构和算法实现
02-05
本项目名为"DSAlgorithms"，涵盖了使用Java、Python和C++编程语言实现的各种数据结构和算法。这些实现不仅适用于学习，也是实际开发中的宝贵资源。以下是这些编程语言中涉及的一些核心知识点： 1. **数据结构**： ...
Python 中文数据结构和算法教程.zip
06-16
本教程“Python 中文数据结构和算法教程”是针对大学生以及编程初学者的一份全面学习资源，涵盖了C/C++/JAVA/Python等多种编程语言的数据结构基础，旨在提升编程思维和解决问题的能力。 在数据结构方面，教程可能...
Algorithms_using_Data_Structures:Java和Python使用的语言
05-09
本项目"Algorithms_using_Data_Structures:Java和Python使用的语言"专注于通过这两种流行的编程语言——Java和Python3——来实现各种算法和数据结构。 1. **Java中的数据结构** - **数组**: 基本的数据结构，用于...
Competitive-Programming:解决Java和Python中竞争性编程问题的解决方案
03-20
这份资源"Competitive-Programming:解决Java和Python中竞争性编程问题的解决方案"似乎专注于这两个流行的编程语言，帮助参赛者提高他们在编程竞赛中的表现。下面，我们将深入探讨如何利用Java和Python在竞争性编程中...
Java常用排序算法程序员必须掌握的8大排序算法Java开
11-22
以上八大排序算法各有优劣，根据实际场景选择合适的算法能显著提高程序性能。了解并熟练运用这些算法是提升Java程序员技能的关键，也是软件开发中解决问题的重要工具。学习资料如"Java常用排序算法程序员必须掌握的8...
linux的cpu使用率100%？
落墨画雪的博客
11-29 7417
1：背景 在linux环境中，我们都会通过top指令获取当前实例的进场占用cpu情况，如下所示 [123456789@root ~]$ top top - 11:48:13 up 622 days, 15:51, 2 users, load average: 0.22, 0.19, 0.11 Tasks: 788 total, 1 running, 787 sleeping, 0 stopped, 0 zombie Cpu(s): 6.6%us, 2.3%sy, 0.0%ni, 91.
关于单精度浮点型精确位数7~8以及双精度浮点型精确位数15~16的解释
落墨画雪的博客
07-14 5463
1问题的提出 最近在学习过程中，遇到了题目中出现的陈述，但是对于原因没有头绪，同时在互联网上很难找的到合理的我想要的解释，因此我搜罗了一些前人的知识，结合自己的理解，总结一下。 2问题的解释 首先，float单精度浮点型，计算机会分配4字节，32位来进行存储，而double float双精度浮点型，计算机则会分配8个字节，即64位来进行小数的存储，这是后面进行详细解释的必备知识。 其次，计算机在存储浮点型数据时，会将浮点型数据分为3个部分来进行存储（至于为什么，规定），分别为： （1）符号位（这个熟悉整型的
2020华为春招第三批机试题
落墨画雪的博客
05-17 1450
前情提要 华为机试题两个小时3道编程题，每题200分，出题的邮件是来自牛客网，由于笔者没有太多A题经验，闲暇只在Leecode上玩玩，所以，对这个牛客网的I/O不很熟练，导致实际答题时耽误很多时间，第一题只通过90.91%测试用例，第二题只通过40%，第三题来不及做完，但是试后花了点时间自己弄出来了，但是没有测试用例，只是在自己的用例中通过，欢迎大家提供自己的想法，互相交流。 第一题 大意：输入一个字符串，类似1980 01 02 5|1980 01 04，其中‘|’将字符串分成了两部分，分别是两个时间字符
centos配置git分布式版本控制系统（连接GitHub）
落墨画雪的博客
06-23 231
111111111
【数据结构】排序基本概念、插入排序、希尔排序（详解）
最新发布
明志の博客
08-03 1133
插入排序、希尔排序
测试工程师面试宝典：涵盖八大核心技术点
资料中特别强调了Java、Python、数据库操作、自动化测试工具的使用以及面试中常见的问题和场景。" 详细知识点： 1. **算法与编程**： - 常见面试题来源：《剑指Offer》是刷题的重要参考书籍，其中包含大量面试常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值