首页 / 算法 / 排序算法锻炼编程思维：冒泡，选择，插入，快速，归并

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

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了排序算法锻炼编程思维：冒泡，选择，插入，快速，归并，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含3879字，纯文字阅读大概需要6分钟。

内容图文

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

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

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

             1
            public
            static
            void
             main(String[] args) {

             2
            //
             TODO Auto-generated method stub
             3
            int []arr= {-10, 2, 3, 246, -100, 0, 5};
 4for(int i=0;i<arr.length-1;i++) {
 5for(int j=0;j<arr.length-i-1;j++) {
 6if(arr[j]>arr[j+1]) {
 7int temp=arr[j];
 8                     arr[j]=arr[j+1];
 9                     arr[j+1]=temp;
10                }
11            }
12        }
13for(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};
 4for(int i=0;i<arr.length-1;i++) {
 5int k=i;
 6//位置还不确定的数据 7for(int j=i+1;j<arr.length;j++) {
 8if(arr[j]<arr[k]) {
 9                     k=j;
10//遍历找到比k小的索引，然后把j赋给k；11                }
12            }
13if(i!=k) {
14int temp=arr[i];
15                 arr[i]=arr[k];
16                 arr[k]=temp;
17            }
18        }
19for(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};
 4int j=0;
 5for(int i=1;i<arr.length;i++) {
 6int temp=arr[i];
 7//temp存放将要插入的数据 8if(arr[i]<arr[i-1]) {
 9for( 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        }
16for(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);
 5for (int a : arr) {
 6             System.out.print(a + " ");
 7        }
 8    }
 910publicstaticint PartSort(int arr[], int low, int high) {
11int data = arr[low];
12/*13         * 一次遍历的方法：插空法 定义一个data将arr[low]存起来，并把这个位置挖空
14*/15while (low < high) {
16while (low < high && arr[high] >= data) {
17                 high--;
18            }
19             arr[low] = arr[high];
20/**21             * 从high，也就是后面往前遍历 找到比键值小的数据 插入到前面留下的空中 high位再次留下空来
22*/2324while (low < high && arr[low] <= data) {
25                 low++;
26            }
27             arr[high] = arr[low];
2829        }
30         arr[low] = data;
31/*32         * 循环退出后 low和high重合 将将键值赋给第low，并将low返回
33*/34return low;
35    }
3637publicstaticvoid QuickSort(int arr[], int low, int high) {
38if(low<high) {
39//防止发生栈溢出异常40int index = PartSort(arr, low, high);
41             QuickSort(arr, low, index - 1);
42             QuickSort(arr, index + 1, high);    
43        }
4445     }

 

归并排序
归并排序要点有两个：对于两个有序数组的合并；递归思想。合并两个有序数组要定义一个新数组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         MergeSort(arr, 0, arr.length-1);
 5for(int s:arr) {
 6             System.out.print(s+" ");
 7        }
 8    }
 9publicstaticvoid merge(int arr[],int low,int mid,int high ) {
10int temp[]=newint[high-low+1];
11/*12     * 创建数组的三种方法 
13     * 1.new int[数组长度];
14     * 2.｛数组的数据｝；
15     * 3.new int[]{数组的数据}
16*/17int i=low;
18//第一个数组的首索引19int j=mid+1;
20//第二个数组的首索引21int k=0;
22//新数组的首索引23while(i<=mid&&j<=high) {
24if(arr[i]<arr[j]) {
25             temp[k++]=arr[i++];
26        }
27else {
28             temp[k++]=arr[j++];
29        }
30    }
31//把两个有序数组合并到新数组中32while(i<=mid) {
33         temp[k++]=arr[i++];
34    }
35while(j<=high) {
36         temp[k++]=arr[j++];
37    }
38for(int n=0;n<temp.length;n++) {
39         arr[n+low]=temp[n];
40    }
41//排序好的数组放置在temp中，要将其复制到arr中。42}
43publicstaticvoid MergeSort(int arr[],int low,int high) {
44int mid=(low+high)/2;
45if(low<high) {
46//防止栈溢出异常47        MergeSort(arr,low,mid);
48         MergeSort(arr,mid+1,high);
49        merge(arr, low, mid, high); 
50    }
5152 }

 

 

 

 

原文：https://www.cnblogs.com/erichi101/p/12295873.html

内容总结

以上是互联网集市为您收集整理的排序算法锻炼编程思维：冒泡，选择，插入，快速，归并全部内容，希望文章能够帮你解决排序算法锻炼编程思维：冒泡，选择，插入，快速，归并所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1300608.html

来源：【匿名】