java排序算法

已于 2022-12-15 11:19:29 修改
阅读量262 收藏 2
点赞数 1
文章标签： 数据结构
于 2022-12-15 04:00:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ww_kobe/article/details/128324100
版权

目录

一 冒泡排序

二 选择排序

三 插入排序

四 希尔排序

五 快速排序

5.1 单边循环快速排序

5.2 双边循环快速排序

六 二分查找

七 总结

一 冒泡排序

  1. 依次比较数组中相邻的两个元素，若 arr[i] > arr[i+1]，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是最大的元素排在最后。
  2. 重复以上操作，直至整个数组有序。
  3. 每轮冒泡时，最后一次交换索引可以作为下一轮冒泡的比较次数，如果这个值为0，表示整个数组有序，直接退出外层循环。
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5,9,7,4,1,2,8,3,6};
        bubble(arr);
    }

    public static void bubble(int[] arr) {
        int n = arr.length - 1;
        while(true) {
            int last = 0; // 最后一次交换索引位置
            for(int i=0;i<n;i++) {
                if(arr[i] > arr[i+1]) {
                    swap(arr, i, i+1);
                    last = i;
                } 
            }
            n = last;
            if(n == 0) {
                break;
            }
            System.out.println(Arrays.toString(arr));
        }  
    }

    public static void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

二 选择排序

  1. 将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集。
  2. 重复以上操作，直至整个数组有序。
  3. 每轮可以先找到最小的索引，在每轮最后在交换元素。
public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {5,9,7,4,1,2,8,3,6};
        selection(arr);
    }

    public static void selection(int[] arr) {
        for(int i=0;i<arr.length-1;i++) {
            int s = i; // 记录最小元素索引
            for(int j=s+1;j<arr.length;j++) {
            	if(arr[s] > arr[j]) {
            		s=j;
            	}
            }
            if(s != i) {
                swap(arr, s, i);
            }
            System.out.println(Arrays.toString(arr));
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

三 插入排序

  1. 将数组分为两个区域，排序区和未排序区，每一轮从未排序区域选取第一个元素，插入到排序区域（需要保证顺序）。
  2. 重复以上操作，直至整个数组有序。
  3. 待插入元素进行比较时，遇到比自己小的元素，就代表找到了插入位置，无需进行后续比较。
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {5,9,7,4,1,2,8,3,6};
        insert(arr);
    }

    public static void insert(int[] arr) {
    	// i 代表待插入元素的索引
        for(int i=1;i<arr.length;i++) {
            int t = arr[i]; // 待插入元素的值
            int j = i-1; // 已排序元素的索引
            while(j >= 0) {
                if(t < arr[j]) {
                    arr[j+1] = arr[j];
                } else {
                    break; // 退出循环，减少比较次数
                }
                j--;
            }
            arr[j+1] = t;
            System.out.println(Arrays.toString(arr));
        }
    }
}

四 希尔排序

  1. 设置间隙序列。
  2. 将间隙相同元素划为一组，对每组使用插入排序。
  3. 重复以上操作，直至数组有序。
public class ShellSort {
	
	public static void main(String[] args) {
		int[] arr = {5,9,7,4,1,2,8,3,6};
		shell(arr);
	}
	
	public static void shell(int[] arr) {
		// 分而治之，循环为每次总数除二
		for (int gap = arr.length/2; gap > 0; gap /= 2) {
			// 循环分治的每一个分组使用插入排序
	        for (int i = gap; i < arr.length; i++) {
	            int t = arr[i];
	            int j = i-gap;
	            while (j >= 0) {
	            	if (t < arr[j]) {
	            		arr[j + gap] = arr[j];
	            	} else {
	            		break;
	            	}
	            	j -= gap;
	            }
	            arr[j+gap] = t;
	            System.out.println(Arrays.toString(arr));
	        }
	        System.out.println("gap="+gap+":"+Arrays.toString(arr));
		}
	}
	
}

五 快速排序

5.1 单边循环快速排序

  1. 选择最右边元素作为基准点元素。
  2. j 指针负责找到基准点小的元素，一旦找到则与 i 进行交换。
  3. i 指针维护小于基准点元素边界，也是每次交换的目标索引。
  4. 最后基准点与 i 交换，i 即为分区位置。
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {5,9,7,4,1,2,8,3,6};
        quick(arr, 0, arr.length-1);
    }

    public static void quick(int[] arr, int l, int h) {
        if(l >= h) {
            return;
        }
        int pv = partition(arr, l, h);
        quick(arr, l, pv-1); // 左边分区范围确定
        quick(arr, pv+1, h); // 右边分区范围确定
    }

    public static int partition(int[] arr, int l, int h) {
        int pv = arr[h];
        int i = l;
        for(int j=l;j<h;j++) {
            if(arr[j] < pv) {
                if(i != j) {
                    swap(arr, i, j);
                }
                i++;
            }
        }
        if(i != h) {
            swap(arr, h, i);
        }
        System.out.println(Arrays.toString(arr));
        return i;
    }

    public static void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

5.2 双边循环快速排序

  1. 选择最左边元素作为基准点元素。
  2. j 指针负责从右向左找比基准点小的元素，i 指针负责从左向右找比基准点大的元素，一旦找到二者交换，直至 i、j 相交。
  3. 最后基准点与 i（此时 i 与 j 相等）交换，i 即为分区位置。
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {5,9,7,4,1,2,8,3,6};
        quick(arr, 0, arr.length-1);
    }

    public static void quick(int[] arr, int l, int h) {
        if(l >= h) {
            return;
        }
        int pv = partition(arr, l, h);
        quick(arr, l, pv-1); // 左边分区范围确定
        quick(arr, pv+1, h); // 右边分区范围确定
    }

    public static int partition(int[] arr, int l, int h) {
        int pv = arr[l];
        int i = l;
        int j = h;
        while(i < j) {
            // j 从右找小的
            while(i < j && arr[j] > pv) {
                j--;
            }
            // i 从左找大的
            while(i < j && arr[i] <= pv) {
                i++;
            }
            swap(arr, i, j);
        }
        swap(arr, l, j);
        System.out.println(Arrays.toString(arr));
        return j;
    }

    public static void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

六 二分查找

1、前提：有已排序的数组 arr。

2、定义左边界 l，右边界 r，确定搜索范围，循环执行二分查找（3、4步）。

3、获取中间索引 m = Floor((l+r)/2)。

4、中间索引的值 arr[m] 与待搜索的值 t 进行比较。

  • arr[m] == t 表示找到，返回中间索引。
  • arr[m] > t，中间值右侧的其它元素都大于 t，无需比较，中间索引左边去找，m-1 设置为右边界，重新查找。
  • arr[m] < t，中间值左侧的其它元素都大于 t，无需比较，中间索引右边去找，m+1 设置为左边界，重新查找。

5、当 l > r，表示没有找到，结束循环。

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1, 5, 8, 11, 19, 22, 31, 35, 40, 45, 48, 49, 50};
        int t = 48;
        int index = binarySearch(arr, t);
            
        System.out.println(index);
    }

    public static int binarySearch(int[] arr, int t) {
        int l = 0, r = arr.length - 1, m;
        while(l <= r) {
            //m = l+(r-l)/2; // 解决整数溢出
            m = (l+r) >>> 1;
            if(arr[m] == t) {
                return m;
            } else if(arr[m] > t) {
                r = m-1;
            } else {
                l = m+1;
            }
        }

        return -1;
    }
}

6、面试题

  • 奇数二分取中间
  • 偶数二分取中间靠左

1、有一个有序表为[1,5,8,11,19,22,31,35,40,48,49,50]，当二分查找值为48的节点时，需经过几次比较？

2、有一个有序表为[1,4,6,7,15,33,50,64,75,78,81,89,96]，当二分查找值为81的节点时，需经过几次比较？

3、在拥有128个元素的数组中二分查找一个数，需要比较的次数最多不超过几次？

  •     \log_{10}128 / \log_{10}2
  •     整数，则该整数即为最终结果
  •     小数，舍去小数部分，整数+1即为最终结果

七 总结

  • int[] arr = {5,9,7,4,1,2,8,3,6} 
时间复杂度实现优化排序过程
冒泡排序O(n^{2})
  1. 依次比较数组中相邻的两个元素，若 arr[i] > arr[i+1]，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是最大的元素排在最后。
  2. 重复以上操作，直至整个数组有序。
  • 每轮冒泡时，最后一次交换索引可以作为下一轮冒泡的比较次数，如果这个值为0，表示整个数组有序，直接退出外层循环。
[5, 7, 4, 1, 2, 8, 3, 6, 9]
[5, 4, 1, 2, 7, 3, 6, 8, 9]
[4, 1, 2, 5, 3, 6, 7, 8, 9]
[1, 2, 4, 3, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
选择排序O(n^{2})
  1. 将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集。
  2. 重复以上操作，直至整个数组有序。
  • 每轮可以先找到最小的索引，在每轮最后在交换元素。
[1, 9, 7, 4, 5, 2, 8, 3, 6]
[1, 2, 7, 4, 5, 9, 8, 3, 6]
[1, 2, 3, 4, 5, 9, 8, 7, 6]
[1, 2, 3, 4, 5, 9, 8, 7, 6]
[1, 2, 3, 4, 5, 9, 8, 7, 6]
[1, 2, 3, 4, 5, 6, 8, 7, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
插入排序

O(n^{2})
  1. 将数组分为两个区域，排序区和未排序区，每一轮从未排序区域选取第一个元素，插入到排序区域（需要保证顺序）。
  2. 重复以上操作，直至整个数组有序。
  • 待插入元素进行比较时，遇到比自己小的元素，就代表找到了插入位置，无需进行后续比较。
  • 插入时可以直接移动元素，而不是交换元素。
[3, 5, 1, 7, 2, 9, 8, 4, 6]
[1, 3, 5, 7, 2, 9, 8, 4, 6]
[1, 3, 5, 7, 2, 9, 8, 4, 6]
[1, 2, 3, 5, 7, 9, 8, 4, 6]
[1, 2, 3, 5, 7, 9, 8, 4, 6]
[1, 2, 3, 5, 7, 8, 9, 4, 6]
[1, 2, 3, 4, 5, 7, 8, 9, 6]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
希尔排序
  1. 设置间隙序列
  2. 将间隙相同元素划为一组，对每组使用插入排序。
  3. 重复以上操作，直至数组有序。
[1, 9, 7, 4, 5, 2, 8, 3, 6]
[1, 2, 7, 4, 5, 9, 8, 3, 6]
[1, 2, 7, 4, 5, 9, 8, 3, 6]
[1, 2, 7, 3, 5, 9, 8, 4, 6]
[1, 2, 7, 3, 5, 9, 8, 4, 6]
gap=4:[1, 2, 7, 3, 5, 9, 8, 4, 6]
[1, 2, 7, 3, 5, 9, 8, 4, 6]
[1, 2, 7, 3, 5, 9, 8, 4, 6]
[1, 2, 5, 3, 7, 9, 8, 4, 6]
[1, 2, 5, 3, 7, 9, 8, 4, 6]
[1, 2, 5, 3, 7, 9, 8, 4, 6]
[1, 2, 5, 3, 7, 4, 8, 9, 6]
[1, 2, 5, 3, 6, 4, 7, 9, 8]
gap=2:[1, 2, 5, 3, 6, 4, 7, 9, 8]
[1, 2, 5, 3, 6, 4, 7, 9, 8]
[1, 2, 5, 3, 6, 4, 7, 9, 8]
[1, 2, 3, 5, 6, 4, 7, 9, 8]
[1, 2, 3, 5, 6, 4, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
gap=1:[1, 2, 3, 4, 5, 6, 7, 8, 9]
 
快速排序-单边循环

O(n^{2})
  1. 选择最右边元素作为基准点元素。
  2. j 指针负责找到基准点小的元素，一旦找到则与 i 进行交换。
  3. i 指针维护小于基准点元素边界，也是每次交换的目标索引。
  4. 最后基准点与 i 交换，i 即为分区位置。
[5, 4, 1, 2, 3, 6, 8, 7, 9]
[1, 2, 3, 4, 5, 6, 8, 7, 9]
[1, 2, 3, 4, 5, 6, 8, 7, 9]
[1, 2, 3, 4, 5, 6, 8, 7, 9]
[1, 2, 3, 4, 5, 6, 8, 7, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
快速排序-双边循环

平均：O(n\log_{2}n)

最坏：O(n^{2})
  1. 选择最左边元素作为基准点元素。
  2. j 指针负责从右向左找比基准点小的元素，i 指针负责从左向右找比基准点大的元素，一旦找到二者交换，直至 i、j 相交。
  3. 最后基准点与 i（此时 i 与 j 相等）交换，i 即为分区位置。
[1, 3, 2, 4, 5, 7, 8, 9, 6]
[1, 3, 2, 4, 5, 7, 8, 9, 6]
[1, 2, 3, 4, 5, 7, 8, 9, 6]
[1, 2, 3, 4, 5, 6, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

ww_kobe
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
常见几种java排序算法
zzzgd_666的博客
02-18 10万+
1.插入排序 public class InsertSort { public static void sort(int[] arr) { if (arr.length &amp;amp;amp;gt;= 2) { for (int i = 1; i &amp;amp;amp;lt; arr.length; i++) { //挖出一个要用来插入的值,同时位置上留下...
java排序算法精讲
杨思默
05-08 1万+
java实现排序算法
java 排序api_JAVA排序算法API
weixin_29816689的博客
02-12 647
上一个类 下一个类框架 无框架摘要：嵌套|字段|构造函数|方法详细信息：字段|构造函数|方法org.luosijin.test类 Sortjava.lang.Objectorg.luosijin.test.Sortpublic class Sortextends java.lang.ObjectJava实现几种常见排序方法:冒泡排序、快速排序、选择排序、插入排序、...
Java排序算法——选择排序
LeeCM0715的博客
08-09 903
Java排序算法——选择排序（Selection sort） 传送门 冒泡排序 插入排序 简述 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 算法描述（设有n个元素） 从第一个元素开始，比较所有未排序的元素，并标记最小（大）元素，将最小（大）元素与未排序的第一个元素进行交换。 第一轮排序时
Java排序算法
sinat_56381539的博客
03-24 8014
Java排序算法一 文章目录Java排序算法一前言一、冒泡排序二、选择排序三、插入排序四、快速排序 前言 Java小白分享学习算法 一、冒泡排序 冒泡排序（Bubble Sort)就是把小的元素往前调或者把大的元素往后调从而实现从小到大的排序。 依次比较相邻的两个元素大小,若前一个元素大于后一个元素，则交换两个元素，每次比较一轮将最大的一个元素归位（即放到最后）。 import java.util.Arrays; /*冒泡排序*/ public class example1 { public
详解Java常用排序算法（10种，含演示动画）
热门推荐
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-30 1万+
Java常用的排序算法有以下几种： 1. 冒泡排序；2. 选择排序；3. 插入排序；4. 希尔排序；5. 归并排序；6. 快速排序；7. 堆排序；8. 计数排序；9. 桶排序；10. 基数排序。 这些排序算法都有各自的优缺点，应根据具体情况选择适合的算法。
十大经典排序算法——java语言
weixin_56781779的博客
11-11 5606
一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、归并排序 六、快速排序 七、堆排序 八、计数排序 九、桶排序 十、基数排序
Java排序算法——选择排序（Selection Sort）
babbfqb93的博客
02-21 4465
上次总结了一下冒泡排序，这次来看看同样非常简单的选择排序 上期冒泡排序传送门： Java排序算法——冒泡排序（Bubble Sort）https://blog.csdn.net/babbfqb93/article/details/123005968?spm=1001.2014.3001.5501 选择排序（Selection Sort）就是通过选择一个数组中的最大（小）值排序到数组的头部位置（和头部位置交换）接下来循环剩余数组找到次最大（小）值排序到第二的位置，以此类推，直到所有的数字都被选择完成之后
JAVA排序:快速排序算法
Just For Learning
07-28 1161
快速排序算法体现了—分治思想将大问题划分为多个相同独立的小问题，每个小问题的解决合在一起解决了大问题。left和right指针相遇就是中心轴pivo的新位置。快排到此结束第一轮，可以发现中心轴值最后移动到结果数组位置。{2,4,1,0,3,5}是目标数组。{0,1,2,3,4,5}是结果数组。确定left和right指针。递归左右两边，完成排序。...
java 排序算法
01-11
代码中列举了java常见的排序算法，并备有简单的注释信息，对于初级开发人员可供参考。
Java排序算法总结之堆排序
09-03
主要介绍了Java排序算法总结之堆排序,详细分析了堆排序的原理与java实现技巧,需要的朋友可以参考下
Java排序算法实现：冒泡与选择排序示例代码
01-04
Java排序算法实现资源 这个资源是关于Java中排序算法实现的简单示例。排序算法是计算机科学中的基础概念，用于按升序或降序排列数据集。这里提供了两种常见的排序算法实现：冒泡排序和选择排序。 冒泡排序（Bubble ...
Java排序算法汇总大全.doc
09-21
想要获得高薪offer？内卷太严重？担心被裁员？总是忙于业务开发？只会CRUD？ 您需要充充电了大哥！只要自己足够强大，内功足够扎实，就不用担心这些...Java排序算法是基础中的基础，这都不会还能做好开发？赶紧上车！
JAVA排序算法收集处
04-22
这里包含了使用java语言的几大排序算法包括：插入排序、冒泡排序、归并排序、基数排序、希尔排序、快速排序、基数排序、选择排序。 jdk版本1.8 打开方式：解压后打开eclipse直接导入项目即可查看和运行代码。方便...
Java排序算法总结之归并排序
09-03
主要介绍了Java排序算法总结之归并排序,较为详细的分析了归并排序的原理与java实现技巧,需要的朋友可以参考下
Java 排序算法知识点总结.zip
最新发布
01-14
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势...
java 排序算法
08-27
Java中常用的排序算法有很多种，以下是一些常见的排序算法： 1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果顺序错误就交换位置，重复这个过程直到所有元素都排好序。时间复杂度为O(n^2)。 2. 选择排序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值