Code Top: day6

m0_47869044

已于 2024-03-29 18:42:20 修改

阅读量68

点赞数 2

分类专栏： CodeTop 文章标签：算法 leetcode 数据结构 java

于 2024-03-28 19:25:44 首次发布

本文链接：https://blog.csdn.net/m0_47869044/article/details/137121597

版权

CodeTop 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文介绍了三个Java编程问题的解决方案：树的锯齿形层次遍历（ZigzagLevelOrder），链表在两个指针之间的翻转，以及二维矩阵的螺旋遍历。展示了如何使用递归和迭代方法处理这些数据结构和算法问题。

摘要由CSDN通过智能技术生成

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Deque<TreeNode> que = new LinkedList<>();
        if (root==null) return result;
        que.add(root);
        while(!que.isEmpty()){
            List<Integer> path = new ArrayList<>();
            int size = que.size();
            for (int i=0;i<size;i++){
                TreeNode node = que.pollFirst();
                path.add(node.val);
                if (node.left!=null) que.addLast(node.left);
                if (node.right!=null) que.addLast(node.right);
            }
            result.add(path);
            if (que.isEmpty()) break;
            path = new ArrayList<>();
            size = que.size();
            for (int i=0;i<size;i++){
                TreeNode node = que.pollLast();
                path.add(node.val);
                if (node.right!=null) que.addFirst(node.right);
                if (node.left!=null) que.addFirst(node.left);
            }
            result.add(path);
        }
        return result;
    }
}

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode start = dummy;
        ListNode end = dummy;
        for (int i=0;i<left-1;i++){
            start = start.next;
        }
        ListNode preNode = start;
        start = start.next;
        for (int i=0;i<right;i++){
            end = end.next;
        }
        ListNode nextNode = end.next;
        ListNode temp = reverse(start,end);
        preNode.next = temp;
        start.next = nextNode;
        return dummy.next;
    }
    public ListNode reverse(ListNode start, ListNode end){
        ListNode pre = null;
        ListNode cur = start;
        while(pre!=end){
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        int m = matrix.length, n = matrix[0].length;
        int left = 0, right = n-1;
        int up = 0, down = m-1;
        int count = m>n ? n : m;
        if (count%2==0){
            count = count/2;
        }else{
            count = count/2 + 1;
        }
        while(count-->0){
            // left--right
            for(int i=left;i<=right;i++){
                result.add(matrix[up][i]);
            }
            // up--down
            up++;
            if (up>down) break;
            for (int i=up;i<=down;i++){
                result.add(matrix[i][right]);
            }
            // right--left
            right--;
            if (left>right) break;
            for (int i=right;i>=left;i--){
                result.add(matrix[down][i]);
            }
            // down--up
            down--;
            for(int i=down;i>=up;i--){
                result.add(matrix[i][left]);
            }
            left++;
        }
        return result;
    }
}