java实现经典排序算法
前言
博主最近在恶补基础知识，算法必然是必不可少的，那么就从经典排序算法开始吧！（图源网络，侵删）,没有列出所有，由于在期末考试囧
web
代码太多，就只显示了最关键的部分
1. 冒泡排序
实现思路：
（1）比较先后相邻的二个数据，若是前面数据大于后面的数据，就将这二个数据交换。
（2）这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第 N-1个位置。
（3）N=N-1，若是N不为 0就重复前面二步，不然排序完成。
这也是博主接触到的第一个排序算法算法
public static void bubbleSort1(){
int i, j;
for(i=0; i<n; i++){//表示 n次排序过程。
for(j=1; j<n-i; j++){
if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换
//交换a[j-1]和a[j]
int temp;
temp = a[j-1];
a[j-1] = a[j];
a[j]=temp;
}
}
}
}
图示：
shell
2. 插入排序算法
经过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置并插入。若是输入数组已是排好序的话，插入排序出现最佳状况，其运行时间是输入规模的一个线性函 数。若是输入数组是逆序排列的，将出现最坏状况。平均状况与最坏状况同样，其时间代价是(n2)。数组
public void sort()
{
for(int i =1; i<arr.length;i++)
{
//插入的数
int insertVal = arr[i];
//被插入的位置(准备和前一个数比较)
int index = i-1;
//若是插入的数比被插入的数小
while(index>=0&&insertVal<arr[index])
{
//将把arr[index] 向后移动
arr[index+1]=arr[index];
//让index向前移动
index--;
}
//把插入的数放入合适位置
arr[index+1]=insertVal;
}
}
图示：
3. 快速排序算法
快速排序的原理：选择一个关键值做为基准值。比基准值小的都在左边序列（通常是无序的）， 比基准值大的都在右边（通常是无序的）。通常选择序列的第一个元素。缓存
public void sort(){
int start = low;
int end = high;
int key = a[low];
while(end>start){
//从后往前比较
while(end>start&&a[end]>=key)
//若是没有比关键值小的，比较下一个，直到有比关键值小的交换位置，而后又从前日后比较
end--;
if(a[end]<=key){
int temp = a[end];
a[end] = a[start];
a[start] = temp;
}
//从前日后比较
while(end>start&&a[start]<=key)
//若是没有比关键值大的，比较下一个，直到有比关键值大的交换位置
start++;
if(a[start]>=key){
int temp = a[start];
a[start] = a[end];
a[end] = temp;
}
//此时第一次循环比较结束，关键值的位置已经肯定了。左边的值都比关键值小，右边的 值都比关键值大，可是两边的顺序还有多是不同的，进行下面的递归调用
}
//递归
if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个
}
}
图示：
4. 希尔排序
基本思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列 中的记录“基本有序”时，再对全体记录进行依次直接插入排序。网络
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进 行直接插入排序。仅增量因子为1 时，整个序列做为一个表来处理，表长度即为整个序列的长度。
private void shellSort() {
int dk = a.length/2;
while( dk >= 1 ){
ShellInsertSort(a, dk);
dk = dk/2;
}
}
private void ShellInsertSort(int[] a, int dk) {
//相似插入排序，只是插入排序增量是1，这里增量是dk,把1换成dk就能够了
for(int i=dk;i<a.length;i++){
if(a[i]<a[i-dk]){
int j;
int x=a[i];//x为待插入元素
a[i]=a[i-dk];
for(j=i-dk; j>=0 && x<a[j];j=j-dk){
//经过循环，逐个后移一位找到要插入的位置。
a[j+dk]=a[j];
}
a[j+dk]=x;//插入
}
}
}
图示：
5. 归并排序算法
归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列 分为若干个子序列，每一个子序列是有序的。而后再把有序子序列合并为总体有序序列svg
public class MergeSortTest (){
public static void main(String[] args) {
int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };
print(data);
mergeSort(data);
System.out.println("排序后的数组：");
print(data);
}
public static void mergeSort(int[] data) {
sort(data, 0, data.length - 1);
}
public static void sort(int[] data, int left, int right) {
if (left >= right)
return;
// 找出中间索引
int center = (left + right) / 2;
// 对左边数组进行递归
sort(data, left, center);
// 对右边数组进行递归
sort(data, center + 1, right);
// 合并
merge(data, left, center, right);
print(data);
}
/**
* 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序
*
* @param data
* 数组对象
* @param left
* 左数组的第一个元素的索引
* @param center
* 左数组的最后一个元素的索引，center+1是右数组第一个元素的索引
* @param right
* 右数组最后一个元素的索引
*/
public static void merge() {
// 临时数组
int[] tmpArr = new int[data.length];
// 右数组第一个元素索引
int mid = center + 1;
// third 记录临时数组的索引
int third = left;
// 缓存左数组第一个元素的索引
int tmp = left;
while (left <= center && mid <= right) {
// 从两个数组中取出最小的放入临时数组
if (data[left] <= data[mid]) {
tmpArr[third++] = data[left++];
} else {
tmpArr[third++] = data[mid++];
}
}
// 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
while (mid <= right) {
tmpArr[third++] = data[mid++];
}
while (left <= center) {
tmpArr[third++] = data[left++];
}
// 将临时数组中的内容拷贝回原数组中
// （原left-right范围的内容被复制回原数组）
while (tmp <= right) {
data[tmp] = tmpArr[tmp++];
}
}
public static void print(int[] data) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + "\t");
}
System.out.println();
}
}
图示：
6. 桶排序算法
桶排序的基本思想是： 把数组 arr 划分为 n 个大小相同子区间（桶），每一个子区间各自排序，最 后合并 。计数排序是桶排序的一种特殊状况，能够把计数排序当成每一个桶里只有一个元素的状况。3d
- 找出待排序数组中的最大值max、最小值min
- 咱们使用 动态数组 ArrayList 做为桶，桶里放的元素也用 ArrayList 存储。桶的数量为(maxmin)/arr.length+1
- 遍历数组 arr，计算每一个元素 arr[i] 放的桶
- 每一个桶各自排序
public static void bucketSort(){
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for(int i = 0; i < arr.length; i++){
max = Math.max(max, arr[i]);
min = Math.min(min, arr[i]);
}
//建立桶
int bucketNum = (max - min) / arr.length + 1;
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
for(int i = 0; i < bucketNum; i++){
bucketArr.add(new ArrayList<Integer>());
} //将每一个元素放入桶
for(int i = 0; i < arr.length; i++){
int num = (arr[i] - min) / (arr.length);
bucketArr.get(num).add(arr[i]); }
//对每一个桶进行排序
for(int i = 0; i < bucketArr.size(); i++){
Collections.sort(bucketArr.get(i));
}
}
}
图示：
code