算法（排序）

長安꧔ꦿ

于 2019-05-14 10:06:35 发布

阅读量139

点赞数 1

分类专栏：数据结构

本文链接：https://blog.csdn.net/qq_43701330/article/details/90200803

版权

数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.对比算法

1.1选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

在这里插入图片描述

/*
 * 选择排序
 * 核心思想：每个元素与后面的元素挨个比较
 * 平均时间复杂度O(n^2)
 * 最好的时间复杂度O(n^2)
 * 最坏的时间复杂度O(n^2)
 * 空间复杂度O(1)
 * 稳定性:不稳定
 * */
public class SelectSort {
	public static void  SelectSort(int[] arr) {
		//对于特殊值的过滤 arr==null arr.length==0 arr.length==1
		if(arr==null||arr.length==0||arr.length==1){
			return;
		}
		int temp=0;
		for(int i=0;i<arr.length-1;i++){
			for(int j=i+1;j<arr.length;j++){
				if(arr[i]>arr[j]){
					temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
	}
}

1.2冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

在这里插入图片描述

/*
 * 冒泡排序
 * 核心思想：每个元素与前面的元素相比
 * 1 2 3 4 5 6 7
 * 两两比较互换
 *  1 2比较 大的往后走
 *   12比较完以后23比较，以此类推，第一轮结束后，最大的就出来了
 *   
 *   平均时间复杂度O(n^2)
 *   最好时间复杂度O(n)
 *   最坏时间复杂度O(n^2)
 *   空间复杂度O(1)
 *   稳定性：稳定
 *   
 * */
public class BubbleSort {
	public static void BubbleSort(int[] arr) {
		if(arr==null||arr.length==0||arr.length==1){
			return;
		}
		int temp=0;
		for(int i=0;i<arr.length-1;i++){
			for(int j=1;j<arr.length-i;j++){
				if(arr[j-1]>arr[j]){
					temp=arr[j-1];
					arr[j-1]=arr[j];
					arr[j]=temp;
				}
			}
		}
	}
}

优化以后的代码

public class BubbleSort {
	public static void BubbleSort(int[] arr) {
		if(arr==null||arr.length==0||arr.length==1){
			return;
		}
		int temp=0;
		int count=0;
		for(int i=0;i<arr.length-1;i++){
			count=0;	//记录是否有交换，如果有交换，则表示有序，
			temp=arr[0];
			for(int j=1;j<arr.length-i;j++){
				if(arr[j]<temp){
					arr[j-1]=arr[j];
					count++;
				}else{
					arr[j-1]=temp;
					temp=arr[j];
				} 
			}
			if(count==0){
				break;
			}
		}
	}
}

1.3插入排序

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。

在这里插入图片描述

/*
 * 插入排序  
 * */
public class InsertSort {
	public static void InsertSort(int[] arr) {
		int temp=0;
		int j;
		for(int i=1;i<arr.length;i++){//O(n)
			for(j=i;j>0;j--){
				if(arr[j-1]>arr[j]){
					temp=arr[j-1];
					arr[j-1]=arr[j];
					arr[j]=temp;
				}
			}
		}
	}
}

优化以后的代码

/*
 * 插入排序
 * 平均时间复杂度O(n^2)
 * 最好时间复杂度O(n)
 * 最坏时间复杂度O(n^2)
 * 空间复杂度O(1)
 * 
 * 
 * 希尔排序	增小缩量排序	是史上第一个突破了O(n^2)级别的排序
 * 
 * O(n^1.3)
 *  
 * */
public class InsertSort {
	public static void InsertSort(int[] arr) {
		int temp=0;
		int j;
		for(int i=1;i<arr.length;i++){//O(n)
			temp=arr[i];
			for(j=i;j>0&&arr[j-1]>temp;j--){//O(n^2)
				arr[j]=arr[j-1];
			}
			arr[j]=temp;
		}
	}
}

1.4归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

在这里插入图片描述

/*
 * 归并排序
 * 平均时间复杂度：O(nlogn)
 * 最好时间复杂度：O(nlogn)
 * 最坏时间复杂度：O(nlogn)
 * 空间复杂度：O(1)
 * 稳定性：稳定
 * */
public class MergeSort {
	public static void MergeSort(int[] arr) {
		mergeSort(arr,0,arr.length-1);
	}
	private static void mergeSort(int[] arr, int l, int r) {
		if(l>r){
			return;
		}
		int mid=(l+r)/2;
		//[L...mid]
		mergeSort(arr, l, mid);
		//[mid+1...r]
		mergeSort(arr, mid+1, r);
		//将arr[l...mid]和arr[mid+1...r]进行归并
			merge(arr,l,mid,r);
	}
	private static void merge(int[] arr, int l, int mid, int r) {
		int[] aux=new int[r-l+1];
		for(int i=l;i<=r;i++){
			aux[i-l]=arr[i];
		}
		int i=l,j=mid+1;
		for(int k=l;k<=r;k++){
			if(i>mid){
				arr[k]=aux[j-l];
				j++;
			}else if(j>r){
				arr[k]=aux[i-l];
				i++;
			}else if(aux[i-l]<=aux[j-l]){
				arr[k]=aux[i-l];
				i++;
			}else{
				arr[k]=aux[j-l];
				j++;
			}
		}
	}
}

优化以后的代码

public class MergeSort {
	public static void MergeSort(int[] arr) {
		mergeSort(arr,0,arr.length-1);
	}
	private static void mergeSort(int[] arr, int l, int r) {
		//2.优化 当递归到一定程度时，可以不需要完全递归到底，直接排序即可
		if(r-l<=15){
			InsertSort.InsertSort(arr,l,r);
			return;
		}
		int mid=(l+r)/2;
		//[L...mid]
		mergeSort(arr, l, mid);
		//[mid+1...r]
		mergeSort(arr, mid+1, r);
		//将arr[l...mid]和arr[mid+1...r]进行归并
		//1.优化 如果左边数组中的最大值 小于等于 右边数组中的最小值 不需要归并
		if(arr[mid]>arr[mid+1]){
			merge(arr,l,mid,r);
		}
	}
	private static void merge(int[] arr, int l, int mid, int r) {
		int[] aux=new int[r-l+1];
		for(int i=l;i<=r;i++){
			aux[i-l]=arr[i];
		}
		int i=l,j=mid+1;
		for(int k=l;k<=r;k++){
			if(i>mid){
				arr[k]=aux[j-l];
				j++;
			}else if(j>r){
				arr[k]=aux[i-l];
				i++;
			}else if(aux[i-l]<=aux[j-l]){
				arr[k]=aux[i-l];
				i++;
			}else{
				arr[k]=aux[j-l];
				j++;
			}
		}
	}
}

1.5快速排序

快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

算法（单路排序）

设置两个变量i、j，排序开始的时候：i=0，j=N-1；
以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换；
从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换；
重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

在这里插入图片描述

private static void quickSort(int[] arr, int l, int r) {
		if(l>r){
			return;
		}
		int p=partion(arr,l,r);
		quickSort(arr,l,p-1);
		quickSort(arr,p+1,r);
	}

	private static int partion(int[] arr, int l, int r) {
		int v=arr[l];
		int j=l;
		for(int i=l+1;i<=r;i++){
			if(arr[i]<=v){
				swap(arr,j+1,i);
				j++;
			}
		}
		swap(arr,l,j);
		return j;
	}
	private static void swap(int[] arr, int i, int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}

优化后代码

private static void quickSort(int[] arr, int l, int r) {
		//1.优化
		if(r-l<=15){
			InsertSort.InsertSort(arr,l,r);
			return;
		}
		int p=partion(arr,l,r);
		quickSort(arr,l,p-1);
		quickSort(arr,p+1,r);
	}

	private static int partion(int[] arr, int l, int r) {
		//2.优化 如果数组近乎有序 要么有大面积的>空间 要么有大面积的<空间
		//再接着对该空间进行拆分，二叉树极度不平衡
		//(int)(Math.random()*(r-l+1)+l )随机获取从l到r区间的值
		swap(arr,l,(int)(Math.random()*(r-l+1)+l ));
		int v=arr[l];
		int j=l;
		for(int i=l+1;i<=r;i++){
			if(arr[i]<=v){
				swap(arr,j+1,i);
				j++;
			}
		}
		swap(arr,l,j);
		return j;
	}

算法（双路排序）

双路排序就是在单路排序的基础上将大于V的值放在后面，小于等于V的值放在前面

源码

private static void quickSort2(int[] arr, int l, int r) {
		if(r-l<=15){
			InsertSort.InsertSort(arr,l,r);
			return;
		}
		int p=partion2(arr,l,r);
		quickSort2(arr,l,p-1);
		quickSort2(arr,p+1,r);
	}
	private static int partion2(int[] arr, int l, int r) {
		swap(arr,l,(int)(Math.random()*(r-l+1)+l ));
		int v=arr[l];
		//j是>v的第一个元素的角标
		int j=r;
		//i是<=v的第一个元素的角标
		int i=l+1;
		while(true){
			while(i<r&&arr[i]<=v){
				i++;
			}
			while(j>i+1&&arr[j]>v){
				j--;
			}
			if(i>j){
				break;
			}
			swap(arr,i,j);
			i++;
			j--;
		}
		swap(arr,l,j);
		return j;
	}

三路排序

将等于V，小于V，大于V的分成三部分并进行排序

源码

private static void quickSort3(int[] arr, int l, int r) {
		if(r-l<=15){
			InsertSort.InsertSort(arr,l,r);
			return;
		}
		int p=partion3(arr,l,r);
		quickSort3(arr,l,p-1);
		quickSort3(arr,p+1,r);
	}
	private static int partion3(int[] arr, int l, int r) {
		swap(arr,l,(int)(Math.random()*(r-l+1)+l ));
		int v=arr[l];
		int lt=l;//arr[l+1....lt]<v
		int gt=r+1;//arr[gt....r]>v
		int i=l+1;
		while(i<gt){
			if(arr[i]<v){
				swap(arr,lt+1,i);
				lt++;
				i++;
			}else if(arr[i]>v){
				swap(arr,gt-1,i);
				gt--;
			}else{
				i++;
			}
		}
		swap(arr,l,lt);
		return lt;
	}
}

1.7计数排序

计数排序是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。当然这是一种牺牲空间换取时间的做法。

public class CountingSort {
	/**
	 * 计数排序---最好用于排序数字
	 * 和数字有关系
	 * 2 2 1 3 2 3 2 4 9 8 8 8
	 * 哈希函数
	 * min 1
	 * max 9
	 * 
	 * 
	 * */
	public static void countingSort(int[] arr){
		int min=findMin(arr);
		int max=findMax(arr);
		int m=max-min+1;
		int[] counts=new int[m];
		for(int i=0;i<arr.length;i++){
			counts[arr[i]-min]++;
		}
		int index=0;
		for(int i=0;i<counts.length;){
			if(counts[i]!=0){
				arr[index]=i+min;
				counts[i]--;
				index++;
				continue;
			}else{
				i++;
			}
		}
	}

	private static int findMax(int[] arr) {
		int max=arr[0];
		for(int i=0;i<arr.length;i++){
			if(max<arr[i]){
				max=arr[i];
			}
		}
		return max;
	}

	private static int findMin(int[] arr) {
		int min=arr[0];
		for(int i=0;i<arr.length;i++){
			if(min>arr[i]){
				min=arr[i];
			}
		}
		return min;
	}
}

長安꧔ꦿ

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法（排序）

1.对比算法1.1选择排序/* * 选择排序 * 核心思想：每个元素与后面的元素挨个比较 * 平均时间复杂度O(n^2) * 最好的时间复杂度O(n^2) * 最坏的时间复杂度O(n^2) * 空间复杂度O(1) * 稳定性:不稳定 * */public class SelectSort { public static void SelectSort(int[] arr...
复制链接

扫一扫

专栏目录