排序算法锻炼编程思维:冒泡,选择,插入,快速,归并

冒泡,选择,插入,快速,归并这五个排序是所有编程语言初学者所遇到过的,可能在实际的编程应用中不会遇到,

但对于锻炼编程思维,还是有很好的作用。

冒泡排序
冒泡排序的就是让大的数向后冒,让小的数向前冒。通过前后两个数据比较,不断将大的元素移动到尾部。

复制代码
 1     public static void main(String[] args) {
 2         // TODO Auto-generated method stub
 3         int []arr= {-10, 2, 3, 246, -100, 0, 5};
 4         for(int i=0;i<arr.length-1;i++) {
 5             for(int j=0;j<arr.length-i-1;j++) {
 6                 if(arr[j]>arr[j+1]) {
 7                     int temp=arr[j];
 8                     arr[j]=arr[j+1];
 9                     arr[j+1]=temp;
10                 }
11             }
12         }
13         for(int a:arr) {
14             System.out.print(a+" ");
15         }
16     }
复制代码

 

选择排序
选择排序就是把无序区的最小元素与首元素互换位置,然后将有序区的区间扩大一位,直到所有无序区都变成有序区。

复制代码
 1 public static void main(String[] args) {
 2         // TODO Auto-generated method stub
 3         int []arr= {-10, 2, 3, 246, -100, 0, 5};
 4         for(int i=0;i<arr.length-1;i++) {
 5             int k=i;
 6                   //位置还不确定的数据
 7             for(int j=i+1;j<arr.length;j++) {
 8                 if(arr[j]<arr[k]) {
 9                     k=j;
10                     //遍历找到比k小的索引,然后把j赋给k;
11                 }
12             }
13             if(i!=k) {
14                 int temp=arr[i];
15                 arr[i]=arr[k];
16                 arr[k]=temp;
17             }
18         }
19         for(int a:arr) {
20             System.out.print(a+" ");
21         }
22     }
复制代码

 

插入排序
插入排序是把数组分为有序区和无序区两块,然后将无序区的指定索引的数插入到有序区的指定位置,假设第0个元素是已经排序好的,无序区第一次循环从1开始遍历,设置一个temp,找到要插入的位置,把temp插入到有序区指定位置。
复制代码
 1     public static void main(String[] args) {
 2         // TODO Auto-generated method stub
 3         int []arr= {-10, 2, 3, 246, -100, 0, 5};
 4         int j=0;
 5         for(int i=1;i<arr.length;i++) {
 6             int temp=arr[i];
 7             //temp存放将要插入的数据
 8             if(arr[i]<arr[i-1]) {
 9                 for( j=i-1;j>=0&&arr[j]>temp;j--) {
10                     arr[j+1]=arr[j];
11                     //temp的位置空出来,把第j个的值赋给第j+1个;
12                 }
13                 arr[j+1]=temp;
14             }
15         }
16         for(int a:arr) {
17             System.out.print(a+" ");
18         }
19     }
复制代码

 

快速排序
快速排序主要思想方法有两个:一趟排序和分治;一趟排序完成数组的第一次排序,设置一个键值data,找到对应正确的位置,data的值插进去;分治就是用分而治之的思想,将键值左右两侧分为两个部分,再调用递归,将左边的部分再分为两个部分,将右边的部分再分为两个部分,依此类推,直到将数组排列完。

复制代码
 1 public static void main(String[] args) {
 2         // TODO Auto-generated method stub
 3         int[] arr = { -10, 2, 3, 246, -100, 0, 5 };
 4         QuickSort(arr, 0, arr.length - 1);
 5         for (int a : arr) {
 6             System.out.print(a + " ");
 7         }
 8     }
 9 
10     public static int PartSort(int arr[], int low, int high) {
11         int data = arr[low];
12         /*
13          * 一次遍历的方法:插空法 定义一个data将arr[low]存起来,并把这个位置挖空
14          */
15         while (low < high) {
16             while (low < high && arr[high] >= data) {
17                 high--;
18             }
19             arr[low] = arr[high];
20             /**
21              * 从high,也就是后面往前遍历 找到比键值小的数据 插入到前面留下的空中 high位再次留下空来
22              */
23 
24             while (low < high && arr[low] <= data) {
25                 low++;
26             }
27             arr[high] = arr[low];
28 
29         }
30         arr[low] = data;
31         /*
32          * 循环退出后 low和high重合 将将键值赋给第low,并将low返回
33          */
34         return low;
35     }
36 
37     public static void QuickSort(int arr[], int low, int high) {
38         if(low<high) {
39             //防止发生栈溢出异常
40             int index = PartSort(arr, low, high);
41             QuickSort(arr, low, index - 1);
42             QuickSort(arr, index + 1, high);    
43         }
44 
45     }
复制代码

 

归并排序
归并排序要点有两个:对于两个有序数组的合并;递归思想。合并两个有序数组要定义一个新数组temp来存放合并后的数组,并通过判断条件让新的数组在合并后成为有序数组。归并的时候让数组调用自己,一步步将数组的长度变小,当子数组被分治到只有一个元素的时候,子数组也就是有序数组,这时候可以调用合并有序数组的方法,整个数组也就完成了排序。

 

 

 

复制代码
 1     public static void main(String[] args) {
 2         int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
 3         mergeSort(a, 0, a.length - 1);
 4         System.out.println("排好序的数组:");
 5         for (int e : a)
 6             System.out.print(e + " ");
 7 
 8     }
 9 
10     //两路归并算法,两个排好序的子序列合并为一个子序列
11     public static  void merge(int []a,int left,int mid,int right){
12         int []tmp=new int[a.length];//辅助数组
13         int p1=left,p2=mid+1,k=left;//p1、p2是检测指针,k是存放指针
14 
15         while(p1<=mid && p2<=right){
16             if(a[p1]<=a[p2])
17                 tmp[k++]=a[p1++];
18             else
19                 tmp[k++]=a[p2++];
20         }
21 
22         while(p1<=mid) tmp[k++]=a[p1++];//如果第一个序列未检测完,直接将后面所有元素加到合并的序列中
23         while(p2<=right) tmp[k++]=a[p2++];//如果第二个序列未检测完,直接将后面所有元素加到合并的序列中
24 
25         //复制回原数组
26         for (int i = left; i <=right; i++)
27             a[i]=tmp[i];
28     }
29 
30 
31     public static void mergeSort(int [] a,int start,int end){
32         if(start<end){//当子序列中只有一个元素时结束递归
33             int mid=(start+end)/2;//划分子序列
34             mergeSort(a, start, mid);//对左侧子序列进行递归排序
35             mergeSort(a, mid+1, end);//对右侧子序列进行递归排序
36             merge(a, start, mid, end);//合并
37             System.out.println("start = " + start + ", mid = " + mid+ ", end = " + end);
38 
39         }
40     }
复制代码

 

 



 

posted @   琅琊甲乙木  阅读(241)  评论(0编辑  收藏  举报
编辑推荐:
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列:如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· Linux系列:如何用 C#调用 C方法造成内存泄露
阅读排行:
· 震惊!C++程序真的从main开始吗?99%的程序员都答错了
· 【硬核科普】Trae如何「偷看」你的代码?零基础破解AI编程运行原理
· 单元测试从入门到精通
· 上周热点回顾(3.3-3.9)
· Vue3状态管理终极指南:Pinia保姆级教程
点击右上角即可分享
微信分享提示