常用的几种排序

#include <iostream>

void shell_sort(int a[],int n)
{
int i = 0;
int j = 0;
int gap = 0;
int tem = 0;
 for(gap = n/2; gap > 0; gap /= 2)
 {
 for(i = gap;i < n;i += gap)
 {
   for(j = 0;j < i; j += gap)
   {
     if(a[j] > a[i])
     {
       tem = a[j];
       a[j] = a[i];
       a[i] = tem;            
     }
   }
 }
 }
}

void choose_sort(int a[], int n)
{
 int i = 0;
 int j = 0;
 int tem = 0;
 int value = 0;
 for(i = 0; i < n; i++)
 {
   tem = i;
   for(j = i+1; j<n; j++)
   {
      if( a[j] < a[tem])
          tem = j;
   }
   value = a[i];
   a[i] = a[tem];
   a[tem] = value;
 }
}

void quick_sort(int a[],int f, int r)
{
int tem = a[f];
int i = f;
int j = r;
  
if(f<r)
{
while(i < j)
{
while((i<j) && (tem <= a[j]))
j--;
if(i<j)
a[i++] = a[j];

while((i<j) && (tem > a[i]))
i++;
if(i<j)
a[j--] = a[i];
}
a[i] = tem;
quick_sort(a,f,i-1);
quick_sort(a,i+1,r);
}
}

void insert_sort(int a[],int n)

  int i = 0;
  int j = 0;
  int tem = 0;
  for(i = 1; i < n; i++)
  {
     for(j = i-1; j>=0 && a[j] > a[j+1]; j--)
     {
        tem = a[j];
        a[j] = a[j+1];
        a[j+1] = tem;
     }  
  }
}

void bubble_sort(int a[],int n)
{
int i = 0;
int j = 0;
int tem = 0;
for(i = 0;i < n;i++)
{
for(j = 1;j<n-i;j++)
{
if(a[j-1] > a[j])
{
tem = a[j-1];
a[j-1] = a[j];
a[j] = tem;
}
   }

}

int main()
{
  int i = 0;
  int a[10] ={62,15,43,76,32,98,42,25,17,37};
 // shell_sort(a,sizeof(a)/sizeof(int));
 // choose_sort(a,10);
 // quick_sort(a,0,9);
 // insert_sort(a,10);
  bubble_sort(a,10);
  for(i = 0; i < sizeof(a)/sizeof(int); i++)
  {
      printf("this is a %d\n",a[i]);
  }
}
### 常见排序算法的实现与比较 在Python中,常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。每种算法都有其独特的实现方式和适用场景。 #### 冒泡排序 冒泡排序是一种简单的排序算法,它通过重复地遍历要排序的列表,比较相邻的元素并交换它们的位置来实现排序。冒泡排序的时间复杂度为O(n²),适用于数据量较小的情况。 ```python def bubble_sort(arr): n = len(arr) for i in range(0, n): is_swap = False for j in range(1, n-i): if arr[j] < arr[j-1]: arr[j], arr[j-1] = arr[j-1], arr[j] is_swap = True if not is_swap: return arr ``` #### 选择排序 选择排序通过每次选择最小的元素并将其放置在有序序列的末尾来实现排序。它的平均时间复杂度为O(n²),但空间复杂度为O(1)。 ```python def select_sort(nums): for i in range(len(nums)): min_index = i for j in range(i + 1, len(nums)): if nums[j] < nums[min_index]: min_index = j if min_index != i: nums[i], nums[min_index] = nums[min_index], nums[i] return nums ``` #### 插入排序 插入排序通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。其时间复杂度为O(n²),但在部分有序的数据集中表现良好。 ```python def insertion_sort(arr): for i in range(1, len(arr)): key = arr[i] j = i - 1 while j >= 0 and key < arr[j]: arr[j + 1] = arr[j] j -= 1 arr[j + 1] = key return arr ``` #### 快速排序 快速排序是一种分治法策略,通过选定一个基准值,将数组分成两部分,一部分小于基准值,另一部分大于基准值,然后递归地对这两部分进行排序。其平均时间复杂度为O(n log n)。 ```python def quick_sort(arr): if len(arr) <= 1: return arr else: pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right) ``` #### 归并排序 归并排序也是一种分治法策略,它将数组分成两半,分别排序,然后合并结果。其时间复杂度为O(n log n),并且是稳定的排序算法。 ```python def merge_sort(arr): if len(arr) > 1: mid = len(arr) // 2 left_half = arr[:mid] right_half = arr[mid:] merge_sort(left_half) merge_sort(right_half) i = j = k = 0 while i < len(left_half) and j < len(right_half): if left_half[i] < right_half[j]: arr[k] = left_half[i] i += 1 else: arr[k] = right_half[j] j += 1 k += 1 while i < len(left_half): arr[k] = left_half[i] i += 1 k += 1 while j < len(right_half): arr[k] = right_half[j] j += 1 k += 1 return arr ``` #### 性能比较 不同的排序算法在性能上有显著差异。冒泡排序、选择排序和插入排序在数据量较大时效率较低,而快速排序和归并排序在处理大数据集时表现出色。此外,Python的内置排序函数(如`sorted()`和`list.sort()`)使用了Timsort算法,结合了归并排序和插入排序的优点,具有良好的性能和稳定性[^2]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值