微信红包、链表习题

1.若栈采用顺序存储方式存储，现两栈共享空间V[1…m]，top[i]代表第i个栈( i =1,2)栈顶，栈1的底在v[1]，栈2的底在V[m]，则栈满的条件是（B）。
A top[1]+top[2]=m
B top[1]+1=top[2]
C top[2]-top[1]|=0
D top[1]=top[2]
2.某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ B）
A 不存在这样的二叉树
B 200
C 198
D 199
解析：
根据二叉树的基本性质，对任何一棵二叉树，度为0的结点（即叶子结点）总是比度为 2 的结点多一个。题目中度为 2 的结点为 199 个，则叶子结点为 199+1=200 。故本题答案为 B 选项。
3.以下哪种排序算法对(1,3,2,4,5,6,7,8,9)进行的排序最快？A
A 冒泡
B 快排
C 归并
D 堆排
解析：
若记录的初始状态已经按关键码基本有序，则选用直接插入排序或冒泡排序发为宜
4.设无向图的顶点个数为n，则该图最多有多少条边？C
A n-1
B n（n+1）/2
C n（n-1）/2
D n
E 不同于以上答案
解析：
无向图的顶点个数为n,则该图最多有n(n-1)/2 条边；
有相图的顶点个数为n，则该图最多有n(n-1)条边。
5.标题：微信红包
【微信红包】 春节期间小明使用微信收到很多个红包，非常开心。在查看领取红包记录时发现，某个红包金额出现的次数超过了红包总数的一半。请帮小明找到该红包金额。写出 具体算法思路和代码实现，要求算法尽可能高效。 给定一个红包的金额数组gifts及它的大小n，请返回所求红包的金额。 若没有金额超过总数的一半，返回0。
测试样例：[1,2,3,2,2],5 返回：2

import java.util.*;
public class Gift {
    public int getValue(int[] gifts, int n) {
        // write code here
        int result = 0;
        HashMap<Integer,Integer> map = new HashMap<>();
        int a = 0;
        if(n%2==0){
            a = n/2;
        }else{
            a = (n/2)+1;
        }
        for(int i = 0;i<gifts.length;i++){
            int count = map.getOrDefault(gifts[i],0);
            map.put(gifts[i],count+1);
        }
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            int num = entry.getKey();
            int c = entry.getValue();
            if(c>=a){
                result = num;
            }
        }
        return result;
    }
}
//方法二：
import java.util.*;
public class Gift {
    public int getValue(int[] gifts, int n) {
        if (gifts.length < n) return 0;
        if (gifts.length == 0) return 0;
        int count = 0, temp = 0;
        for (int i = 0; i < n; i++) {
            if (count == 0) {
                temp = gifts[i];
                count = 1;
            } else {
                if (temp == gifts[i]) 
                    count++;
                else
                    count--;
            }
        }
        int size = 0;
        for (int i = 0; i < n; i++) {
            if (temp == gifts[i]) size++;
        }
        return (size > n / 2) ? temp : 0;
    }
}

6.编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。注意：分割以后保持原来的数据顺序不变。

import java.util.*;
/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        // write code here
        ListNode result = null;
        ListNode node = pHead;
        ListNode b = null;
        ListNode last1 = null;
        ListNode last2 = null;
        ListNode back = null;
        while (node != null) {
            if (node.val < x) {
                ListNode n = new ListNode(node.val);
                if (result == null) {
                    result = n;
                    back = n;
                } else {
                    last1 = result;
                    while (last1.next!=null){
                        last1 = last1.next;
                    }
                    last1.next = n;
                    back = n;
                }
            } else {
                ListNode n = new ListNode(node.val);
                if (b == null) {
                    b = n;
                } else {
                    last2 = b;
                    while (last2.next!=null){
                        last2 = last2.next;
                    }
                    last2.next = n;
                }
            }
            node = node.next;
        }
        if(back!=null){
            back.next = b;
            return result;
        }else {
            return b;
        }
    }
}
//方法二：
import java.util.*; 
/*public class ListNode { 
        int val;
        ListNode next = null;
        ListNode(int val) {
         this.val = val;
        } 
  }*/
public class Partition {
    public ListNode partition(ListNode pHead, int x) {

        if (pHead == null || pHead.next == null) {
            return pHead;
        }
        ListNode cur = pHead;
        //定义2个链表，此处Shead Bhead两个头指针 
        ListNode Shead = new ListNode(-1);
        ListNode Bhead = new ListNode(-1);
        ListNode Stmp = Shead;
        ListNode Btmp = Bhead;
        while (cur != null) {
            if (cur.val < x) {
                //值小于x的节点 
                Stmp.next = new ListNode(cur.val);
                Stmp = Stmp.next;
            } else {
                //值大于等于x的节点 
                Btmp.next = new ListNode(cur.val);
                Btmp = Btmp.next;
            }
            cur = cur.next;
        }//第1个链表的头
        cur = Shead;
        //循环遍历找到第1个链表的尾 
        while (cur.next != null && cur.next.val != -1) {
            cur = cur.next;
        }
        //cur的next指向第2个节点的next(非头节点) 
        // 相当于将第1个链表和第2个链表连接 
        cur.next = Bhead.next;
        return Shead.next;
        //返回第1个节点next(不含头节点) 
    }
}