排序算法
Posted lixuec
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了排序算法相关的知识，希望对你有一定的参考价值。
??数组有很多排序算法，主要的排序算法有10种：，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，基数排序，堆排序，计数排序，桶排序。下面为大家简单介绍几种排序算法。
一、冒泡算法
??1. 基本思想
??冒泡排序的相邻的元素进行比较，如果满足条件就交换两个元素，把大的元素放到后面，小的元素像气泡一样上升到顶部。
??2. 算法实现
??冒泡排序需要双层循环来实现，其中外层循环控制排序的轮数，内存循环控制用于对比两个元素的大小，以确定是否进行交换。下面代码进行代码实现：
import java.util.Arrays;
public class Maopao
public static void main(String[] args)
int arr[]=2,5,8,7,1,0,9;
for (int i = 0; i < arr.length; i++)
for(int j=1;j<arr.length;j++)
if(arr[j]<arr[j-1])
int s=arr[j];
arr[j]=arr[j-1];
arr[j-1]=s;
System.out.println(Arrays.toString(arr));
??运行结果如下图：
二、选择排序
??1. 基本思想
??选择排序的基本思想就是将指定的元素与其他的元素分别进行对比，如果满足条件就交换这两个元素，区别于冒泡排序的是，选择排序是一个分别与其他元素进行对比，而冒泡排序只是两个相邻的元素进行比较。
??2. 算法实现
??选择排序在每一轮的排序都能找出一个最大或者最小的元素，顺序的排放数组的最后，直到元素全部排完顺序。选择排序也是使用双层循环，外层循环控制每一轮指定的元素，内层循环则控制每一个与指定元素进行比较的元素。代码实现如下：
import java.util.Arrays;
public class Xuanzhe
public static void main(String[] args)
int arr[] = 2, 5, 8, 7, 1, 0, 9,-2,-3;
for (int i = 0; i < arr.length-1; i++)
for (int j = 1 + i; j < arr.length; j++)
if (arr[i] > arr[j])
int s = arr[j];
arr[j] = arr[i];
arr[i] = s;
System.out.println(Arrays.toString(arr));
??运行结果如下图：
三、插入排序
??1. 基本思想
??直接插入排序的比较就是把后一个元素和前面的有序列表进行比较，使之仍然有序，比如一个数组为｛2，3，5，1，9，0｝，那么先让 3 和｛2｝ 进行 比较，符合条件的话交换两个元素，否则让5和前面的有序数列｛2，3｝进行比较得到有序数列｛2，3，5｝然后让1和这个数列再进行比较，如果1小于数列中的元素那么就进行交换，直到1和三个元素比较完毕。然后得到数列｛1，2，3，5｝，以此类推，当到最后一个元素比较完毕会得到一个完整的有序数列｛0，1，2，3，5，9｝。
??2. 算法实现
??插入排序也可以使用双层循环，外层循环控制轮次，内层循环控制每个元素和有序数列进行比较，具体代码实现如下：
import java.util.Arrays;
public class Charu
public static void main(String[] args)
int arr[] = 2, 5, 8, 7, 1, 0, 9;
for (int i = 1; i < arr.length; i++)
for (int j = i; j > 0; j--)
if (arr[j] < arr[j - 1])
int s = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = s;
System.out.println(Arrays.toString(arr));
??运行结果如下图所示：
四、希尔排序
??1. 基本思想
??其实希尔排序是插入排序的升级版本，因为插入排序就相当于间隔为1的希尔排序。希尔排序就是选取一个合适的间隔n，让间隔为n的两个数进行比较，这样可以使数组大致的有点顺序，让我们再缩小间隔，直到把间隔缩小到1，那么整个数组就完成了排序。原理如下图所示：
??如上面的图示，每一轮都可以使数组大致有序，当间隔为1的时候，数组就全部排好顺序。
??2. 算法实现
??希尔排序用到了三层for循环，第一层是控制间隔d，第二层确定间隔为d的那个元素，第三次循环则控制间隔为d的两个元素进行比较，具体代码实现如下：
import java.util.Arrays;
public class Shell
public static void main(String[] args)
int arr[] = 100, -2, 2, 5, 8, 7, 1, 0, 9;
int index = 1;
while (index < arr.length / 3)
index = index * 3 + 1;
for (int h = index; h > 0; h = (h - 1) / 3)
for (int i = h; i < arr.length; i++)
for (int j = i; j > h - 1; j -= h)
if (arr[j] < arr[j - h])
int s = arr[j - h];
arr[j - h] = arr[j];
arr[j] = s;
System.out.println(Arrays.toString(arr));
??代码中是while循环是为了选择一个合适的间隔，利用的克努特序列（h=3*h+1），因为选择一个合适的间隔可以减少循环的次数，提高效率。
五、快速排序
??1. 基本思想
??快速排序的基本思想就是选一个参照数，让每个元素和它进行比较，如果小于这个数就把这个数排到它的左边，如果小于它就排到它的右边。然后再对参照数左边的数据和右边的数据重复上述步骤，直到整个数组有序。
??2. 算法实现
??具体代码实现如下：
public class Quicksort
public static void main(String[] args)
int arr[] = 100, -5, -56, 2, 5, 8, 7, 1, 0, 9;
pai(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
public static void pai(int arr[], int start, int end)
if (end > start)
int index = getIndex(arr, start, end);
pai(arr, start, index - 1);
pai(arr, index + 1, end);
private static int getIndex(int arr[], int startIndex, int endIndex)
int i = startIndex;
int j = endIndex;
int x = arr[i];
while (j > i)
while (j > i && arr[j] >= x)
j--;
if (j>i)
arr[i] = arr[j];
i++;
while (j > i && x >=arr[i])
i++;
if (j>i)
arr[j] = arr[i];
j--;
arr[i] = x;
return i;
??上面的代码主要内容就是要获取那个参照数的索引，getIndex()方法就是获取参照数的索引，而pai()方法就是对符号条件的元素进行交换，然后递归调用，直到排序完成。
六、归并排序
??1. 基本思想
??归并排序的思想就是该算法采用经典的分治（divide-and-conquer）策略，将大的问题分成小的问题，然后用递归进行解决。如下图所示，把数组分成单个的有序数列，然后再进行治的操作，把他们再合并为一个有序的数列
??2. 算法实现
??代码分为两部分，第一步是就是利用递归把一个数组分成多个单个元素，第二步是治的阶段，把分完的元素，归到一块去，使之成为一个有序的数组。在实现的时候我们要创建一个临时数组进行存放元素，排序之后再把元素放到原来的数组里面。具体代码实现如下：
import java.util.Arrays;
public class Guibing
public static void main(String[] args)
int arr[] = 1, -2, 3, 4, 5, 9, 6;
chai(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
private static void chai(int[] arr, int start, int end)
int center = (start + end) / 2;
if (end > start)
chai(arr, start, center);
chai(arr, center + 1, end);
gui(arr, start, center, end);
private static void gui(int arr[], int start, int center, int end)
int tempArr[] = new int[end - start + 1];
int i = start;
int j = center + 1;
int index = 0;
while (i <= center && j <= end)
if (arr[i] <= arr[j])
tempArr[index] = arr[i];
i++;
else
tempArr[index] = arr[j];
j++;
index++;
while (i <= center)
tempArr[index] = arr[i];
i++;
index++;
while (j <= end)
tempArr[index] = arr[j];
j++;
index++;
for (int k = 0; k < tempArr.length; k++)
arr[k + start] = tempArr[k];
??运行结果如下：
#### 七、基数排序
##### ??1. 基本思想
??基数排序和前面排序不同的是，基数排序不进行数据是比较，他是遍历每个元素，然后把个位相同的元素按顺序放到一个容器里面，得到一个顺序的数组；然后再把该数组里十位数相同的元素再次放到容器里面，再得到一个顺序的数组，直到把最大位的元素也排序成功，这时就会得到一个由顺序的数组。如下图所示：
##### ??2. 算法实现
??基数排序需要创建一个二维数组，里面放10个容器用来存放数据，然后我们还需要找出最大的那个数，判断他是几位数，具体代码实现如下：
import java.util.Arrays;
public class JishuSort
public static void main(String[] args)
int[] arr = 73, 22, 93, 43, 55, 14, 28;
sortArr(arr);
System.out.println(Arrays.toString(arr));
private static void sortArr(int[] arr)
//最大数有几位,我们就排几轮
int max = getMax(arr);
int len = String.valueOf(max).length();
//定义一个二维数组,长度为10
int[][] tempArr = new int[10][arr.length];
//再定义一个数组,长度和二维数组的长度一样,用于记录二维数组中的每一个桶位存了几个数字
int[] counts = new int[10];
for (int i = 0, n = 1; i < len; i++, n *= 10)
//循环遍历,取每个位上的数字
for (int j = 0; j < arr.length; j++)
//取每个位上的数字
int ys = arr[j] / n % 10;
//int count=counts[ys];
tempArr[ys][counts[ys]] = arr[j];
counts[ys]++;
// count++;//二维数组中的一维数组放了要一个数,就在统计数组对应的位置统计一下
// counts[ys] = count; //将累加后的值,赋值给统计数组
//取出每个桶中的元素,放入原来的数组
int index = 0;
for (int k = 0; k < counts.length; k++)
//取出统计数组在每个位置上统计的个数
if (counts[k] != 0)
for (int h = 0; h < counts[k]; h++)
arr[index] = tempArr[k][h];
index++;
counts[k] = 0; //一趟完成后,把统计的个数清0
private static int getMax(int[] arr)
int max = arr[0];
for (int i = 1; i < arr.length; i++)
if (arr[i] > max)
max = arr[i];
return max;
??以上就是我为大家介绍的几种排序。
以上是关于排序算法的主要内容，如果未能解决你的问题，请参考以下文章