本文介绍了衡量算法优劣的两个关键指标：时间复杂度和空间复杂度，并详细阐述了八大排序算法，包括冒泡排序、快速排序、直接插入排序、希尔排序、简单选择排序、归并排序、基数排序和堆排序，帮助读者深入理解各种排序算法的工作原理和效率特点。
这里我们主要来讲讲八大排序算法
首先呢,我们来明确一些概念问题
1.如何衡量一个算法的优劣：
从两方面来说：时间复杂度 和 空间复杂度
①时间复杂度：一个算法运行需多长时间
②空间复杂度：一个算法运行时需占用多少内存
2.时间复杂度：一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示.若有某个辅助函数f(n)使得当n趋近无穷大时，T(n)/f(n)的极限值为不等于0的常数。则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))。
称O(f(n))为算法的渐进时间复杂度，简称时间复杂度。
①T(n)： 即语句频度，一个算法中的语句执行次数
②T(n)不同，但时间复杂度可能相同.
例如：T(n) = n^2 + 5n+6与 T(n) = 3n^2+3n+2 它们的T(n)不同,但时间复杂度都为O(n^2);
③常见的时间复杂度：而随着问题规模n的不断增大,下述时间复杂度不断增大,算法的执行效率越低
④计算时间复杂度的方法：
用常数1代替运行时间中的所有加法常数,修改后的运行次数函数中,只保留最高阶项
去除最高阶项的系数
3.八种常用排序算法
一、冒泡排序(BubbleSort):相邻元素两两比较，大的往后放。第一轮后，最大值就出现在最大索引处.
package cn.makasa1;
import java.util.Arrays;
//冒泡排序
public class BubbleSort {
public static void main(String[] args) {
int[] arr = new int[]{5,6,2,1,4,7};
System.out.println(Arrays.toString(arr));
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
//冒泡排序
/**
* 5,6,2,1,4,7 一共需要比较length-1轮
*
* @param arr
*/
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;
}
}
}
}
}
二、快速排序(QuickSort): 取一个基数(一般都是第一个数和最后一个数)，比它大的数都放后面，比它小的都放它前面，然后依次递归
package cn.makasa1;
import java.util.Arrays;
//快速排序
public class QuickSort {
public static void main(String[] args) {
int[] arr = new int[]{5,6,2,1,4,7};
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);*/
}
}
}
三、直接插入排序(InsertSort):拿一个元素(一般是第2个)与前面的元素相比，比它小的不变位置，比他大的，自己放至前面
package cn.makasa1;
import java.util.Arrays;
public class InsertSort {
public static void main(String[] args) {
int[] arr = new int[]{5,3,4,7,1,2,8};
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;
}
}
}
}
四、希尔排序(ShellSort):比直接插入排序效率高一些
元素个数/2 得出第一轮交换的步长,然后将这些元素排列好
之后就步长/2 依次排列 直到排序完成
例子：
package cn.makasa1;
import java.util.Arrays;
//希尔排序
public class ShellSort {
public static void main(String[] args) {
int[] arr = new int[]{2, 5, 3, 7, 8, 3, 9,0};
shellSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void shellSort(int[] arr) {
//遍历所有的步长
for (int d = arr.length / 2; d > 0; d /= 2) { ;
//遍历所有元素
for (int i = d; i < arr.length; i++) {
//遍历本组中所有的元素
for (int j = i - d; j >=0; j -= d) {
//如果当前元素大于加上步长后的那个元素
if (arr[j] > arr[j + d]) {
int temp = arr[j];
arr[j] = arr[j + d];
arr[j + d] = temp;
}
}
}
}
}
}
五、简单选择排序(SelectSort):从0索引开始，依次和后面元素比较，小的往前放。第一次完毕，最小值出现在了最小索引处。
package cn.makasa1;
import java.util.Arrays;
//简单选择排序
public class SelectSort {
public static void main(String[] args) {
int[] arr = new int[]{5,6,2,1,4,7};
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[j]<arr[minIndex]){
//记录下最小的那个数的下标
minIndex = j;
}
}
//如果最小的数和当前遍历数的下标不一致，说明下标为minIndex的数比当前遍历的数更小
if(i!=minIndex){
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
}
六、归并排序(MergeSort):
例子：
package cn.makasa1;
import java.util.Arrays;
public class MergeSort {
public static void main(String[] args) {
int[] arr = new int[]{3,1,4,2,5,3,5};
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];
}
}
}
七、基数排序(RadixSort):按个、十、百…位排，排的次数以元素中最大的位数决定
例如：269，即排三次，排到百位
例子：
package cn.makasa1;
import java.util.Arrays;
public class RedixSort {
public static void main(String[] args) {
int[] arr = new int[]{23,6,189,45,8};
redixSort(arr);
System.out.println(Arrays.toString(arr));
}
private static void redixSort(int[] arr) {
//存在数组中最大的数字
int max = Integer.MIN_VALUE;
for(int i=0;i<arr.length;i++){
if(arr[i] > max){
max = arr[i];
}
}
//计算最大数字是几位数
int maxLength = (max+"").length();
//用于临时存储数据的数组
int[][] temp = new int[10][arr.length];//写上arr.length避免空指针异常
//用于记录在temp中相应的数组中存放的数字的数量
int[] counts = new int[10];
//根据最大长度的数决定比较的次数
for(int i = 0,n=1;i<maxLength;i++,n*=10){
//把每一个数字分别计算余数
for(int j =0;j<arr.length;j++){
//计算余数
int ys = arr[j]/n%10;
//把当前遍历的数据放入指定的数组中
temp[ys][counts[ys]] = arr[j];
//记录数量
counts[ys]++;
}
//记录去的元素需要放的位置
int index = 0;
//把数字取出来
for(int k =0;k<temp.length;k++){
//记录数量的数组中当前余数记录的数量不为0 才取
if(counts[k] != 0){
//遍历循环取出元素
for(int l=0;l<counts[k];l++){
//取出元素
arr[index] = temp[k][l];
//记录下一个位置
index++;
}
//把数量置为0；
counts[k] =0;
}
}
}
}
}
八、堆排序(HeapSort):
升序排序使用大顶堆(根节点大于子节点)
降序排序使用小顶堆(根节点小于子节点)
例：
package cn.makasa1;
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 heapSize,int index){
//左子节点
int leftNode = 2*index+1;
//右子节点
int rightNode = 2*index+2;
int max = index;
//和两个子节点分别对比 找出最大的节点
if(leftNode<heapSize && arr[leftNode]>arr[max]){
max=leftNode;
}
if(rightNode<heapSize && arr[rightNode]>arr[max]){
max =rightNode;
}
//交换位置
if(max !=index){
int temp = arr[index];
arr[index] = arr[max];
arr[max] = temp;
//交换位置以后 可能会破坏之前排好的堆 需要重新调整
maxHeap(arr,heapSize,index);
}
}
}
扫一扫
1458
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
