JAVA排序

一、前言：

1、稳定性的定义

能保证两个相等的数，经过排序之后，其在序列的前后位置顺序不变。（A1=A2，排序前A1在A2前面，排序后A1还在A2前面）

2、排序算法不稳定的含义

在排序之前，有两个数相等，但是在排序结束之后，它们两个有可能改变顺序，这就是说明该排序算法具有不稳定性。

3、分类

① 稳定性排序：冒泡排序，插入排序、归并排序、基数排序

② 不稳定性排序：选择排序、快速排序、希尔排序、堆排序

4、排序算法可以分为内部排序和外部排序。

定义：内部排序是数据记录在内存中进行排序。

1、外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
2、常见的内部排序算法有：冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序等。

5、排序速度

1、速度: 快速排序>>归并排序>>>>>插入排序>>选择排序>>冒泡排序
并且可以看到,选择排序,冒泡排序在数据量越来越大的情况下,耗时已经呈指数型上涨,而不是倍数上涨,在50w的时候已经需要足足5分钟以上

6、冒泡排序

a、冒泡排序，是通过每一次遍历获取最大值

b、将最大值/最小值放在尾部

c、然后除开最大值，剩下的数据在进行遍历获取最大值

d、代码实现

public static void main(String[] args) {
        int arr[] = {8, 5, 3, 2, 4};

        //冒泡
        for (int i = 0; i < arr.length; i++) {
            //外层循环，遍历次数
            for (int j = 0; j < arr.length - i - 1; j++) {
                //内循环，下方取值 j+1，防止越界，所以arr.length-1
                //内循环，每次去掉最后最大的值，所以arr.length-1-i
                //内层循环，升序（如果前一个值比后一个值大，则交换）
                //内层循环一次，获取一个最大值
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }


//kotlin用法
  var arrayList = arrayListOf<Int>(88,12,6,99,100,52,2,0,66)
        var temp =0
        for(index in 0 .. arrayList.size){
            for (x in 0 .. arrayList.size-1-index ){
                  if (arrayList[x+1]<arrayList[x]){
                      temp = arrayList[x]
                      arrayList[x] = arrayList[x+1]
                      arrayList[x+1] = temp
                  }
            }
        }
        arrayList.forEach { Log.d("LUO","$it ") }

7、选择排序

a、将第一个值看成最小值

b、然后和后续的比较找出最小值和下标

c、交换本次遍历的起始值和最小值

d、说明：每次遍历的时候，将前面找出的最小值，看成一个有序的列表，后面的看成无序的列表，然后每次遍历无序列表找出最小值。

e、代码实现

public static void main(String[] args) {

        int arr[] = {6, 5, 3, 2, 4};
        //最后一个元素不用参与自己交换位置了，所以-1
        for (int i = 0; i < arr.length-1; i++) {
           //记录最小的下标
            int index = i;
            //通过与后面的数据进行比较得出，最小值和下标
            for (int j = i+1 ; j < arr.length; j++) {
                if (min > arr[j]) {
                    index = j;
                }
            }
            //然后将最小值与本次循环的i 的位置，开始值交换
            //不相等才去交换位置,避免自己和自己交换
            if（i !=index）{
                int temp = arr[index];
                arr[index] = array[i];
                arr[i] = temp;
            }
         
            //说明：将i前面的数据看成一个排好的队列，i后面的看成一个无序队列。每次只需要找出最小值，做替换
        }
    }

8、快速排序

9、二分查找

public class BinarySearch {

	public static void main(String[] args) {
		int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };// 源数据
		int key = 23;
		int ret = biSearch(arr, key);
		System.out.println(ret);
	}

	public static int biSearch(int arr[], int a) {
		int start = 0;
		int end = arr.length - 1;

		int mid;
		while (start <= end) {
			mid = (start + end) / 2;

			if (arr[mid] < a) {
				start = mid + 1;
			} else if (arr[mid] > a) {
				end = mid - 1;
			} else {
				return mid;
			}
		}
		return -1;//找不到
	}
}

---

链接：https://www.cnblogs.com/ll409546297/p/10956960.html