每日训练-day24

day24_0521

选择题

 1、Q.rear>Q.front
假设Q.rear=5，Q.front=2，则现在队列占得单元有Q.data[2]、Q.data[3]、Q.data[4]三个，那么队列长度L=Q.rear-Q.front=3。
2、Q.rear=Q.front
假设Q.rear=5，Q.front=5。我们知道Q.rear是一定指向空单元的，
所以队列长度L=Q.rear-Q.front=0；
3、Q.rear<Q.front
假设Q.rear=3，Q.front=5，那么队列占得单元有Q.front开头的Q.data[5]、Q.data[6]、Q.data[7]...Q.data[9]5个单元，再加上Q.rear往下数的Q.data[2]、Q.data[1]、Q.data[0]三个单元，一共有8个单元。则MaxSize-Q.front=5，MaxSize-Q.front+Q.rear=8，
所以队列长度L=MaxSize-Q.front+Q.rear；

3的结果我们将变量位置变一下，则L=Q.reare-Q.front+MaxSize；
这时我们发现3的结果不就是在1和2的结果上加了一个MaxSize吗。根据数学取余的性质，
（x+ky）%y=x（注：x<y，k∈N）,因此综上所述，队列长度公式可以写成：
L=（Q.reare-Q.front+MaxSize）%MaxSize

删除8后，将最后一个节点12移动到堆顶，首先12和15，10分别比较选取最小的子节点10，然后10和12交换位置，最后12和16比较大小，所以3次。

 C HASH函数冲突处理方式
（1）开放定值法  这个方法分为几种
 其中一种是线性探索，就是这个值有冲突  就向下一个寻址 依次加1  向后直到不冲突为止，但是这样 有的时候会造成 效率偏低  。所以还有的时候会使用二次探索法  就是使用平方的方式  等。
（2）拉链法  这个方法就是 使用链表处理冲突  只要有冲突就增加一个链表节点。
（3）双哈希法  就是这个hash函数有冲突  就换一个hash函数试试。
（4）建立公共溢出区  这种方法就是将哈希表分为基本表和溢出表  凡是有冲突的就直接放到溢出区。

 

快排的阶段性排序的结果的特点是，第i趟完成时，会有i个以上的数出现在它最终将要出现的位置 

 1. 在每一个链表中取出第一个值，然后把它们放在一个大小为N的数组里，然后把这个数组当成heap建成小(大)根堆。此步骤的时间复杂度为O(N)：N个数构建一个堆的复杂度是O(N)
2. 取出堆中的最小值(也是数组的第一个值), 然后把该最小值所处的链表的下一个值放在数组的第一个位置。如果链表中有一个已经为空（元素已经都被取出），则改变heap的大小。此步骤的时间复杂度为O(lg N)。
3. 不断的重复步骤二，直到所有的链表都为空。
建堆只建一次，复杂度为O(N)；调整堆MN-1次（构建的时候抽走了根结点，剩下的数目是MN-1个数），复杂度为(MN-1)*O(lg N)。
4.复杂度是O(N)+(MN-1)*O(lg N)，所以复杂度为O(MN*lg N)
在堆排序中也是一样的，总共n个数，需要得到n个有序的数，那么构建堆需要O(n)，重建堆需要（n-1)*O(lgn)，所以总共复杂度O(nlgn)；如果我只需要前面k个数有序的，那么重构堆需要k*O(lgn)，那么总共复杂度就是O(klgn)

二叉排序树，左子树<根<右子树 

编程

年终年

 

import java.util.*;

public class Bonus {
    public int getMost(int[][] board) {
        // write code here
     int[][] arr = new int[6][6];
         for (int i=0;i<6;i++){
            for (int j =0; j <6; j++) {
                if(i==0&&j==0){
                    arr[i][j]=board[i][j];
                }else if (i == 0) {
                        arr[i][j] = arr[i][j - 1] +board[i][j];
                    } else if (j == 0) {
                        arr[i][j] = arr[i - 1][j] +board[i][j];
                    } else {
                        arr[i][j] = Math.max(arr[i - 1][j], arr[i][j-1])+board[i][j];
                    }
                }
            }
        return arr[5][5];
    }
}

迷宫问题

 这段代码不能完全解决这个问题，只能解决向下走和向上走，我实在不想到了

public class Maze {   
 public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int[] a=new int[2];
        for(int i=0;i<2;i++){
            a[i]=sc.nextInt();
        }
        int row=a[0];
        int column=a[1];
        int[][] maze=new int[row][column];
        for(int i=0;i<row;i++){
            for(int j=0;j<column;j++){
                maze[i][j]=sc.nextInt();
            }
        }
        check(maze,0,0);//预先探测迷宫一遍，将走不通的路置1
        System.out.println(Path(maze,0,0));
    }

    private static String Path(int[][] maze, int x, int y) {
        if(x==maze.length-1&&y==maze[x].length-1){
            return "("+x+","+y+")";
        }
        //当前是路输出，且继续走
        if(x<maze.length&&y<maze[x].length&&maze[x][y]==0){
            return "("+x+","+y+")"+"\n"+Path(maze,x+1,y)+Path(maze,x,+y+1);
        }
        return "";
    }

    public static int  check(int[][] arr,int a,int b){
        if(a==arr.length-1&&b==arr[a].length-1){
            return 1;
        }
        //当前位置是路
        if(a<arr.length&&b<arr[a].length&&arr[a][b]==0){
            //当前为死路
            if(check(arr,a+1,b)==-1&&check(arr,a,b+1)==-1){
                //那么此路就不要了
                arr[a][b]=1;
                return -1;
            }else{
                return 1;
            }
            //不是路
        }else return -1;
    }
}