其他分享
首页 > 其他分享> > 简单,冒泡,插入排序基本思想以及位运算和对数器的运用

简单,冒泡,插入排序基本思想以及位运算和对数器的运用

作者:互联网

1. 简单排序

//选择排序
 public static void SelectedSort(int arr[]){
   for (int i = 0; i < arr.length; i++) {
            int midIndex = i;
         for (int j = i+1; j < arr.length; j++) { //这个for每次得到最小值的下标
       midIndex = arr[midIndex]>arr[j] ? j : midIndex;
            }
            if(i!=midIndex)
            swap(arr,i,midIndex);
        }
       Show(arr);
    }

2. 冒泡排序

//冒泡排序
    public static void BubbleSort(int arr[]){
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j+1]<arr[j]){ //两两比较
                    swap(arr,j,j+1);
                }
            }
        }
        Show(arr);
    }

3. 插入排序

//插入排序
  public static void InsertSort(int arr[]){
    for (int i = 1; i < arr.length; i++) {
      for (int j = i-1; j >=0&&arr[j+1]<arr[j]; j--) { //与有序表从右至左依次比较
                    swap(arr,j,j+1);
            }
        }
        Show(arr);
    }

4. 关于位运算
首先说说上述排序中的swap函数
一般写法是:

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

借助位运算:

//注意使用位运算时,应避免i和j相等,不然最后异或结果都为0,达不到交换的目的
public static void swap(int arr[],int i,int j){
        arr[i] = arr[i]^arr[j]; (1)
        arr[j] = arr[i]^arr[j]; (2)
        arr[i] = arr[i]^arr[j]; (3)
    }

通常位运算是比数字运算快很多的。所以能采取位运算尽量采取位运算。
位运算原理:
位运算有一个性质为两个位异或,相同为0相异为1,还有一个性质是自己和自己异或为0和任何数与0异或等于本身,且满足交换律和结合律。
这里简单说明一下上述swap原理
假设arr[i]=a,arr[j]=b.由(1)得:arr[i]=a ^ b,arr[j]=b;
由(2)得:arr[i]=a ^ b, arr[j]=a ^ b ^b=a ^ 0=a
由(3)得:arr[i]=a ^ b ^ a = b ^ 0 = b,a[j]=a
这样就达到了交换的目的。

5.位运算扩展(位运算能解决的问题)

1.有这样一组数,相邻两个数不等,其中某个数出现了奇数次,其他数均出现了偶数次,求这个奇数是什么?
方案:通过位运算,声明一个变量x=0,让x与这组数从头异或到尾,那么最终异或结果就是这个奇数。
原理:因为异或具有结合律和交换律,所以这组数中的偶数次数相互结合异或得0,而x也是0,最后就会单一个奇数出来(奇数个拿出来偶数个),即为所求。
2.再有这样一组数,相邻两个数不等,其中某两个数出现了奇数次,其他数出现了偶数次,求出现奇数次的两个数是什么?
方案:还是先声明一个变量x=0,同样与这组数进行异或,那么最后就会得到x=a ^ b,由于a肯定不等于b(两个数),所以x=a^b 肯定不为0,那么a和b异或肯定有一位不为0,也即a和b的那一位是相异的,a为1,b就为0,反之亦然。假设a和b第6位不相同,那这组数也可以分为两类,一类是与a一样,一类是与b一样。再声明一个变量y=0,将y与这组数中的其中一类进行异或,那么会单出来a或者b(那些偶数次的数还是没有影响),即y=a or y=b,最后将y与x异或就得到a或者b,如果x ^ y=a,那么y=b,反之亦然,x ^ y和y即为所求的两个奇数。
代码实现:

  public static void bit(int arr[]){
     int x = 0;
     for(int e:arr){
       x ^= e;
     }
     int rightOne = x & (~x+1);//取出最右边的1
     int y = 0;
     for(int e: arr){
       if(rightOne & e == 1) //将y与某一类进行异或,这里等于1或者0均可
         {
           y ^= e;
         }
    }
   System.out.println("第一个奇数:"+y,"第二个奇数:"+y ^ x)
  }

6. 对数器

对数器实际上是自测自己写的算法的一个正确与否的一个好方法,可以不依赖于oj。以上述三个手写的排序函数为例,来对三个排序函数进行测试。

public static void logForTest(){   //测试方法
        int times = 10000;//测试一万组
        boolean f = false;
        for (int i = 0; i < times; i++) {
            int arr[] = returnRandomArr();
            int arr1[] = Arrays.copyOf(arr,arr.length);
            int arr2[] = Arrays.copyOf(arr,arr.length);
            SelectedSort(arr);//选择排序
            BubbleSort(arr1);//冒泡排序
            InsertSort(arr2);//插入排序
			Arrays.sort(arr3);//系统方法用于对照
            Show(arr3);
            for (int j = 0; j < arr.length; j++) {
                if(arr[i]!=arr1[i] || arr[i]!=arr2[i] || arr1[i]!=arr2[i]||
                        arr[i]!=arr3[i]||arr1[i]!=arr3[i]||arr2[i]!=arr3[i]){
                    f = true;
                    break;
                }
            }
            if(f) System.out.println("失败");
            else System.out.println("成功");
        }
    }
 public static  int[] returnRandomArr(){//随机生成测试用例

        Random random = new Random();
        int maxValue = random.nextInt(100);

        int arr[] = new int[random.nextInt(100)];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(maxValue+1)-random.nextInt(maxValue);
        }
        Show(arr);
        return arr;
    }

三个排序算法测试结果:

初始数组:17 4 -60 -42 14 30 58 52 52 34 -6 4 55 34 0 21 -30 21 -18 -26 -13 26 20 70 8 -2 -5 -24 -19 -39 -45 -16 37 71 -7 -29 -13 49 -21 -27 -66 61 -29 -48 35 -34 37 -20 18 -51 62 31 
选择排序:-66 -60 -51 -48 -45 -42 -39 -34 -30 -29 -29 -27 -26 -24 -21 -20 -19 -18 -16 -13 -13 -7 -6 -5 -2 0 4 4 8 14 17 18 20 21 21 26 30 31 34 34 35 37 37 49 52 52 55 58 61 62 70 71 
冒泡排序:-66 -60 -51 -48 -45 -42 -39 -34 -30 -29 -29 -27 -26 -24 -21 -20 -19 -18 -16 -13 -13 -7 -6 -5 -2 0 4 4 8 14 17 18 20 21 21 26 30 31 34 34 35 37 37 49 52 52 55 58 61 62 70 71 
插入排序:-66 -60 -51 -48 -45 -42 -39 -34 -30 -29 -29 -27 -26 -24 -21 -20 -19 -18 -16 -13 -13 -7 -6 -5 -2 0 4 4 8 14 17 18 20 21 21 26 30 31 34 34 35 37 37 49 52 52 55 58 61 62 70 71 
系统方法:-66 -60 -51 -48 -45 -42 -39 -34 -30 -29 -29 -27 -26 -24 -21 -20 -19 -18 -16 -13 -13 -7 -6 -5 -2 0 4 4 8 14 17 18 20 21 21 26 30 31 34 34 35 37 37 49 52 52 55 58 61 62 70 71 
result:成功
-2 44 -46 9 16 -65 29 -57 -3 -27 41 -74 -44 
-74 -65 -57 -46 -44 -27 -3 -2 9 16 29 41 44 
-74 -65 -57 -46 -44 -27 -3 -2 9 16 29 41 44 
-74 -65 -57 -46 -44 -27 -3 -2 9 16 29 41 44 
-74 -65 -57 -46 -44 -27 -3 -2 9 16 29 41 44 
成功
-25 -15 20 -2 -15 -28 8 8 20 7 2 -4 12 -9 15 -8 13 14 -23 -17 -19 3 -25 -42 4 -13 22 22 4 -11 -32 -3 24 19 14 8 -26 25 2 13 -35 -3 2 30 -6 1 -10 8 -11 23 -22 -8 17 6 -20 12 2 -11 -12 -7 -3 12 34 20 -4 8 14 
-42 -35 -32 -28 -26 -25 -25 -23 -22 -20 -19 -17 -15 -15 -13 -12 -11 -11 -11 -10 -9 -8 -8 -7 -6 -4 -4 -3 -3 -3 -2 1 2 2 2 2 3 4 4 6 7 8 8 8 8 8 12 12 12 13 13 14 14 14 15 17 19 20 20 20 22 22 23 24 25 30 34 
-42 -35 -32 -28 -26 -25 -25 -23 -22 -20 -19 -17 -15 -15 -13 -12 -11 -11 -11 -10 -9 -8 -8 -7 -6 -4 -4 -3 -3 -3 -2 1 2 2 2 2 3 4 4 6 7 8 8 8 8 8 12 12 12 13 13 14 14 14 15 17 19 20 20 20 22 22 23 24 25 30 34 
-42 -35 -32 -28 -26 -25 -25 -23 -22 -20 -19 -17 -15 -15 -13 -12 -11 -11 -11 -10 -9 -8 -8 -7 -6 -4 -4 -3 -3 -3 -2 1 2 2 2 2 3 4 4 6 7 8 8 8 8 8 12 12 12 13 13 14 14 14 15 17 19 20 20 20 22 22 23 24 25 30 34 
-42 -35 -32 -28 -26 -25 -25 -23 -22 -20 -19 -17 -15 -15 -13 -12 -11 -11 -11 -10 -9 -8 -8 -7 -6 -4 -4 -3 -3 -3 -2 1 2 2 2 2 3 4 4 6 7 8 8 8 8 8 12 12 12 13 13 14 14 14 15 17 19 20 20 20 22 22 23 24 25 30 34 
成功
-2 -8 5 -12 -10 -6 -3 0 4 9 -5 2 2 3 9 -6 -8 -1 -5 0 11 6 -15 6 -9 -9 10 -7 5 6 9 2 -4 2 0 11 6 10 -2 4 -13 9 -11 -2 2 -4 6 1 0 5 3 0 -6 4 0 -11 
-15 -13 -12 -11 -11 -10 -9 -9 -8 -8 -7 -6 -6 -6 -5 -5 -4 -4 -3 -2 -2 -2 -1 0 0 0 0 0 0 1 2 2 2 2 2 3 3 4 4 4 5 5 5 6 6 6 6 6 9 9 9 9 10 10 11 11 
-15 -13 -12 -11 -11 -10 -9 -9 -8 -8 -7 -6 -6 -6 -5 -5 -4 -4 -3 -2 -2 -2 -1 0 0 0 0 0 0 1 2 2 2 2 2 3 3 4 4 4 5 5 5 6 6 6 6 6 9 9 9 9 10 10 11 11 
-15 -13 -12 -11 -11 -10 -9 -9 -8 -8 -7 -6 -6 -6 -5 -5 -4 -4 -3 -2 -2 -2 -1 0 0 0 0 0 0 1 2 2 2 2 2 3 3 4 4 4 5 5 5 6 6 6 6 6 9 9 9 9 10 10 11 11 
-15 -13 -12 -11 -11 -10 -9 -9 -8 -8 -7 -6 -6 -6 -5 -5 -4 -4 -3 -2 -2 -2 -1 0 0 0 0 0 0 1 2 2 2 2 2 3 3 4 4 4 5 5 5 6 6 6 6 6 9 9 9 9 10 10 11 11 
成功
3 3 6 1 4 3 2 4 1 -5 0 5 2 -8 1 -3 4 6 5 -2 -3 -4 1 -3 2 -3 3 -3 -5 2 0 6 2 -6 -3 8 2 6 -3 7 0 -3 3 0 4 -3 7 -3 -3 0 -5 1 2 1 6 2 -6 -2 5 -7 -1 0 -8 3 4 -3 2 
-8 -8 -7 -6 -6 -5 -5 -5 -4 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -2 -2 -1 0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 5 5 5 6 6 6 6 6 7 7 8 
-8 -8 -7 -6 -6 -5 -5 -5 -4 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -2 -2 -1 0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 5 5 5 6 6 6 6 6 7 7 8 
-8 -8 -7 -6 -6 -5 -5 -5 -4 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -2 -2 -1 0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 5 5 5 6 6 6 6 6 7 7 8 
-8 -8 -7 -6 -6 -5 -5 -5 -4 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3 -2 -2 -1 0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 5 5 5 6 6 6 6 6 7 7 8 
成功
-66 7 -6 16 -45 -38 -20 52 -32 16 -1 -26 -17 59 -18 70 -21 -33 -29 7 -19 -5 -22 -10 -46 17 9 -55 -22 -15 25 -41 17 14 -23 -49 -55 3 25 -16 34 -2 
-66 -55 -55 -49 -46 -45 -41 -38 -33 -32 -29 -26 -23 -22 -22 -21 -20 -19 -18 -17 -16 -15 -10 -6 -5 -2 -1 3 7 7 9 14 16 16 17 17 25 25 34 52 59 70 
-66 -55 -55 -49 -46 -45 -41 -38 -33 -32 -29 -26 -23 -22 -22 -21 -20 -19 -18 -17 -16 -15 -10 -6 -5 -2 -1 3 7 7 9 14 16 16 17 17 25 25 34 52 59 70 
-66 -55 -55 -49 -46 -45 -41 -38 -33 -32 -29 -26 -23 -22 -22 -21 -20 -19 -18 -17 -16 -15 -10 -6 -5 -2 -1 3 7 7 9 14 16 16 17 17 25 25 34 52 59 70 
-66 -55 -55 -49 -46 -45 -41 -38 -33 -32 -29 -26 -23 -22 -22 -21 -20 -19 -18 -17 -16 -15 -10 -6 -5 -2 -1 3 7 7 9 14 16 16 17 17 25 25 34 52 59 70 
成功
···

标签:11,arr,20,17,int,插入排序,13,冒泡,对数
来源: https://blog.csdn.net/godaa/article/details/122848591