排序算法

1.异或

异或运算的性质与扩展 用来处理奇偶数方便

1）0^N == N N^N == 0 也就是说奇数次异或为最后剩下的那个数，偶数次异或为0 2）异或运算满足交换律和结合率 3）不用额外变量交换两个数 ：

a=a^b b=a^b a=a^b； 这样就完成了两个数的交换

一个数组中有一种数出现了奇数次，其他数都出现了偶数次，怎么找到这一个数？

定义一个变量，由于偶数次异或为0，则异或数组中每个变量，剩下的那个就是奇数

一个数组中有两种数出现了奇数次，其他数都出现了偶数次，怎么找到这两个数 ？

跟上面一样，先遍历一遍数组，然后那个变量就是temp=a^b。由于是两种数

public class 异或 {
   
    public static void main(String[] args) {
   
        int[] array={
   1,1,1,2,2,2,2,1,2,1,2,3,3,1,1,4,4,4,};
        int num=array[0];
        for (int i = 1; i < array.length; i++)
            num=num ^ array[i] ;
        //遍历完成的到 num=1^ 4

        //由于这两个数不一样 则肯定异或不为0，则num!=0 ,所以num有一位肯定为1
        //提取最右边的1
        int right= (~num +1) &num;
        int num1=0;
        for (int data : array) 
            //然后把数据相当于分成了2组 一个位置有1，一个位置没有1
            if((data & right) == 1)//只要那个位置为1的
               num1^=data;
        System.out.println("两个数为："+num1+" "+(num1^num));
    }
}

2.二分法（解决局部最小值问题）

使用二分法可以找到局部最小值问题 ，初始判断第1个和第2个数，如果第1个数小，则直接返回第一个数，否则再判断最后两个数，如果最后一个数较小，则直接判断最后一个数。否则中间绝对会有一个最低谷，如下图：

3.冒泡排序

思想：每一趟就是 两两比较大小 然后交换数据， 每经历1轮，最大的数就放在最后了，比较的个数少1个

时间复杂度O(N^2)，空间复杂度O(1)

		int[] array={
   6,3,8,2,9,1}, temp=0;
        for (int i = 0; i < array.length-1; i++) {
   
            //每一趟就是 两两比较大小 然后交换 每经历1轮，比较的个数少1个,所以结尾减i
            for (int j = 0; j <array.length-1-i ; j++) {
   
                if(array[j] > array[j+1]){
   
                    //抖机灵写法 异或 ^  通过异或来交换两个数的值
                    array[j]= array[j] ^ array[j+1];
                    array[j+1]=array[j] ^ array[j+1];
                    array[j]=array[j] ^ array[j+1];
//                    temp = array[j+1];
//                    array[j+1]=array[j];
//                    array[j]=temp;
                }
            }
    }
}

4.选择排序

思想：用后面的数和每一轮的第一个数相比较，用简单的话来说，就是从第一个数开始，与后面所有的数相比较，找出最小的数，放在第一个位置，以此类推，每一轮确定一个相对于这一轮最小的数。

时间复杂度O(N^2)，空间复杂度O(1)

	 //从小到大进行排序
    public  static int[] sort1(int[] array){
   
        int temp=0;
        for (int i = 0; i < array.length-1; i++) {
   
            for (int j = i+1; j <array.length ; j++) {
   
                if(array[i] >array[j]){
   
                    temp=array[i];
                    array[i]=array[j];
                    array[j]=temp;
                }
            }
        }
        return array;
    }
}

5.插入排序

思想：把所有的元素分为两组，已经排序的和未排序的，找到未排序的组中的第一个元素，向已经排序的组中进行插入，插入的时候倒叙遍历已经排序的元素，依次和待插入的元素进行比较，比较的时候进行交换位置，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置。

时间复杂度O(N^2)，额外空间复杂度O(1) 。该算法极其不稳定，最坏就是5，4，3，2，1，喊你从小到大排序，最好就是1，2，3，4，5直接遍历一遍O(N)就行，所以及其不稳定。

	int[] array={
   5,4,6,4564,4,6}，temp= 0;
        //从小到大进行排序
        for (int i = 1; i < array.length; i++) {
   
            for (int j = i; j >0 ; j--) {
   
                if(array[j-1] >array