排序
排序算法 有多种，常用的排序算法有冒泡排序、插入排序、选择排序、快速排序、堆排序、归并排序、希尔排序、二叉树排序、计数排序等。
选择排序
表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
-
初始状态：无序区为R[1…n]，有序区为空；
-
第 i 趟 排 序 (i=1,2,3…n-1) 开 始 时 ， 当 前 有 序 区 和 无 序 区 分 别 为 R[1…i-1] 和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
-
n-1趟结束，数组有序化了。
代码演示：
public static void main(String[] args) {
//定义初始化数组
int[] arr = {23, 55, 21, 10, 54, 62, 44, 32, 5, 12};
//外层遍历数组，记录数组总共比较多少次
for (int i = 0; i < arr.length-1; i++) {
//定义一个变量用来记录最小值的下标
int index = i;
//内层数组，用来比较每次循环的次数
for (int j = index + 1; j < arr.length; j++) {
if (arr[index] > arr[j]) {//(寻找最小值)
index = j;//(保存最小值的索引)
}
}
//比较结束，交换两个数的位置
int count = arr[i];
arr[i] = arr[index];
arr[index] = count;
}
for (int a :
arr) {
System.out.println(a);
}
}
插入排序
插入排序的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
算法描述：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
代码演示：
public static void main(String[] args) {
int[] arr = {23, 55, 21, 10, 54, 62, 44, 32, 5, 12};
for (int i = 1; i < arr.length; i++) {
int count = arr[i];
int index = i-1;
for (; index >= 0 && count < arr[index]; index--) {
arr[index + 1] = arr[index];
}
arr[index + 1] = count;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
冒泡排序
它重复地走访过要排序的数组，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数组的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
代码演示：
public static void main(String[] args) {
int[] arr = {23,55,21,10,54,62,44,32,5,12};
for (int i = 0; i < arr.length-1; i++) {//外层循环，控制比较多少轮
for (int j = 0; j < arr.length-1-i; j++) {//内层循环，控制每轮循环多少轮
if (arr[j] > arr[j+1]){//比较大小
int temp = arr[j];//交换位置
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
for (int a:
arr) {
System.out.println(a);
}
}
快速排序
1.如图所示，这是一个数组，我们首先以2为基准，开始遍历数组。
2.此时j找到比2小的数字-9，就停下来了，i开始找比2大的数字7，停下来后，-9和7交换位置。如图：
3.接下来，j–，继续往左找，找到-1停下来，此时，i++，开始往右找，找到9，停下来，交换位置。如图：
4.此时，j–左移到达0的位置且正好小于2，i++和j碰头，此时这个位置的数字和基准数字比较大小，交换位置。如图：
最后，把数组分成左右两部分，左右两部分，这两部分形成了两个数组，和以上步骤一样。重复1，2，3，4步骤，最后就能完成快速排序。
public static void main(String[] args) {
// 快速排序
int[] nums = {2, 7, 9, 0, -1, 2, -9};
quickSort(nums, 0, nums.length - 1);
System.out.println(Arrays.toString(nums));
}
public static void quickSort(int[] arr, int left, int right) {
if (left > right) {
return;//结束条件
}
int jiZhun = arr[left];
int i = left;
int j = right;
while (i != j) {
// 找到比基准值小的下标
while (j > i && arr[j] >= jiZhun) {
j--;
}
// 找到比基准值大的下标
while (j > i && arr[i] <= jiZhun) {
i++;
}
if (i < j) {
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
}
}
//i和j相遇，互换基准和当前数的位置
if (arr[i] < jiZhun) {
arr[left] = arr[i];
arr[i] = jiZhun;
}
// 数组以 i 下标分成左边 和右边两部分 i 左边 小于 基准值 i 右边比基准值大
// 排序左边
quickSort(arr, left, i - 1);
quickSort(arr, i + 1, right);
}
二分查找
**注：**利用二分查找时，首先要给数组排序。
二分查找（Binary Search）算法，也叫折半查找算法。二分查找的思想非常简单，有点类似分治的思想。二分查找针对的是一个有序的数据集合，每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0。
代码演示：
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
int key = 13;
int start = 0;
int max = arr.length - 1;
int mid = (start + max) / 2;
while (start < max) {
if (key == arr[mid]) {
System.out.println(mid);
break;
} else if (arr[mid] > key) {
max = mid - 1;
} else {
start = mid + 1;
}
mid = (start + max) / 2;
}
if (start > max) {
System.out.println(-1);
}
}
随机排名
需求：某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。
随机排名的思路
1.在程序中录入5名员工的工号存储起来 ---> 使用动态初始化数组的方式。
2.依次遍历数组中的每个数据。
3.每遍历到一个数据，都随机一个索引值出来，让当前数据与该索引位置处的数据进行交换。
代码如下
public class Test3 {
public static void main(String[] args) {
// 目标：完成随机排名
// 1、定义一个动态初始化的数组用于存储5名员工的工号
int[] codes = new int[5];
// 2、提示用户录入5名员工的工号。
Scanner sc = new Scanner(System.in);
for (int i = 0; i < codes.length; i++) {
// i = 0 1 2 3 4
System.out.println("请您输入第" + (i + 1) +"个员工的工号：");
int code = sc.nextInt();
codes[i] = code;
}
// 3、打乱数组中的元素顺序。
// [12, 33, 54, 26, 8]
// i index
Random r = new Random();
for (int i = 0; i < codes.length; i++) {
// codes[i]
// 每遍历到一个数据，都随机一个数组索引范围内的值。
//然后让当前遍历的数据与该索引位置处的值交换。
int index = r.nextInt(codes.length); // 0 - 4
// 定义一个临时变量记住index位置处的值
int temp = codes[index];
// 把i位置处的值赋值给index位置处
codes[index] = codes[i];
// 把index位置原来的值赋值给i位置处
codes[i] = temp;
}
// 4、遍历数组中的工号输出即可
for (int i = 0; i < codes.length; i++) {
System.out.print(codes[i] + " ");
}
}
}
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
