手撕算法总结

原创已于 2022-03-07 03:01:29 修改 · 405 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

于 2022-03-03 22:09:34 首次发布

本文探讨了多种数据结构问题的解决方案，包括LeetCode中的207题判断有环、27题下一个排列、24题两两交换链表中的节点以及1087题花括号展开。通过示例代码详细解析了如何利用链表进行操作，如检查环、排序等，并展示了二叉树的最大路径和排序链表的方法。这些算法涉及到了链表、数组、二叉树等核心数据结构的操作和优化。

【Leetcode207】判断是否有环

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        Map<Integer,List<Integer>> graph = new HashMap<>();
        int[] inDegree = new int[numCourses];
        for(int i=0;i<numCourses;i++){
            graph.put(i,new LinkedList<Integer>());
            inDegree[i]=0;
        }
        for(int []prereq:prerequisites){
            graph.get(prereq[1]).add(prereq[0]);
            inDegree[prereq[0]]++;
        }

        Queue<Integer> queue = new LinkedList<>();
        List<Integer> res = new LinkedList<>();
        for(int i=0;i<numCourses;i++){
            if(inDegree[i]==0){
                queue.offer(i);
            }
        }

        while(!queue.isEmpty()){
            int course = queue.remove();
            res.add(course);
            for(int next:graph.get(course)){
                inDegree[next]--;
                if(inDegree[next]==0){
                    queue.offer(next);
                }
            }
        }
        if(res.size()==numCourses){
            return true;
        }else{
            return false;
        }
    }
}

【leetcode27】下一个排列

class Solution {
    public void nextPermutation(int[] nums) {
        int i = nums.length-2;
        while(i>=0&&nums[i]>=nums[i+1]){
            i--;
        }
        if(i>=0){
            int j=nums.length-1;
            while(j>=0&&nums[i]>=nums[j]){
                j--;
            }
            swap(nums,i,j);
        }
        reverse(nums,i+1);
    }

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

    public void reverse(int[] nums,int start){
        int left = start,right=nums.length-1;
        while(left<right){
            swap(nums,left,right);
            left++;
            right--;
        }
    }
}

把数组排列成最小的数

题目：
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个，例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

代码：

public class Main32{
    public String minNumber1(int[] nums){
        String[] res = new String[nums.length];
        int len = nums.length;
        for(int i=0;i<len;i++){
            res[i]=String.valueOf(nums[i]);
        }
        Arrays.sort(res,(x,y)->(x+y).compareTo(y+x));
        StringBuilder str=new StringBuilder();
        for(String x:res){
            str.sppend(x);
        }
        return str.toString();
    }
}

【leetcode24两两交换链表中的节点】

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode temp = dummy;
        while(temp.next!=null&&temp.next.next!=null){
            ListNode node1 = temp.next;
            ListNode node2 = temp.next.next;
            temp.next = node2;
            node1.next = node2.next;
            node2.next = node1;
            temp = node1;
        }
        return dummy.next;
    }
}

【leetcode二叉树中最大路径】

class Solution {
    int pathSum = Integer.MIN_VALUE;

    public int maxPathSum(TreeNode root) {
        dfs(root);
        return pathSum;
    }

    public int dfs(TreeNode node){
        if(node==null) return 0;
        int left = dfs(node.left);
        int right = dfs(node.right);
        int ret = Math.max(node.val,node.val+Math.max(left,right));
        pathSum = Math.max(pathSum,Math.max(ret,node.val+left+right));
        return ret;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        return sortList(head,null);
    }
    public ListNode sortList(ListNode head,ListNode tail){
        if(head==null){
            return head;
        }
        if(head.next == tail){
            head.next = null;
            return head;
        }
        ListNode slow = head,fast = head;
        while(fast!=tail){
            slow = slow.next;
            fast = fast.next;
            if(fast!=tail){
                fast = fast.next;
            }
        }
        ListNode mid = slow;
        ListNode list1 = sortList(head,mid);
        ListNode list2 = sortList(mid,tail);
        ListNode sorted = merge(list1,list2);
        return sorted;
    }

    public ListNode merge(ListNode head1,ListNode head2){
        ListNode dummyHead = new ListNode(0);
        ListNode temp = dummyHead, temp1 = head1, temp2 = head2;
        while(temp1!=null&&temp2!=null){
            if(temp1.val<=temp2.val){
                temp.next = temp1;
                temp1 = temp1.next;
            }else{
                temp.next = temp2;
                temp2 = temp2.next;
            }
            temp = temp.next;
        }
        if(temp1!=null){
            temp.next=temp1;
        }else if(temp2!=null){
            temp.next = temp2;
        }
        return dummyHead.next;
    }
}