1.兩個連結清單相加

2.判斷樹是否為鏡像二叉樹

3.從一個無序數組中找出倒數第k大的數

4.合并兩個無序數組為一個有序數組

5.在一個數組中，找到最長子序列

6.爬樓梯問題，列印所有結果

1.兩個連結清單相加

3->1->5->null 5->9->2->null 傳回8->0->8->null 513+295=808

public ListNode addList(ListNode l1,ListNode l2){
        ListNode dummy = new ListNode(-1);
        ListNode p1=l1;
        ListNode p2=l2;
        ListNode p =dummy;
        int flag = 0;
        while(p1!=null||p2!=null){
            int temp = flag;
            if(p1!=null){
                temp+=p1.val;
                p1=p1.next;
            }
            if(p2!=null){
                temp+=p2.val;
                p2=p2.next;
            }
            if(temp>9){
                temp-=10;
                flag=1;
            }else{
                flag=0;
            }
            p.next=new ListNode(temp);
            p=p.next;
        }
        if(flag==1)
            p.next=new ListNode(1);
        return dummy.next;
        
    }

6->1->7 2->9->5 傳回9-1-2 617+295=912

public ListNode addList(ListNode l1,ListNode l2){
        ListNode l11 = reverse(l1);
        ListNode l22 = reverse(l2);
        ListNode dummy = new ListNode(-1);
        ListNode p1=l11;
        ListNode p2=l22;
        ListNode p=dummy;
        int flag = 0;
        while(p1!=null||p2!=null){
            int temp=flag;
            if(p1!=null){
                temp+=p1.val;
                p1=p1.next;
            }
            if(p2!=null){
                temp+=p2.val;
                p2=p2.next;
            }
            if(temp>9){
                temp-=10;
                flag=1;
            }else{
                flag=0;
            }
            p.next=new ListNode(temp);
            p=p.next;
        }
        if(flag==1)
            p.next=new ListNode(1);
        return reverse(dummy.next);
    }
    public ListNode reverse(ListNode haed){
        ListNode cur=head,pre=null;
        while(cur!=null){
            ListNode temp=cur.next;
            cur.next=pre;
            pre=cur;
            cur=temp;
        }
        return pre;
    }

2.判斷樹是否為鏡像二叉樹

public boolean isSymmetric(TreeNode root) {
        return root==null?true:recur(root.left,root.right);
    }
    boolean recur(TreeNode L,TreeNode R){
        if(L==null&&R==null) return true;
        if(L==null||R==null||L.val!=R.val) return false;
        return recur(L.left,R.right)&&recur(L.right,R.left);
    }

public boolean isSymmetric(TreeNode root) {
        //使用隊列
        if(root==null) return true;
        Queue<TreeNode> q= new LinkedList<>(){{add(root.left);add(root.right);}};
        while(!q.isEmpty()){
            TreeNode l = q.poll();
            TreeNode r = q.poll();
            if(l==null&&r==null) continue;
            if(l==null||r==null||l.val!=r.val) return false;
            q.offer(l.left);
            q.offer(r.right);
            q.offer(l.right);
            q.offer(r.left);
        }
        return true;
    }

3.從一個無序數組中找出倒數第k大的數

3.1最小的k個數

（1）快排

public int[] getLeastNumbers(int[] arr, int k) {
        if (k >= arr.length) return arr;
        quick_sort(arr,0,arr.length-1,k);
        return  Arrays.copyOf(arr, k);
    }
   public static void quick_sort(int[] q,int l,int r,int k){
        //base case 
        if(l>=r){return;}
        int mid=q[l],i=l-1,j=r+1;
        while(i<j){
            do i++;while(q[i]<mid);
            do j--;while(q[j]>mid);
            if(i<j){swap(q,i,j);}
        }
        if(k-1>j){
            quick_sort(q,j+1,r,k);
            quick_sort(q,l,j,k);
        }else{
            quick_sort(q,l,j,k);
        }
    }
    public static void swap(int[] q,int i,int j){
        int temp=q[i];
        q[i]=q[j];
        q[j]=temp;
    }

（2）堆排序

// 保持堆的大小為K，然後周遊數組中的數字，周遊的時候做如下判斷：
// 1. 若目前堆的大小小于K，将目前數字放入堆中。
// 2. 否則判斷目前數字與大根堆堆頂元素的大小關系，如果目前數字比大根堆堆頂還大，這個數就直接跳過；
//    反之如果目前數字比大根堆堆頂小，先poll掉堆頂，再将該數字放入堆中。
class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        // 預設是小根堆，實作大根堆需要重寫一下比較器。
        Queue<Integer> pq = new PriorityQueue<>((v1, v2) -> v2 - v1);
        for (int num: arr) {
            if (pq.size() < k) {
                pq.offer(num);
            } else if (num < pq.peek()) {
                pq.poll();
                pq.offer(num);
            }
        }
        
        // 傳回堆中的元素
        int[] res = new int[pq.size()];
        int idx = 0;
        for(int num: pq) {
            res[idx++] = num;
        }
        return res;
    }
}

手動建堆--大根堆

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        
        int [] res =new int[k];
        System.arraycopy(arr, 0, res, 0, k);
        buildHeap(res);
        for(int i=k;i<arr.length;i++){
            if(arr[i]<res[0])
                res[0]=arr[i];
                adjust(res,0);
        }
    
        return res;
    }

        public void buildHeap(int[] arr){
        for(int i = arr.length / 2 - 1; i >= 0; i--){
            adjust(arr, i);
        }
    }
    public void adjust(int[] arr, int i){
        int maxIndex = i;
        int len = arr.length;
        if(2*i+1 < len && arr[2*i+1] > arr[maxIndex]) maxIndex = 2*i+1;
        if(2*i+2 < len && arr[2*i+2] > arr[maxIndex]) maxIndex = 2*i+2;
        if(maxIndex != i){
            swap(arr, maxIndex, i);
            adjust(arr, maxIndex);
        }
    }
    public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

（3）二叉搜尋樹

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        // TreeMap的key是數字, value是該數字的個數。
        // cnt表示目前map總共存了多少個數字。
        TreeMap<Integer, Integer> map = new TreeMap<>();
        int cnt = 0;
        for (int num: arr) {
            // 1. 周遊數組，若目前map中的數字個數小于k，則map中目前數字對應個數+1
            if (cnt < k) {
                map.put(num, map.getOrDefault(num, 0) + 1);
                cnt++;
                continue;
            } 
            // 2. 否則，取出map中最大的Key（即最大的數字), 判斷目前數字與map中最大數字的大小關系：
            //    若目前數字比map中最大的數字還大，就直接忽略；
            //    若目前數字比map中最大的數字小，則将目前數字加入map中，并将map中的最大數字的個數-1。
            Map.Entry<Integer, Integer> entry = map.lastEntry();
            if (entry.getKey() > num) {
                map.put(num, map.getOrDefault(num, 0) + 1);
                if (entry.getValue() == 1) {
                    map.pollLastEntry();
                } else {
                    map.put(entry.getKey(), entry.getValue() - 1);
                }
            }
            
        }

        // 最後傳回map中的元素
        int[] res = new int[k];
        int idx = 0;
        for (Map.Entry<Integer, Integer> entry: map.entrySet()) {
            int freq = entry.getValue();
            while (freq-- > 0) {
                res[idx++] = entry.getKey();
            }
        }
        return res;
    }
}

3.2 數組中第k個最大元素

class Solution {
    public int findKthLargest(int[] nums, int k) {
        if (k > nums.length) return -1;
        quick_sort(nums,0,nums.length-1,nums.length-k+1);
        return  nums[nums.length-k];
    }

    public static void quick_sort(int[] q,int l,int r,int k){
        //base case 
        if(l>=r){return;}
        int mid=q[l],i=l-1,j=r+1;
        while(i<j){
            do i++;while(q[i]<mid);
            do j--;while(q[j]>mid);
            if(i<j){swap(q,i,j);}
        }
        if(k-1>j){
            quick_sort(q,j+1,r,k);
            quick_sort(q,l,j,k);
        }else{
            quick_sort(q,l,j,k);
        }
    }
    public static void swap(int[] q,int i,int j){
        int temp=q[i];
        q[i]=q[j];
        q[j]=temp;
    }
}

3.3 堆

建堆----大根堆

public void buildHeap(int[] arr){
        for(int i = arr.length / 2 - 1; i >= 0; i--){
            adjust(arr, i);
        }
    }
    public void adjust(int[] arr, int i){
        int maxIndex = i;
        int len = arr.length;
        if(2*i+1 < len && arr[2*i+1] > arr[maxIndex]) maxIndex = 2*i+1;
        if(2*i+2 < len && arr[2*i+2] > arr[maxIndex]) maxIndex = 2*i+2;
        if(maxIndex != i){
            swap(arr, maxIndex, i);
            adjust(arr, maxIndex);
        }
    }
    public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

小根堆

public void buildHeap(int[] arr){
        for(int i = arr.length / 2 - 1; i >= 0; i--){
            adjust(arr, i);
        }
    }
    public void adjust(int[] arr, int i){
        int minIndex = i;
        int len = arr.length;
        if(2*i+1 < len && arr[2*i+1] < arr[minIndex]) maxIndex = 2*i+1;
        if(2*i+2 < len && arr[2*i+2] < arr[minIndex]) maxIndex = 2*i+2;
        if(maxIndex != i){
            swap(arr, maxIndex, i);
            adjust(arr, maxIndex);
        }
    }
    public void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

4.合并兩個無序數組為一個有序數組

合并兩個數組，然後快排或者堆排序，香不

5.在一個數組中，找到最長子序列

再等等

6.爬樓梯問題，列印所有結果

class Solution {
    public static List<List<Integer>> res = new LinkedList<>();
    public int numWays(int n) {
        if(n==0) return 1;
        LinkedList<Integer> track = new LinkedList<Integer>();
        int[] nums = new int[]{1, 2};
        backtrack(nums, n, track);
        System.out.println(res);
        return res.size();
    }

    private static void backtrack(int[] nums, int n, LinkedList<Integer> track) {
        if(n<0)
            return;
        if(n==0) {
            res.add(new LinkedList(track));
            System.out.println(track);
            return;
        }

        for(int i=0; i<nums.length; i++) {

            track.add(nums[i]);

            backtrack(nums, n-nums[i], track);

            track.removeLast();
        }
    }
}

1.兩個連結清單相加

2.判斷樹是否為鏡像二叉樹

3.從一個無序數組中找出倒數第k大的數

4.合并兩個無序數組為一個有序數組

5.在一個數組中，找到最長子序列

6.爬樓梯問題，列印所有結果

1.兩個連結清單相加

2.判斷樹是否為鏡像二叉樹

3.從一個無序數組中找出倒數第k大的數

3.1最小的k個數

（1）快排

（2）堆排序

（3）二叉搜尋樹

3.2 數組中第k個最大元素

3.3 堆

4.合并兩個無序數組為一個有序數組

5.在一個數組中，找到最長子序列

6.爬樓梯問題，列印所有結果

繼續閱讀

Command Network(POJ 3164)---定根最小樹形圖模闆題題目描述輸入格式輸出格式輸入樣例輸出樣例分析源程式

開源低帶寬語音編解碼器

241 Different Ways to Add Parentheses（C代碼版）

【趨高機器視覺】機器視覺技術原了解析及解決方案

LeetCode-110-平衡二叉樹-C語言

CSMA/CD1． CSMA/CD的概述2． CSMA 的工作原理3． CSMA/CD控制規程及特點4． CSMA/CD協定5． CSMA/CD的優點6．結束語

極大似然法(ML)與最大期望法(EM)

C++ 第十五周報告1--《冒泡法排序》

筆試面試題目：滑動視窗(二)

27. Remove Element(清單)題目代碼

資料結構與算法（27）——排序（二）

Dijkstra--簡易版（最短路徑）

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

LeetCode OJ Binary Tree Right Side View

leetcode809

hdu7108哈希