八大排序算法

最新推荐文章于 2024-07-24 20:44:05 发布

yuqidag

最新推荐文章于 2024-07-24 20:44:05 发布

阅读量136

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/yuqidag/article/details/106165199

版权

八大排序算法动态图参考链接https://cloud.tencent.com/developer/article/1062796
https://cloud.tencent.com/developer/article/1055117
在这里插入图片描述

一. 插入排序
1.直接插入排序
直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过。
因此，从上面的描述中我们可以发现，直接插入排序可以用两个循环完成：
1.第一层循环：遍历待比较的所有数组元素
2.第二层循环：将本轮选择的元素(selected)与已经排好序的元素(ordered)相比较。

代码实现
package demo4;

import java.util.Arrays;

public class InsertSort {

public static void main(String[] args) {
	int[] arr = new int[] {5,3,2,8,5,9,1,0};
	insertSort(arr);
	System.out.println(Arrays.toString(arr));
}

//插入排序
public static void insertSort(int[] arr) {
	//遍历所有的数字
	for(int i=1;i<arr.length;i++) {
		//如果当前数字比前一个数字小
		if(arr[i]<arr[i-1]) {
			//把当前遍历数字存起来
			int temp=arr[i];
			int j;
			//遍历当前数字前面所有的数字
			for(j=i-1;j>=0&&temp<arr[j];j--) {
				//把前一个数字赋给后一个数字
				arr[j+1]=arr[j];
			}
			//把临时变量（外层for循环的当前元素）赋给不满足条件的后一个元素
			arr[j+1]=temp;
		}
	}
}

}

2.希尔排序
希尔排序的算法思想：将待排序数组按照步长gap进行分组，然后将每组的元素利用直接插入排序的方法进行排序；每次将gap折半减小，循环上述操作；当gap=1时，利用直接插入，完成排序。同样的：从上面的描述中我们可以发现：希尔排序的总体实现应该由三个循环完成：
1.第一层循环：将gap依次折半，对序列进行分组，直到gap=1
2.第二、三层循环：也即直接插入排序所需要的两次循环。
代码实现

二.选择排序
1.简单选择排序
简单选择排序的基本思想：比较+交换。
算法步骤：
1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
2）再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3）重复第二步，直到所有元素均排序完毕。

代码实现
package demo4;

import java.util.Arrays;

public class SelectSort {

public static void main(String[] args) {
	int[] arr = new int[] {3,4,5,7,1,2,0,3,6,8};
	selectSort(arr);
	System.out.println(Arrays.toString(arr));
}

//选择排序
public static void selectSort(int[] arr) {
	//遍历所有的数
	for(int i=0;i<arr.length;i++) {
		int minIndex=i;
		//把当前遍历的数和后面所有的数依次进行比较，并记录下最小的数的下标
		for(int j=i+1;j<arr.length;j++) {
			//如果后面比较的数比记录的最小的数小。
			if(arr[minIndex]>arr[j]) {
				//记录下最小的那个数的下标
				minIndex=j;
			}
		}
		//如果最小的数和当前遍历数的下标不一致,说明下标为minIndex的数比当前遍历的数更小。
		if(i!=minIndex) {
			int temp=arr[i];
			arr[i]=arr[minIndex];
			arr[minIndex]=temp;
		}
	}
}

}

2.堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
堆排序的平均时间复杂度为Ο(nlogn) 。

算法步骤：

1）创建一个堆H[0…n-1]

2）把堆首（最大值）和堆尾互换

3）把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置

4）重复步骤2，直到堆的尺寸为1
代码实现
package demo4;

import java.util.Arrays;

public class HeapSort {

public static void main(String[] args) {
	int[] arr = new int[] {9,6,8,7,0,1,10,4,2};
	heapSort(arr);
	System.out.println(Arrays.toString(arr));
}

public static void heapSort(int[] arr) {
	//开始位置是最后一个非叶子节点，即最后一个节点的父节点
	int start = (arr.length-1)/2;
	//调整为大顶堆
	for(int i=start;i>=0;i--) {
		maxHeap(arr, arr.length, i);
	}
	//先把数组中的第0个和堆中的最后一个数交换位置，再把前面的处理为大顶堆
	for(int i=arr.length-1;i>0;i--) {
		int temp = arr[0];
		arr[0]=arr[i];
		arr[i]=temp;
		maxHeap(arr, i, 0);
	}
}

public static void maxHeap(int[] arr,int size,int index) {
	//左子节点
	int leftNode = 2*index+1;
	//右子节点
	int rightNode = 2*index+2;
	int max = index;
	//和两个子节点分别对比，找出最大的节点
	if(leftNode<size&&arr[leftNode]>arr[max]) {
		max=leftNode;
	}
	if(rightNode<size&&arr[rightNode]>arr[max]) {
		max=rightNode;
	}
	//交换位置
	if(max!=index) {
		int temp=arr[index];
		arr[index]=arr[max];
		arr[max]=temp;
		//交换位置以后，可能会破坏之前排好的堆，所以，之前的排好的堆需要重新调整
		maxHeap(arr, size, max);
	}
}

}

三.交换排序
1.冒泡排序
冒泡排序思路比较简单：
1.将序列当中的左右元素，依次比较，保证右边的元素始终大于左边的元素；
2.（第一轮结束后，序列最后一个元素一定是当前序列的最大值；）
对序列当中剩下的n-1个元素再次执行步骤1。
3.对于长度为n的序列，一共需要执行n-1轮比较
（利用while循环可以减少执行次数）

代码实现
package demo4;

import java.util.Arrays;

public class BubbleSort {

public static void main(String[] args) {
	int[] arr=new int[] {5,7,2,9,4,1,0,5,7};
	System.out.println(Arrays.toString(arr));
	bubbleSort(arr);
	System.out.println(Arrays.toString(arr));
}

//冒泡排序
/**
 * 5,7,2,9,4,1,0,5,7		共需要比较length-1轮
 * 5,7,2,9,4,1,0,5,7	
 * 5,2,7,9,4,1,0,5,7
 * 5,2,7,4,1,0,5,7,9
 * 2,5   
 */
public static void bubbleSort(int[]  arr) {
	//控制共比较多少轮
	for(int i=0;i<arr.length-1;i++) {
		//控制比较的次数
		for(int j=0;j<arr.length-1-i;j++) {
			if(arr[j]>arr[j+1]) {
				int temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		}
	}
	
}

}

2.快速排序
它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
假设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
一趟快速排序的算法是：
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
5）重复第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-完成的时候，此时令循环结束）。
复杂度：O(nlogn)
代码实现
package demo4;

import java.util.Arrays;

public class QuickSort {

public static void main(String[] args) {
	int[] arr = new int[] {3,4,6,7,2,7,2,8,0,9,1};
	quickSort(arr,0,arr.length-1);
	System.out.println(Arrays.toString(arr));
}

public static void quickSort(int[] arr,int start,int end) {
	if(start<end) {
		//把数组中的第0个数字做为标准数
		int stard=arr[start];
		//记录需要排序的下标
		int low=start;
		int high=end;
		//循环找比标准数大的数和比标准数小的数
		while(low<high) {
			//右边的数字比标准数大
			while(low<high&&stard<=arr[high]) {
				high--;
			}
			//使用右边的数字替换左边的数
			arr[low]=arr[high];
			//如果左边的数字比标准数小
			while(low<high&&arr[low]<=stard) {
				low++;
			}
			arr[high]=arr[low];
		}
		//把标准数赋给低所在的位置的元素
		arr[low]=stard;
		//处理所有的小的数字
		quickSort(arr, start, low);
		//处理所有的大的数字
		quickSort(arr, low+1, end);
	}
}

}

四.归并排序
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
归并过程为：比较a[i]和b[j]的大小，若a[i]≤b[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素b[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
复杂度：O(nlogn)
代码实现
package demo4;

import java.util.Arrays;

public class MergeSort {

public static void main(String[] args) {
	int[] arr = new int[] {1,3,5,2,4,6,8,10};
	System.out.println(Arrays.toString(arr));
	mergeSort(arr, 0, arr.length-1);
	System.out.println(Arrays.toString(arr));
}

//归并排序
public static void mergeSort(int[] arr,int low,int high) {
	int middle=(high+low)/2;
	if(low<high) {
		//处理左边
		mergeSort(arr, low, middle);
		//处理右边
		mergeSort(arr, middle+1, high);
		//归并
		merge(arr,low,middle,high);
	}
}

public static void merge(int[] arr,int low,int middle, int high) {
	//用于存储归并后的临时数组
	int[] temp = new int[high-low+1];
	//记录第一个数组中需要遍历的下标
	int i=low;
	//记录第二个数组中需要遍历的下标
	int j=middle+1;
	//用于记录在临时数组中存放的下标
	int index=0;
	//遍历两个数组取出小的数字，放入临时数组中
	while(i<=middle&&j<=high) {
		//第一个数组的数据更小
		if(arr[i]<=arr[j]) {
			//把小的数据放入临时数组中
			temp[index]=arr[i];
			//让下标向后移一位；
			i++;
		}else {
			temp[index]=arr[j];
			j++;
		}
		index++;
	}
	//处理多余的数据
	while(j<=high) {
		temp[index]=arr[j];
		j++;
		index++;
	}
	while(i<=middle) {
		temp[index]=arr[i];
		i++;
		index++;
	}
	//把临时数组中的数据重新存入原数组
	for(int k=0;k<temp.length;k++) {
		arr[k+low]=temp[k];
	}
}

}

8.基数排序
基数排序是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。[1-2] 当然这是一种牺牲空间换取时间的做法，而且当O(k)>O(nlog(n))的时候其效率反而不如基于比较的排序（基于比较的排序的时间复杂度在理论上的下限是O(nlog(n)), 如归并排序，堆排序）
假设输入的线性表L的长度为n，L=L1,L2,…,Ln；线性表的元素属于有限偏序集S，|S|=k且k=O(n)，S={S1,S2,…Sk}；则计数排序可以描述如下：
1、扫描整个集合S，对每一个Si∈S，找到在线性表L中小于等于Si的元素的个数T(Si)；
2、扫描整个线性表L，对L中的每一个元素Li，将Li放在输出线性表的第T(Li)个位置上，并将T(Li)减1。
代码实现
void cntsort(int *a, int n, int *s,int *Rank)
{
int i, j;
for (i = 1;i <= n;i++)
s[a[i]]++;
for (i = 1;i <= 100;i++)
s[i] += s[i - 1];
for (i = n;i >= 1;i–)
Rank[s[a[i]]–] = a[i];
for (i = 1;i <= n;i++)
printf("%d “, Rank[i]);
printf(”\n");
}

yuqidag

关注

0
点赞
踩
0

收藏

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

八大排序算法动态图参考链接https://cloud.tencent.com/developer/article/1062796https://cloud.tencent.com/developer/article/1055117一. 插入排序1.直接插入排序直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过。因此，从上面的描述中我们可以发现，直接插入排序可以用两个循环完成：1.第一层循环：遍历待比较的所
复制链接

扫一扫