牛客网剑指Offer，一些值得记住的小题（一）

本文链接：https://blog.csdn.net/shl_shl/article/details/60465580

本文提供了一系列经典的编程题目解答，包括二进制位操作、数组排序调整、链表处理及二叉树结构比较等，深入浅出地介绍了各种数据结构与算法的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

public class Solution {
    public int NumberOf1(int n) {
        int account = 0;
        while(n!=0){
            account++;
            n=n&(n-1);
        }
        return account;
    }
}

解析：（巧妙运用了&，&能实现把左右两边的数变成二进制后进行与运算的操作。）

把一个数字与这个数字减一后做与运算后得到的效果相当于把这个数字二进制数右数第一个1去掉，每经历依次循环就减少一个1，直到循环结束变成全是

0时即可输出1的个数

2.输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

public class Solution {
    public void reOrderArray(int [] array) {
       int num = array.length;//应该循环几次
	       for(int i=0;i<num;i++){       	
	       if(array[i]%2!=0){
	            continue;
	       }else{
	            int temp = array[i];
	            for(int j=i;j<array.length-1 ;j++){ 
	                array[j]=array[j+1];
	            }
	            array[array.length-1]=temp;
	            i--;
	            num--;
	            }
	        }
    }
}

解析：
思路是遇到奇数不作处理，继续循环，遇到偶数把该偶数放到末尾，后面的数一次往前提，需要注意的是把偶数放到末尾了以后要i--,把后面的数往前挪的时候，该偶数后面的数就到了该偶数的位置，该数是奇偶还需要判断，当偶数整理好了以后，奇数自然也就整理好了。

3.输入一个链表，输出该链表中倒数第k个结点。

ListNode类
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}

主类
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if(head==null||k<=0){
            return null;
        }
        ListNode node1;
        ListNode node2;
        node1=node2=head;
        for(int i=0;i<k-1;i++){
            if(node1.next!=null){
                node1=node1.next;
            }else{
                return null;
            }
            
        }
        while(node1.next!=null){
            node1=node1.next;
            node2=node2.next;
        }
        return node2;
    }
}

解析：定义两个node,先把node1先后挪k-1个位置，然后node1,node2保持不变的距离向后挪，知道node1到了链表的末尾，此时node2的位置即为倒数第k个结点

4.输入一个链表，反转链表后，输出链表的所有元素。

public class Solution {
    public ListNode ReverseList(ListNode head){
          if(head==null){
                return null;
            }  
          ListNode temp;
	        ListNode pre;
	        ListNode cur;
	        pre=head;
	        cur=head.next;  
            
	        while(cur!=null){
	            temp=cur.next;
	            cur.next=pre;
	            pre=cur;
	            cur=temp;
	        }
	        head.next=null;
	        return pre;
    }
}

解析：这一题花了我一定的功夫，方法有很多中其实最简便的只需要两个变量，但是那种方法改变了参数head的位置，所以我更喜欢自己的方法，循环中实现步骤为：(temp的作用是记录cur.next的位置，最后要把head.next=null)

5.输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

ListNode类
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}

主类
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1==null&&list2!=null){
            return list2;
        }else if(list2==null&&list1!=null){
            return list1;
        }else if(list1==null&&list2==null){
            return null;
        }
        ListNode head;
        ListNode ll;
        ListNode la = list1;
        ListNode lb = list2;
        
        if(la.val<lb.val){
            head=ll=list1;
            la=list1.next;
        }else{
            head=ll=list2;
            lb=list2.next;
        }
        while(la!=null&&lb!=null){
            if(la.val<lb.val){
                ll.next=la;
                ll=la;
                la=la.next;
            }else{
                ll.next=lb;
                ll=lb;
                lb=lb.next;
            }
        }
        if(la!=null){
            ll.next=la;
        }else{
            ll.next=lb;
        }
        return head;
    }
}

解析：
截了几张上课时老师的PPT

6.输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

TreeNode类
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}

主类
public class Solution {
    public boolean IsSubTree(TreeNode root1,TreeNode root2){
        if(root1==null&&root2!=null){
            return false;
        }else if(root2==null){
            return true;
        }else{
            if(root1.val==root2.val){
                return IsSubTree(root1.left,root2.left)&&IsSubTree(root1.right,root2.right);
            }else{
                return false;
            }
        }
    }
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        if(root1==null||root2==null){
            return false;
        }else{
            return IsSubTree(root1,root2)||HasSubtree(root1.left,root2)||HasSubtree(root1.right,root2);
        }
        
    }
}

解析：只是一道递归的练习