剑指Offer(13)顺时针打印矩阵 包含min的栈

剑指Offer(13)顺时针打印矩阵 包含min的栈

题目:

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵：

1 2 3 4

5 6 7 8

9 10 11 12

13 14 15 16

则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

思路:

12

34 输出为 1243

对于任意一个矩阵，可以找到他的位于正对角线两边界的元素，

1234

5678

4329 对于这个矩阵 第一个边界元素是1 ，第二个边界元素是9。

假设 1 的坐标为 （row1，cow1）

假设 9 的坐标为 （row2，cow2）

对于任意一个矩阵，都可以

从 cow1++到 cow2 其中row不变 输出每个元素 第一行

然后 row1 ++ 到 row2 其中cow不变 输出每个元素 最后一列

然后 cow2-- 到cow1 其中row不变 输出每个元素 最后一行

row2-- 到row1 其中cow不变 输出每个元素。 第一列

当完成一次循环时，（row1++，colw1++） 如果此时没有出现 row1>=row2 则继续上面的函数输出。

代码:

    ArrayList arrayList = new ArrayList();
    public ArrayList<Integer> printMatrix(int[][] matrix)
    {
        int row1 = 0;
        int  cow1= 0;
        int row2 = matrix.length - 1;
        int  cow2= matrix[0].length - 1;
        while (cow1 <= cow2 && row1 <= row2) {
            printEdge1(matrix, row1++, cow1++, row2--, cow2--);
        }
        return arrayList;
    }
    public  void printEdge1(int[][] m, int row1, int cow1, int row2, int cow2)
    {
        if(row1==row2)
        {
            for (int i = cow1; i <= cow2; i++)
            {
                arrayList.add(m[row1][i]);
                //只有一行， 遍历每列
            }
        }
        else if (cow1==cow2)
        {
            for (int i = row1; i <= row2; i++)
            {
                arrayList.add(m[i][cow1]);
                //只有一列  遍历每行
            }
        }
        else
        {
            int c=cow1;
            int r=row1;
            while(c!=cow2)
            {
                arrayList.add(m[row1][c]);
                // 左到右
                c++;
            }
            while(r!=row2)
            {
                arrayList.add(m[r][cow2]);
                //上到下
                r++;
            }
            while(c!=cow1)
            {
                arrayList.add(m[row2][c]);
                // 右到左
                c--;
            }
            while(r!=row1)
            {
                arrayList.add(m[r][cow1]);
                // 下到上
                r--;
            }
        }
    }

题目:

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1）。

思路:

要求如果当前最小元素的栈被弹出了,如何得到下一个最小的元素呢?

处理方法是建立一个辅助栈,每次入栈前将当前元素a与辅助栈里的顶部元素b比较,如果a>b,则入栈一个b,反之入栈a.

代码:

    private Stack<Integer> dataStack=new Stack<>();
    private Stack<Integer> helpStack=new Stack<>();
    public void push(int node) {
        dataStack.push(node);
        if (helpStack.isEmpty())
            helpStack.push(node);
        else
            helpStack.push(Math.min(node,helpStack.peek()));
    }
    public void pop() {
        dataStack.pop();
        helpStack.pop();
    }
    public int top() {
        return dataStack.peek();
    }
    public int min() {
        return helpStack.peek();
    }