文章详情

Php文档 Php问答 行业资讯 Php论坛 Php手册 Php博客
  • 游戏榜单
  • 软件榜单
关闭导航
热搜榜
热门下载
热门标签
php教程
关闭搜索
php爱好者> php教程>排序算法十大经典方法(C#和java版)

排序算法十大经典方法(C#和java版)

时间：2024-12-08  来源：互联网  标签： PHP教程

在计算机科学中，排序算法是基础且关键的组成部分。它们负责将数据集按照特定的顺序排列，无论是升序还是降序。这些算法广泛应用于各种场景，从数据库管理到数据可视化，再到机器学习的数据预处理。今天，我们就来探讨一下十大经典排序方法的C#和Java实现，看看它们各自的特点和应用场景。

排序算法十大经典方法(C#和java版)

一、冒泡排序

冒泡排序是一种简单直观的排序算法，它通过重复遍历列表，比较相邻元素并交换位置，直到列表完全有序。虽然冒泡排序不是最快的排序算法，但它易于理解和实现，适合小数据量排序。

  • C#：

    • usingSystem;

classBubbleSort
{
publicstaticvoidMain()
{
int[]arr={64,34,25,12,22,11,90};

intn=arr.Length;
for(inti=0;i<n-1;i++)
{
for(intj=0;j<n-i-1;j++)
{
if(arr[j]>arr[j+1])
{
inttemp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}

Console.WriteLine("Sortedarray:");
foreach(intelementinarr)
{
Console.Write(element+"");
}
}
}

  • Java：

    • publicclassBubbleSort{
publicstaticvoidmain(String[]args){
intarr[]={64,34,25,12,22,11,90};

intn=arr.length;
for(inti=0;i<n-1;i++){
for(intj=0;j<n-i-1;j++){
if(arr[j]>arr[j+1]){
inttemp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}

System.out.println("Sortedarray:");
for(intelement:arr){
System.out.print(element+"");
}
}
}

    二、插入排序

    接下来是插入排序，它类似于整理手中的扑克牌，每次将一个待排序的元素插入到已排序的序列中的适当位置。这种方法对小规模或部分有序的数据非常高效，但在大数据集中性能较差。

  • C#：

    • usingSystem;

classInsertionSort
{
staticvoidMain()
{
int[]arr={64,34,25,12,22,11,90};

intn=arr.Length;
for(inti=1;i<n;i++)
{
intkey=arr[i];
intj=i-1;

while(j>=0&&arr[j]>key)
{
arr[j+1]=arr[j];
j=j-1;
}
arr[j+1]=key;
}

Console.WriteLine("Sortedarray:");
foreach(intelementinarr)
{
Console.Write(element+"");
}
}
}

  • Java：

    • publicclassInsertionSort{
publicstaticvoidmain(String[]args){
int[]arr={64,34,25,12,22,11,90};

intn=arr.length;
for(inti=1;i<n;i++){
intkey=arr[i];
intj=i-1;

while(j>=0&&arr[j]>key){
arr[j+1]=arr[j];
j=j-1;
}
arr[j+1]=key;
}

System.out.println("Sortedarray:");
for(intelement:arr){
System.out.print(element+"");
}
}
}

    三、选择排序

    选择排序则是一种更直接的方式，它会一次又一次地选择剩余元素中的最小值，并将其放在排序序列的末尾。这种方法容易实现，但效率并不高，因为它需要O(n^2)的时间复杂度。

  • C#：

    • usingSystem;

classSelectionSort
{
staticvoidMain()
{
int[]arr={64,25,12,22,11};

intn=arr.Length;
for(inti=0;i<n-1;i++)
{
intmin_idx=i;
for(intj=i+1;j<n;j++)
{
if(arr[j]<arr[min_idx])
{
min_idx=j;
}
}

inttemp=arr[min_idx];
arr[min_idx]=arr[i];
arr[i]=temp;
}

Console.WriteLine("Sortedarray:");
foreach(intelementinarr)
{
Console.Write(element+"");
}
}
}

  • Java：

    • publicclassSelectionSort{
publicstaticvoidmain(String[]args){
intarr[]={64,25,12,22,11};

intn=arr.length;
for(inti=0;i<n-1;i++){
intmin_idx=i;
for(intj=i+1;j<n;j++){
if(arr[j]<arr[min_idx]){
min_idx=j;
}
}

inttemp=arr[min_idx];
arr[min_idx]=arr[i];
arr[i]=temp;
}

System.out.println("Sortedarray:");
for(intelement:arr){
System.out.print(element+"");
}
}
}

    四、希尔排序

    希尔排序是插入排序的一种改进版本，通过定义一个增量序列来确定元素比较的距离，使得即使在大数据集上也能保持较高的效率。

  • C#：

    • usingSystem;

classShellSort
{
staticvoidMain()
{
int[]arr={12,34,54,2,3};

intn=arr.Length;

for(intgap=n/2;gap>0;gap/=2)
{
for(inti=gap;i<n;i++)
{
inttemp=arr[i];
intj;
for(j=i;j>=gap&&arr[j-gap]>temp;j-=gap)
{
arr[j]=arr[j-gap];
}
arr[j]=temp;
}
}

Console.WriteLine("Sortedarray:");
foreach(intelementinarr)
{
Console.Write(element+"");
}
}
}

  • Java：

    • publicclassShellSort{
publicstaticvoidmain(String[]args){
int[]arr={12,34,54,2,3};

intn=arr.length;

for(intgap=n/2;gap>0;gap/=2){
for(inti=gap;i<n;i++){
inttemp=arr[i];
intj;
for(j=i;j>=gap&&arr[j-gap]>temp;j-=gap){
arr[j]=arr[j-gap];
}
arr[j]=temp;
}
}

System.out.println("Sortedarray:");
for(intelement:arr){
System.out.print(element+"");
}
}
}

    五、归并排序

    归并排序采用分治策略，将数据集分割成小块，分别排序后再合并。它是一种稳定的、非原地排序算法，时间复杂度为O(nlogn)。

  • C#：

    • usingSystem;

classMergeSort
{
staticvoidMain()
{
int[]arr={12,11,13,5,6,7};

MergeSortFunction(arr,0,arr.Length-1);

Console.WriteLine("Sortedarray:");
foreach(intelementinarr)
{
Console.Write(element+"");
}
}

staticvoidMergeSortFunction(int[]arr,intl,intr)
{
if(l<r)
{
intm=l+(r-l)/2;
MergeSortFunction(arr,l,m);
MergeSortFunction(arr,m+1,r);
Merge(arr,l,m,r);
}
}

staticvoidMerge(int[]arr,intl,intm,intr)
{
intn1=m-l+1;
intn2=r-m;

int[]L=newint[n1];
int[]R=newint[n2];

for(inti=0;i<n1;i++)
L[i]=arr[l+i];
for(intj=0;j<n2;j++)
R[j]=arr[m+1+j];

intk=l,x=0,y=0;

while(x<n1&&y<n2)
{
if(L[x]<=R[y])
{
arr[k]=L[x];
x++;
}
else
{
arr[k]=R[y];
y++;
}
k++;
}

while(x<n1)
arr[k++]=L[x++];

while(y<n2)
arr[k++]=R[y++];
}
}

  • Java：

    • publicclassMergeSort{
publicstaticvoidmain(String[]args){
int[]arr={12,11,13,5,6,7};

mergeSort(arr,0,arr.length-1);

System.out.println("Sortedarray:");
for(intelement:arr){
System.out.print(element+"");
}
}

staticvoidmergeSort(int[]arr,intl,intr){
if(l<r){
intm=l+(r-l)/2;
mergeSort(arr,l,m);
mergeSort(arr,m+1,r);
merge(arr,l,m,r);
}
}

staticvoidmerge(int[]arr,intl,intm,intr){
intn1=m-l+1;
intn2=r-m;

int[]L=newint[n1];
int[]R=newint[n2];

for(inti=0;i<n1;i++)
L[i]=arr[l+i];
for(intj=0;j<n2;j++)
R[j]=arr[m+1+j];

inti=0,j=0;
intk=l;

while(i<n1&&j<n2){
if(L[i]<=R[j]){
arr[k]=L[i];
i++;
}
else{
arr[k]=R[j];
j++;
}
k++;
}

while(i<n1){
arr[k]=L[i];
i++;
k++;
}

while(j<n2){
arr[k]=R[j];
j++;
k++;
}
}
}

    六、快速排序

    快速排序同样使用分治思想，选择一个基准值，然后将数组分为小于和大于基准值的两个子数组，递归地对这两个子数组进行排序。尽管最坏情况下的时间复杂度为O(n^2)，但平均情况下它是非常高效的。

  • C#：

    • usingSystem;

classQuickSort
{
staticvoidMain()
{
int[]arr={12,11,13,5,6,7};

QuickSortFunction(arr,0,arr.Length-1);

Console.WriteLine("Sortedarray:");
foreach(intelementinarr)
{
Console.Write(element+"");
}
}

staticvoidQuickSortFunction(int[]arr,intlow,inthigh)
{
if(low<high)
{
intpi=Partition(arr,low,high);

QuickSortFunction(arr,low,pi-1);
QuickSortFunction(arr,pi+1,high);
}
}

staticintPartition(int[]arr,intlow,inthigh)
{
intpivot=arr[high];
inti=low-1;

for(intj=low;j<=high-1;j++)
{
if(arr[j]<pivot)
{
i++;
inttemp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}

inttemp1=arr[i+1];
arr[i+1]=arr[high];
arr[high]=temp1;

returni+1;
}
}

  • Java：

    • publicclassQuickSort{
publicstaticvoidmain(String[]args){
int[]arr={12,11,13,5,6,7};

quickSort(arr,0,arr.length-1);

System.out.println("Sortedarray:");
for(intelement:arr){
System.out.print(element+"");
}
}

staticvoidquickSort(int[]arr,intlow,inthigh){
if(low<high){
intpi=partition(arr,low,high);

quickSort(arr,low,pi-1);
quickSort(arr,pi+1,high);
}
}

staticintpartition(int[]arr,intlow,inthigh){
intpivot=arr[high];
inti=low-1;

for(intj=low;j<high;j

    七、堆排序

    堆排序利用二叉堆这一数据结构的特性，可以迅速找到最大或最小的元素。它是一种原地、非稳定的排序算法，时间复杂度为O(nlogn)。

  • C#：

    • usingSystem;

classHeapSort
{
staticvoidMain()
{
int[]arr={12,11,13,5,6,7};

HeapSortFunction(arr);

Console.WriteLine("Sortedarray:");
foreach(intelementinarr)
{
Console.Write(element+"");
}
}

staticvoidHeapSortFunction(int[]arr)
{
intn=arr.Length;

for(inti=n/2-1;i>=0;i--)
Heapify(arr,n,i);

for(inti=n-1;i>0;i--)
{
inttemp=arr[0];
arr[0]=arr[i];
arr[i]=temp;

Heapify(arr,i,0);
}
}

staticvoidHeapify(int[]arr,intn,inti)
{
intlargest=i;
intleft=2*i+1;
intright=2*i+2;

if(left<n&&arr[left]>arr[largest])
largest=left;

if(right<n&&arr[right]>arr[largest])
largest=right;

if(largest!=i)
{
intswap=arr[i];
arr[i]=arr[largest];
arr[largest]=swap;

Heapify(arr,n,largest);
}
}
}

  • Java：

    • publicclassHeapSort{
publicstaticvoidmain(String[]args){
int[]arr={12,11,13,5,6,7};

heapSort(arr);

System.out.println("Sortedarray:");
for(intelement:arr){
System.out.print(element+"");
}
}

staticvoidheapSort(int[]arr){
intn=arr.length;

for(inti=n/2-1;i>=0;i--)
heapify(arr,n,i);

for(inti=n-1;i>0;i--){
inttemp=arr[0];
arr[0]=arr[i];
arr[i]=temp;

heap

    八、计数排序

    计数排序是一个线性时间复杂度的排序算法，适用于知道最大数值和最小数值的情况。它通过创建一个计数数组来记录每个元素的出现次数，然后根据这个信息重新构建排序后的数组。

  • C#：

    • usingSystem;

classCountingSort
{
staticvoidMain()
{
int[]arr={4,2,2,8,3,3,1};

CountingSortFunction(arr);

Console.WriteLine("Sortedarray:");
foreach(intelementinarr)
{
Console.Write(element+"");
}
}

staticvoidCountingSortFunction(int[]arr)
{
intn=arr.Length;
intmax=arr[0];
for(inti=1;i<n;i++)
{
if(arr[i]>max)
max=arr[i];
}

int[]count=newint[max+1];
int[]output=newint[n];

for(inti=0;i<n;i++)
{
count[arr[i]]++;
}

for(inti=1;i<=max;i++)
{
count[i]+=count[i-1];
}

for(inti=n-1;i>=0;i--)
{
output[count[arr[i]]-1]=arr[i];
count[arr[i]]--;
}

for(inti=0;i<n;i++)
{
arr[i]=output[i];
}
}
}

  • Java：

    • publicclassCountingSort{
publicstaticvoidmain(String[]args){
int[]arr={4,2,2,8,3,3,1};

countingSort(arr);

System.out.println("Sortedarray:");
for(intelement:arr){
System.out.print(element+"");
}
}

staticvoidcountingSort(int[]arr){
intn=arr.length;
intmax=arr[0];
for(inti=1;i<n;i++){
if(arr[i]>max)
max=arr[i];
}

int[]count=newint[max+1];
int[]output=newint[n];

for(inti=0;i<n;i++){
count[arr[i]]++;
}

for(inti=1;

    九、桶排序

    桶排序与计数排序类似，都是线性时间复杂度的排序算法。它将元素分布到有限数量的桶中，每个桶各自排序，然后连接各个桶。适用于元素均匀分布在特定范围的场景。

  • C#：

    • usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;

classBucketSort
{
staticvoidMain()
{
int[]arr={170,45,75,90,802,24,2,66};

List<int>sortedArr=BucketSortFunction(arr);

Console.WriteLine("Sortedarray:");
foreach(intelementinsortedArr)
{
Console.Write(element+"");
}
}

staticList<int>BucketSortFunction(int[]arr)
{
intn=arr.Length;
List<int>sortedArr=newList<int>();
List<int>[]buckets=newList<int>[n];

for(inti=0;i<n;i++)
{
intbucket=arr[i]/10;
if(buckets[bucket]==null)
{
buckets[bucket]=newList<int>();
}
buckets[bucket].Add(arr[i]);
}

for(inti=0;i<n;i++)
{
if(buckets[i]!=null)
{
buckets[i]=buckets[i].OrderBy(x=>x).ToList();
sortedArr.AddRange(buckets[i]);
}
}

returnsortedArr;
}
}

  • Java：

    • importjava.util.ArrayList;
importjava.util.List;

publicclassBucketSort{
publicstaticvoidmain(String[]args){
int[]arr={170,45,75,90,802,24,2,66};

List<Integer>sortedArr=bucketSort(arr);

System.out.println("Sortedarray:");
for(intelement:sortedArr){
System.out.print(element+"");
}
}

staticList<Integer>bucketSort(int[]arr){
intn=arr.length;
List<Integer>sortedArr=newArrayList<>();
List<Integer>[]buckets=newList[n];

for(inti=0;i<n;i++){
intbucket=arr[i]/10;
if(buckets[bucket]==null){
buckets[bucket]=newArrayList<>();
}
buckets[bucket].add(arr[i]);
}

for(inti=0;i<n;i++){
if(

    十、基数排序

    基数排序是一种基于数字的位或基数的排序方法，它使用稳定的子过程（如计数排序）按位进行排序。由于其稳定性，基数排序特别适合对大型数字集合进行排序。

  • C#：

    • usingSystem;

classRadixSort
{
staticvoidMain()
{
int[]arr={170,45,75,90,802,24,2,66};

intn=arr.Length;
intmax=arr[0];
for(inti=1;i<n;i++)
{
if(arr[i]>max)
max=arr[i];
}

for(intexp=1;max/exp>0;exp*=10)
CountingSort(arr,n,exp);

Console.WriteLine("Sortedarray:");
foreach(intelementinarr)
{
Console.Write(element+"");
}
}

staticvoidCountingSort(int[]arr,intn,intexp)
{
int[]output=newint[n];
int[]count=newint[10];
for(inti=0;i<n;i++)
count[(arr[i]/exp)%10]++;

for(inti=1;i<10;i++)
count[i]+=count[i-1];

for(inti=n-1;i>=0;i--)
{
output[count[(arr[i]/exp)%10]-1]=arr[i];
count[(arr[i]/exp)%10]--;
}

for(inti=0;i<n;i++)
arr[i]=output[i];
}
}

  • Java：

    • publicclassRadixSort{
publicstaticvoidmain(String[]args){
int[]arr={170,45,75,90,802,24,2,66};

intn=arr.length;
intmax=arr[0];
for(inti=1;i<n;i++){
if(arr[i]>max){
max=arr[i];
}
}

for(intexp=1;max/exp>0;exp*=10){
countingSort(arr,n,exp);
}

System.out.println("Sortedarray:");
for(intelement:arr){
System


    在实现这些算法时，C#和Java都有各自的特点。C#提供了丰富的库函数，使得实现某些算法更加简便。而Java则以其跨平台的特性和强大的社区支持而备受青睐。不过，无论选择哪种语言，理解每种排序算法的原理和适用场景都是编程中不可或缺的技能。

    以上就是php小编整理的全部内容，希望对您有所帮助，更多相关资料请查看php教程栏目。

    相关阅读更多 +
    最近更新
    排行榜 更多 +
    元梦之星最新版手游

    元梦之星最新版手游

    棋牌卡牌 下载
    我自为道安卓版

    我自为道安卓版

    角色扮演 下载
    一剑斩仙

    一剑斩仙

    角色扮演 下载

    Copyright 2006-2020 (phpxiu.com) All Rights Reserved.

    本站为非盈利性网站，不接受任何广告。php爱好者