5种经典排序算法，每个程序员都应该知道，现在做Linux运维开发有前途吗-CSDN博客

本文链接：https://blog.csdn.net/m0_60144796/article/details/137849413

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Linux运维全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上运维知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注运维）

正文

2. 选择排序

选择排序算法通过从未排序的部分中重复查找最小元素（考虑升序）并将其放在开头来对数组进行排序。该算法在给定数组中维护两个子数组：

已经排序的子数组
剩余未排序的子数组

在选择排序的每次迭代/传递中，都会从未排序的子数组中选取最小元素（考虑升序）并将其移至已排序的子数组。选择排序具有最小化交换次数的特性。因此，当交换成本较高时，它是最佳选择。

示例：
 arr[]= 23 78 45 8 32 46
Pass 1
 // 找到arr[0...5]中的最小元素并将其放在开头
8 78 45 23 32 46
Pass 2
 // 找到arr[1...5]中的最小元素并将其放在arr[1...5]的开头
8 23 45 78 32 46
Pass 3
 // 找到arr[2...5]中的最小元素并将其放在arr[2...5]的开头
8 23 32 78 45 46
Pass 4
 // 找到arr[3...5]中的最小元素并将其放在arr[3...5]的开头
8 23 32 45 78 46
Pass 5
 // 找到arr[4...5]中的最小元素并将其放在arr[4...5]的开头
8 23 32 45 46 78

选择排序的实现

选择排序

算法：
void SelectionSort (int a[], int n) 
{ 
int i,j, temp, min; 
for (i=0; i<n-1; i++) 
{ 
    min = i; 
    for (j=i+1; j<n; j++) 
      if (a[j] < a[min]) 
      { 
        min = j; 
      }
    温度 = a[i]; 
    a[i] = a[min]；
    a[分钟] = 温度；
} 
}

// C program for implementation of selection sort
#include <stdio.h>

void swap(int *xp, int *yp)
{
    int temp = *xp;
    *xp = *yp;
    *yp = temp;
}

void selectionSort(int arr[], int n)
{
    int i, j, min_idx;

    // One by one move boundary of unsorted subarray
    for (i = 0; i < n - 1; i++)
    {
        // Find the minimum element in unsorted array
        min_idx = i;
        for (j = i + 1; j < n; j++)
            if (arr[j] < arr[min_idx])
                min_idx = j;

        // Swap the found minimum element with the first element
        swap(&arr[min_idx], &arr[i]);
    }
}

/* Function to print an array */
void printArray(int arr[], int size)
{
    int i;
    for (i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

// Driver program to test above functions
int main()
{
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
    selectionSort(arr, n);
    printf("Sorted array: \n");
    printArray(arr, n);
    return 0;
}

3.冒泡排序

冒泡排序是一种排序算法，如果相邻元素的顺序错误，则重复交换相邻元素。每次迭代或传递后，最大的元素到达末尾（在升序的情况下）或最小的元素到达末尾（在降序的情况下）。重复遍历列表直到列表被排序。该算法不适合大型数据集，因为其平均和最坏情况复杂度为 Ο(n^2)，其中n是项目数

示例：
 64 34 25 12 22 11 90
迭代 1：
 ( 64 34 25 12 22 11 90) -> ( 34 64 25 12 22 11 90)，这里，算法比较前两个元素，并从 64 > 34 开始交换。
(34 64 25 12 22 11 90) - > (34 25 64 12 22 11 90)，从 64 开始交换 > 25
(34 25 64 12 22 11 90) -> (34 25 12 64 22 11 90)，从 64 开始交换 > 12
(34 25 12 64 22 11 90) ) -> (34 25 12 22 64 11 90)，从 64 > 22 开始交换
(34 25 12 22 64 11 90) -> (34 25 12 22 11 64 90)，从 64 > 11 开始交换
(34 25 12 22 11) 64 90 ) -> (34 25 12 22 11 64 90 )，现在，由于这些元素已经按顺序排列 (90 > 64)，算法不会交换它们。
迭代 2：(
 34 25 12 22 11 64 90) -> ( 25 34 12 22 11 64 90)，从 34 > 25 开始交换
( 25 34 12 22 11 64 90) -> (25 12 34 22 11 64 90)，自 34 > 12 起交换(25 12 34 22 11 64 90) -> (25 12 22 34 11 64 90)，自 34 > 22 起交换(25 12 22 34 11 64 90) -> (25 12 22 11 34 64 90) )，交换自 34 > 11(25 12 22 11 34 64 90) -> (25 12 22 11 34 64 90)，现在，由于这些元素已经按顺序排列 (64 > 34)，算法不会交换它们。


迭代 3：
 ( 25 12 22 11 34 64 90) -> ( 12 25 22 11 34 64 90)，从 25 > 12 开始交换
(12 25 22 11 34 64 90) -> (12 22 25 11 34 64 90)，自 25 > 22 起交换
(12 22 25 11 34 64 90) -> (12 22 11 25 34 64 90), 自 25 > 11 起交换
(12 22 11 25 34 64 90) -> (12 22 11 25 34 64 90) )，现在，由于这些元素已经按顺序排列 (34 > 25)，算法不会交换它们。
迭代 4：
 ( 12 22 11 25 34 64 90) -> ( 12 22 11 25 34 64 90)
(12 22 11 25 34 64 90) -> (12 11 22 25 34 64 90)，从 22 > 11 开始交换
( 12 11 22 25 34 64 90) -> (12 11 22 25 34 64 90)
迭代 5：(
 12 11 22 25 34 64 90) -> ( 11 12 22 25 34 64 90)，从 12 开始交换 > 11
(11 12 22 25 34 64 90) -> (11 12 22 25 34 64 90)
迭代 6：(
 11 12 22 25 34 64 90) -> ( 11 12 22 25 34 64 90)
现在，数组已经排序了，但是我们的算法不知道它是否已完成。该算法需要一整遍而不需要任何交换才能知道它已排序。
迭代7：
 ( 11 12 22 25 34 64 90) -> ( 11 12 22 25 34 64 90) 
(11 12 22 25 34 64 90) -> (11 12 22 25 34 64 90 ) ( 11 12 22 25 34 64 90) -> (11 12 22 25 34 64 90) (11 12 22 25 34 64 90) -> (11 12 22 25 34 64 90) (11 12 22 25 34 64 90) -> (11 12 22 25 34) 64 90) (11 12 22 25 34 64 90 ) -> (11 12 22 25 34 64 90 )

冒泡排序的实现。

冒泡排序

算法：
Bubble_Sort(int a[], n) 
{ 
int swapped, i, j; 
for (i=0; i<n; i++) 
{
   交换 = 0; 
   for (j=0; j<ni-1; j++) 
   { 
     if (a[j] > a[j+1]) 
     {
       交换 (a[j], a[j+1]); } 
       交换=1；   if    (交换== 0)
     中断     ; } }

// C program for implementation of Bubble sort
#include <stdio.h> 
  
void swap(int *xp, int *yp) 
{ 
    int temp = *xp; 
    *xp = *yp; 
    *yp = temp; 
} 
  
// An optimized version of Bubble Sort 
void bubbleSort(int arr[], int n) 
{ 
   int i, j; 
   bool swapped; 
   for (i = 0; i < n-1; i++) 
   { 
     swapped = false; 
     for (j = 0; j < n-i-1; j++) 
     { 
        if (arr[j] > arr[j+1]) 
        { 
           swap(&arr[j], &arr[j+1]); 
           swapped = true; 
        } 
     } 
  
     // IF no two elements were swapped by inner loop, then break 
     if (swapped == false) 
        break; 
   } 
} 
  
/* Function to print an array */
void printArray(int arr[], int size) 
{ 
    int i; 
    for (i=0; i < size; i++) 
        printf("%d ", arr[i]); 
    printf("n"); 
} 
  
// Driver program to test above functions 
int main() 
{ 
    int arr[] = {64, 34, 25, 12, 22, 11, 90}; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    bubbleSort(arr, n); 
    printf("Sorted array: \n"); 
    printArray(arr, n); 
    return 0; 
}

4. 归并排序

与上述三种排序算法不同，该算法基于分而治之技术。它将输入数组分为两半，为两半调用自身，然后合并已排序的两半。归并排序的核心是函数merge()，用于合并两半。merge(A, p, q, r) 是一个关键过程，它假设 A[p…q] 和 A[q+1…r] 已排序，并将两个已排序的子数组合并为一个。

当您需要稳定且 O(N log N) 排序时，合并排序是唯一的选择。

合并()函数

合并过程也称为异地过程

归并排序的实现

算法：
merge(A, p, q, r) 
{ 
  n1= q-p+1 
  n2= rq
  设 L[1:n+1] 和 R[1:n2+1] 为
  (i=1:n1) 的新数组
    L[i]= A[p+i-1] 
  for (j=1:n2) 
    R[j]= A[q+j] 
  L[n1 + 1]= 无穷大
  R[n2 + 1]= 无穷大
  i= 1、j=1 
  for (k=p:r) 
  { 
    if (L[i] <= R[j]) 
      A[k] = L[i] 
      i= i+1 
    else 
      A[k] = R[j ] 
      j= j+1 
  } 
}

/* C program for Merge Sort */
#include <stdio.h>
#include <stdlib.h>

// Merges two subarrays of arr[].
// First subarray is arr[l..m]
// Second subarray is arr[m+1..r]
void merge(int arr[], int l, int m, int r)
{
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;

    /* create temp arrays */
    int L[n1], R[n2];

    /* Copy data to temp arrays L[] and R[] */
    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];

    /* Merge the temp arrays back into arr[l..r]*/
    i = 0; // Initial index of first subarray
    j = 0; // Initial index of second subarray
    k = l; // Initial index of merged subarray
    while (i < n1 && j < n2)
    {
        if (L[i] <= R[j])
        {
            arr[k] = L[i];
            i++;
        }
        else
        {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    /* Copy the remaining elements of L[], if there 
	are any */
    while (i < n1)
    {
        arr[k] = L[i];
        i++;
        k++;
    }

    /* Copy the remaining elements of R[], if there 
	are any */
    while (j < n2)
    {
        arr[k] = R[j];
        j++;
        k++;
    }
}

/* l is for left index and r is right index of the 
sub-array of arr to be sorted */
void mergeSort(int arr[], int l, int r)
{
    if (l < r)
    {
        // Same as (l+r)/2, but avoids overflow for
        // large l and h
        int m = l + (r - l) / 2;

        // Sort first and second halves
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);

        merge(arr, l, m, r);
    }
}

/* UTILITY FUNCTIONS */
/* Function to print an array */
void printArray(int A[], int size)
{
    int i;
    for (i = 0; i < size; i++)
        printf("%d ", A[i]);
    printf("\n");
}

/* Driver program to test above functions */
int main()
{
    int arr[] = {12, 11, 13, 5, 6, 7};
    int arr_size = sizeof(arr) / sizeof(arr[0]);

    printf("Given array is \n");
    printArray(arr, arr_size);

    mergeSort(arr, 0, arr_size - 1);

    printf("\nSorted array is \n");
    printArray(arr, arr_size);
    return 0;
}

合并排序

整个归并排序按以下方式工作：

归并排序的实现。

归并排序

算法：
Merge_Sort(A, p ,r) 
{ 
  if p<r 
    q= [(p+r)/2] 
    Merge_Sort(A, p ,q) 
    Merge_Sort(A, q+1, r) 
    merge(A, p, q, r) 
}

5. 快速排序

快速排序也是一种分治算法。它选择一个元素作为主元，并围绕所选主元对给定数组进行分区，以便所有较小的元素都位于主元的左侧，所有较大的元素都位于主元的右侧。QuickSort 有许多不同的版本，它们以不同的方式选择枢轴：

始终选择第一个元素作为枢轴。
始终选择最后一个元素作为基准（在下面实现）。
选择一个随机元素作为基准。
选择中位数作为枢轴。

快速排序的关键过程是partition()方法。分区的目标是，给定一个数组和数组中的一个元素 r 作为主元，将r放在排序数组中的正确位置，并将所有较小的元素（小于r）放在r之前，并将所有较大的元素（大于 r ）放在 r 之前。比r ) 在r之后。所有这些都应该在线性时间内完成。

对于小输入，与合并排序相比，快速排序是最好的算法。当您不需要稳定的排序并且平均情况性能比最坏情况性能更重要时，请选择快速排序。我们先看看分区算法及其实现。

最后的话

最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！

资料预览

给大家整理的视频资料：

给大家整理的电子书资料：

如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注运维）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
快速排序。我们先看看分区算法及其实现。

最后的话

最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！

资料预览

给大家整理的视频资料：

[外链图片转存中…(img-JskFUDhQ-1713296344280)]

给大家整理的电子书资料：

[外链图片转存中…(img-2UBeVL25-1713296344280)]

如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注运维）
[外链图片转存中…(img-p1SnQWU8-1713296344280)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！