数据结构-排序

说明：观看B站视频记录笔记（马士兵说）

数据结构绪论

什么是数据结构

1. Data Structure
2. 存储数据的不同方式（顺序表、链表）

什么是算法

1. 同一问题的不同解决方法
2. 算法往往是针对特定的数据结构（数组和链表的插入方法）

如何测算算法的优劣

1. 时间测算
   java中记录算法开始的时间before=System.currentTimeMillis()，算法结束时记录一个时间，然后相减，一次算法可能不好比较，用循环来凑。比如循环10000次。
   1. 计算算法时间差
   2. 幅度不够循环来凑
2. 空间测算
   用到的额外空间

Big O

1. 时间 -问题（数据）规模
   1. 不考虑必须要做的操作
      循环、赋初值、程序初始化…
   2. 不考虑常数项
   3. 不考虑低次项
      
      作业：
      
      回答：O(1)、O(N)、O(N)、O(N)

排序

常见排序：

插排、堆排、快排、归并四种必须记
选泡插， 快归堆希统计基， 恩方恩老恩一三， 对恩加K恩乘K， 不稳稳稳不稳稳， 不稳不稳稳稳稳！

选择排序

最简单但是最没用的排序算法，也有优化空间
如何计算时间和空间复杂度
算法的验证-随机谁生成器、对数器
写算法程序的哲学

package mashibing_class.sorts;

public class SeletcionSort {

    /*
     * 如何写程序：
     * 1、由简单到复杂
     *   1. 验证一步走一步
     *   2. 多打印中间结果
     * 2、先局部后整体
     *   没思路时先细分
     * 3、先粗糙后精细
     *   1. 变量更名
     *   2.语句合并
     *   3.边界处理
     * */

    public static void main(String[] args) {
        int[] arr = {5, 3, 6, 8, 1, 7, 9, 4, 2};
        for(int i =0;i<arr.length-1;i++){
            int minPos=i;
            for (int j=i+1;j<arr.length;j++){
            // minPos = arr[j] < arr[minPos] ? j : minPos;
                if (arr[j]<arr[minPos])
                    minPos=j;
            }
            swap(arr,i,minPos);
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

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

    /*
    * 选择排序还可以优化，可以一次循环找到一个最小值和最大值，最小值放到最前面，最大值放到最后面。循环次数少一半。
    * */
}

对数器

package mashibing_class.sorts;

import java.util.Arrays;
import java.util.Random;

public class DataChecker {
    /*
     * 验证算法：对数器
     * 如何验算算法是否正确？
     *   1. 肉眼观察
     *   2. 产生足够多的随机样本
     *   3. 用确定正确的算法计算样本结果
     *   4. 对比被验证算法的结果
     * */
    static int[] generateRandomArray() {
        Random r = new Random();
        int[] arr = new int[10000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt(10000);
        }
        return arr;
    }

    static void check() {
        int[] arr = generateRandomArray();
        int[] arr2 = new int[arr.length];
        System.arraycopy(arr, 0, arr2, 0, arr.length);//数组拷贝一份
        Arrays.sort(arr);
        SeletcionSort.sort(arr2);
        boolean same = true;
        for (int i = 0; i < arr2.length; i++) {
//            same = arr[i] != arr2[i] ? false : same;
            if (arr[i]!=arr2[i]) same=false;
        }
        System.out.println(same == true ? "right" : "wrong");
        SeletcionSort.printResult(arr2);
    }

    public static void main(String[] args) {
        check();
    }

}

选择排序作业

冒泡排序

package mashibing_class.sorts;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {9, 3, 1, 4, 6, 8, 7, 5, 2};
        sort(arr);
        //sort2(arr);
        printResult(arr);
    }
    static void sort(int[] arr) {
//        for (int i = 0; i <arr.length-1;i++)
//            //最大冒到尾部
//            for (int j=0;j<arr.length-i-1;j++){
//                if (arr[j]>arr[j+1])
//                    swap(arr,j,j+1);
//            }
        for (int i=0;i<arr.length-1;i++)
            for (int j = arr.length - 1; j > i; j--) {
                if (arr[j] < arr[j - 1]) swap(arr, j, j - 1);
            }
    }

    static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    static void printResult(int[] arr) {
        for (int i=0;i<arr.length;i++)
            System.out.print(arr[i]+" ");
    }
	 static void sort2(int[]arr){
	        for(int i=arr.length-1;i>0;i--)
	            findMax(arr,i);
	    }
    static void findMax(int[]arr,int n){
        //前n个数求最大值
        for(int i=0;i<n;i++)
            if (arr[i]>arr[i+1]) swap(arr,i,i+1);
    }

}

冒泡排序最好的时间复杂度是O(n),以上算法分析均是O(n^2),因此冒泡还有优化代码。
答：加入判断数组是否已经有序，直接遍历一次，不交换即是O(n)

插入排序(简单排序中最后一种排序)

对于基本有序的数组最好用
稳定

package mashibing_class.sorts;

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {9, 3, 1, 4, 6, 8, 7, 5, 2};
        sort(arr);
        printResult(arr);
    }
    static void sort(int[] arr) {
        //从index=1开始比较前面一个数大小，index之前都有序
        //arr[index]<arr[index-1],arr[index-1]往后挪;index--,直到arr[index]>=arr[index-1]
        int i, j;
        for (i = 1; i < arr.length; i++) {
            int insertNum = arr[i];
//            System.out.println("i: " + i + " inserNum: " + insertNum);
            for (j = i; j > 0; j--)
                if (insertNum < arr[j - 1])
                    arr[j] = arr[j - 1];
                else break;
//            System.out.println("j="+j);
            arr[j] = insertNum;
        }

//        马老师代码
//        for (int m=1;m<arr.length;m++)
//            for (int n=m;n>0;n--)
//                if (arr[n]<arr[n-1])
//                    swap(arr,n,n-1);
    }
    static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    static void printResult(int[] arr) {
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i] + " ");
    }
}

插入排序作业

插入排序比冒泡快一半，一般也比选择排序好

简单排序算法总结

1. 冒泡
   基本不用，太慢；最好O(n),最差(n^2).
2. 选择
   基本不用，不稳
3. 插入
   样本小且基本有序的时候效率比较高

希尔排序

更加高级的排序，希尔排序是插入排序的一个改进版

package mashibing_class.sorts;

public class ShellSort {
    public static void main(String[] args) {
        //间隔大时，移动次数少
        //间隔小时，移动距离短
        //因此比插入排序好
        /*
         * 希尔排序
         *   1.选择一个间隔，每一个组排好序
         *   2.选择更小的间隔，每个组排好序
         *   3.直到间隔为1，插入排序（此时基本有序，插入排序效率高）
         * */
        int[] arr = {9, 6, 11, 3, 5, 12, 8, 7, 10, 15, 14, 4, 1, 13, 2};
//        sort(arr);
        sort(arr);
        printResult(arr);
    }

    static void sort(int[] arr) {
//        int gap = 4;
//        for (int gap = 4; gap > 0; gap /= 2)
        for (int gap = arr.length >> 1; gap > 0; gap /= 2)
            //普通插入排序-->有间隔排序
            for (int i = gap; i < arr.length; i++) {
                for (int j = i; j > gap - 1; j -= gap) {
                    if (arr[j] < arr[j - gap])
                        swap(arr, j, j - gap);
                }
            }
    }

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

    static void printResult(int[] arr) {
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i] + " ");
    }
}

Knuth序列

写程序时，不熟悉可以先试试固定间隔gap,然后二分（希尔思想）===》进一步改进的序列Knuth序列。

1. h=1 最小为1
2. h=3*h+1 后面的序列
   1,4,13…

static void sort(int[] arr) {
//        int gap = 4;
//        for (int gap = 4; gap > 0; gap /= 2)
//        for (int gap = arr.length >> 1; gap > 0; gap /= 2)
        int h = 1;
        while (h <= arr.length / 3) {
            h = h * 3 + 1;
        }
        //普通插入排序-->有间隔排序
        for (int gap=h;gap>0;gap=(gap-1)/3)
        for (int i = gap; i < arr.length; i++) {
            for (int j = i; j > gap - 1; j -= gap) {
                if (arr[j] < arr[j - gap])
                    swap(arr, j, j - gap);
            }
        }
    }

希尔排序复杂度

时间复杂度 最好O(n^1.3)
空间复杂度O(1)

希尔排序作业

归并排序

递归

package mashibing_class.sorts;

public class Recursion {
    public static void main(String[] args) {
        //递归
        System.out.println();
    }
    static long f(int n) {
        if (n < 1)
            return -1;
        if (n == 1)
            return 1;
        return n + f(n - 1);
    }
}

归并排序

static void merge(int[] arr) {
        int mid = arr.length >> 1;
        int i = 0, j = mid + 1;
        int[] helpArray = new int[arr.length];
        int k = 0;
        while (i <= mid && j < =arr.length) {
//            if (arr[i] <= arr[j])
//                helpArray[k++] = arr[i++];
//            else helpArray[k++] = arr[j++];
            helpArray[k++]=arr[i]<arr[j]?arr[i++]:arr[j++];
        }
        while (i <= mid) helpArray[k++] = arr[i++];
        while (j < arr.length) helpArray[k++] = arr[j++];
        System.out.println("\nmerge后：");
        printResult(helpArray);
        System.out.println();
    }

package mashibing_class.sorts;
public class MergeSort {
    //TIM Sort
    //Java 内置排序
    public static void main(String[] args) {
        int[] arr = {1, 4, 6, 7, 10, 11, 3, 5, 8, 9};
//        int[] arr = {1,4,7,8,3,6,9};
        System.out.println("merge前：");
        printResult(arr);
//        sort(arr);
        sort(arr,0,arr.length);
        System.out.println("\nmerge后：");
        printResult(arr);

    }
    static void sort(int[] arr,int left,int right) {
//        merge(arr);
//        merge2(arr,0,arr.length>>1,arr.length);
        //base case
        if (left==right)    return;
        //分成两半，
        int mid=left+(right-left)/2;//防止越界
        // 左边排序，
        sort(arr,left,mid);
        // 右边排序
        sort(arr,mid+1,right);
        merge2(arr,left,mid,right);
    }
    static void merge(int[] arr) {
        int mid = arr.length >> 1;
        int i = 0, j = mid + 1;
        int[] helpArray = new int[arr.length];
        int k = 0;
        while (i <= mid && j < arr.length) {
//            if (arr[i] <= arr[j])
//                helpArray[k++] = arr[i++];
//            else helpArray[k++] = arr[j++];
            helpArray[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
        }
        while (i <= mid) helpArray[k++] = arr[i++];
        while (j < arr.length) helpArray[k++] = arr[j++];
        System.out.println("\nmerge后：");
        printResult(helpArray);
        System.out.println();
    }

    static void merge2(int[]arr,int left,int mid,int right){
        //上面merge不够灵活
        int []helpArray=new int[right-left];
        int i=left,j=mid+1,k=0;
        while (i<=mid&&j<right)
            helpArray[k++]=arr[i]<arr[j]?arr[i++]:arr[j++];
        while (i<=mid) helpArray[k++]=arr[i++];
        while (j<right) helpArray[k++]=arr[j++];
//        System.out.println("\nmerge后：");
//        printResult(helpArray);
//        System.out.println();

        for (int m=0;m<helpArray.length;m++){
            arr[left+m]=helpArray[m];
        }
    }
    static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    static void printResult(int[] arr) {
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i] + " ");
    }
}

java对象排序

1. 对象排序一般要求稳定（TimSort改进的排序）
   

快速排序

package mashibing_class.sorts;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {9, 3, 1, 4, 10, 6, 8, 7, 5, 11};
        System.out.println("排序前：");
        printArray(arr);
        sort(arr, 0, arr.length - 1);
        System.out.println("\n排序后:");
        printArray(arr);
    }

    static void sort(int[] arr, int left, int right) {
        if (left > right) return;
        int mid = partition(arr,left,right);
//        System.out.println("mid"+mid);;
        sort(arr,left,mid-1);
        sort(arr,mid+1,right);

    }

    static int  partition(int[] arr, int left, int right) {
//        int pivot = arr[mid];
        int pivot=arr[right];
        int rightBound=right;
//        System.out.println("\nrightBound:"+rightBound);
//        System.out.println("pivot:" + pivot);
        while (left < right) {
            while (left < right && arr[left] <= pivot) left++;
            while (left < right && arr[right] >= pivot) right--;
            if (left<right)
                swap(arr, left, right);
//            System.out.println("left:"+left+" right:"+right);
        }
//        System.out.println(arr[left]+"  "+arr[rightBound]);
        swap(arr,left,rightBound);
        return left;
    }

    static void swap(int[] arr, int i, int j) {
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
        //异或运算交换两个数
//        arr[i] = arr[i] ^ arr[j];
//        arr[j] = arr[i] ^ arr[j];
//        arr[i] = arr[j] ^ arr[i];
    }

    static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i] + " ");
    }
}

双轴快排
选两个数，第一个数比第二数小。分为三个区域，小于第一个区域的数，介于中间的区域，大于第二个数的区域
less,mid,more

计数排序

1. 非比较排序
2. 桶思想的一种

算法思想

1. 量大但是范围小
   1. 某大型企业数万名员工年龄排序
   2. 如何快速得知高考名次（腾讯面试）
      

package mashibing_class.sorts;

import java.util.Arrays;

public class CountSort {
    public static void main(String[] args) {
        int[] arr = {2, 4, 2, 3, 7, 1, 1, 0, 0, 5, 6, 9, 8, 5, 7, 4, 0, 9};
        int[] result = sort(arr);
        System.out.println(Arrays.toString(result));
    }
    static int[] sort(int[] arr) {
        int[] result = new int[arr.length];
        int[] count = new int[10];
        for (int i = 0; i < arr.length; i++) {
            count[arr[i]]++;
        }
        System.out.println(Arrays.toString(count));
        for (int i = 0, j = 0; i < count.length && j < result.length; i++) {
            while ((count[i]--)>0)
                result[j++]=i;
        }
        return result;
    }
}

现在程序有两个小bug：

1. 范围不是从零开始
2. 稳定性，现在是不稳定的。（用累加数组进行排序）

  static int[] sort(int[] arr) {
        int[] result = new int[arr.length];
        int[] count = new int[10];
        int[] reverseCount = new int[10];

        for (int i = 0; i < arr.length; i++) {
            count[arr[i]]++;
        }
        System.out.println(Arrays.toString(count));
        //累加数组
        for (int j = 1; j < count.length; j++) {
            count[j] = count[j] + count[j - 1];
        }
        System.out.println(Arrays.toString(count));
        for (int k = arr.length-1; k >= 0; k--) {
            result[--count[arr[k]]]=arr[k];
        }
        return result;
    }

总结：

1. 计数排序是非比较排序
2. 适用于特定问题，也就是对源数据有要求
3. O(n+k)

基数排序

1. 非比较排序
2. 桶思想的一种
3. 多关键字排序

package mashibing_class.sorts;

import java.util.Arrays;

public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {421, 240, 115, 532, 305, 430, 124};
        //判断最高位数
        int levels = 0;
        for (int i = 0; i < arr.length; i++) {
            levels = 0;
            for (int temp = arr[i]; temp > 0; temp /= 10)
                levels++;
        }
        System.out.println(levels);
        int[] result = sort(arr, levels);
        System.out.println(Arrays.toString(result));
    }

    static int[] sort(int[] arr, int levels) {
        int[] result = new int[arr.length];
        int[] count = new int[10];
        for (int level = 0; level < levels; level++) {
            int division = (int) Math.pow(10, level);
            System.out.println(division);
            for (int i = 0; i < arr.length; i++) {
                int num = arr[i] / division % 10;
                System.out.print(num + " ");
                count[num]++;
            }
            System.out.println();
            System.out.println(Arrays.toString(count));
            for (int j = 1; j < count.length; j++)
                count[j] = count[j] + count[j - 1];
            for (int k = arr.length - 1; k >= 0; k--) {
                int num = arr[k] / division % 10;
                System.out.println("num:" + num);
                result[--count[num]] = arr[k];
            }
            System.arraycopy(result, 0, arr, 0, arr.length);
//            System.out.println(Arrays.toString(arr));

            Arrays.fill(count, 0);//count数组置为0
        }
        return result;
    }
}

总结：

1. 本质是一种多关键字排序
2. 有低位优先和高位优先两种
   1. LSD MSD（Least Significant Digit first） (Most)
   2. MSD属于分治的思想
3. 百度百科的程序有问题
   1. 空间复杂度变高

桶排序

桶排序的算法思想：

1. 求出待排序列最小和最大数据，作差，求出桶的范围。
2. 然后遍历整个序列，放入各范围桶。
3. 每个桶进行排序。
   省了时间，空间就省不了，省了空间，时间就省不了