69.平方根8.字符串转换整数82.删除排序链表重复元素Ⅱ19.删除链表倒数第N个结点2.两数相加148.排序链表144.二叉树前序遍历4.寻找两个正序数组的中位数(归并排序,线索二叉树)

本文链接：https://blog.csdn.net/lastxuan6/article/details/122738912

69.sqrt(x)

给你一个非负整数 x ，计算并返回 x 的算术平方根。由于返回类型是整数，结果只保留整数部分，小数部分将被舍去。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

0 <= x <= $2^{31}$ - 1

输入：x = 8
输出：2

注意相乘时溢出int型范围的情况。二分查找可以达到O(logn)。

 public int mySqrt(int x) {
    int left=0,right=x;
    while(left<=right)
    {
    int mid=(left+right)/2;
    if((long)mid*mid<x)
    left=mid+1;
    else if((long)mid*mid>x)
    right=mid-1;
    else return mid;
    }
    if((long)left*left<x)
    return left;
    else
    return left-1;
  }

8.字符串转换整数

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数。

输入：s = " -42"
输出：-42

输入：s = “-91283472332”
输出：-2147483648 (越下界则返回下界)

输入：s = " + 413"
输出：0(正负号后面紧跟数字才算合法)

判断越界if(sign==1&&(long)sum*10+(c-‘0’)>2147483647)；注意正负号后面紧跟数字才算合法的正负符号。

82.删除排序链表中的重复元素Ⅱ

给定一个已排序的链表的头 head ，删除原始链表中所有重复数字的节点，只留下不同数字。返回排序后链表。

输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]

设三个节点，一个保存前驱，两个用于比较。

19.删除链表的倒数第N个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

注意要删除第一个结点的情况。

2.两数相加

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

148.排序链表

给你链表的头结点 head ，请将其按升序排列并返回 排序后的链表 。

输入：head = [4,2,1,3]
输出：[1,2,3,4]

归并排序：1.快慢指针找到中点2.递归调用sort()继续分成两半3.分到最底层的时候开始两两合并返回链表。这里要注意的是整个过程是自顶向下再自下向上，这里merge()和sort()函数返回的链表都是有序的；找到中点后要先从中点断链，才继续对前半部分和后半部分递归排序。时间O(nlogn)，因为递归占用了栈空间，因此空间O(longn)。

 public ListNode sortList(ListNode head) {
            if(head==null)
            return head;
            ListNode tail=head;
            while(tail.next!=null) tail=tail.next;
            return sort(head,tail);
    }
    public ListNode sort(ListNode left,ListNode right)
    {
        if(left==right)
        return left;
        ListNode slow=left,fast=left.next;
        while(fast!=null&&fast.next!=null)
        {
            slow=slow.next;
            fast=fast.next.next;
        }
        ListNode p=slow.next;
        slow.next=null;
        ListNode l1=sort(left,slow);
        ListNode l2=sort(p,right);
        return merge(l1,l2);
    }
    public ListNode merge(ListNode p,ListNode q)
    {
        ListNode phead=new ListNode(0),tail=phead;
        while(p!=null&&q!=null)
        {
            if(p.val<q.val)
            {
                tail.next=p;
                tail=tail.next;
                p=p.next;
            }
            else
            {
                tail.next=q;
                tail=tail.next;
                q=q.next;
            }
        }
        if(p!=null) tail.next=p;
        if(q!=null) tail.next=q;
        return phead.next;
    }

快排。注意这里链表的快排不同于顺序表的快排，不需要双指针，只需要从头遍历一次链表，把比划分点小的结点断开取出来存放在另一个链表里，最后让大链表插在小链表后面，得到的新链表中划分节点位置一定是正确的。注意别忘了和原先链表前驱后继连起来，否则会断链，这里phead是待排序链表的前驱。

 public ListNode sortList(ListNode head) {
            ListNode phead=new ListNode(-1,head),tail=phead;
            while(tail.next!=null) tail=tail.next;
            quicksort(phead,tail);
            return phead.next;
    }
    public void quicksort(ListNode phead,ListNode tail)
    {
        if(phead.next==tail||phead==tail)
        return;
        ListNode end=tail.next,p=phead.next;
        ListNode big=new ListNode(0),small=new ListNode(0),ph=big,ps=small;
        int pro=p.val;
        while(p!=end)
        {
            if(p.val>=pro)
            {
                ph.next=p;
                ph=ph.next;
                p=p.next;
            }
            else
            {
                ps.next=p;
                ps=ps.next;
                p=p.next;
            }
        }
        ps.next=big.next;
        phead.next=small.next;
        ph.next=end;
        if(ps==small)  ps=phead;  
        quicksort(phead,ps);
        quicksort(big.next,ph);
    }

有一种不需要递归直接自底向上的归并排序，空间可以达到O(1)，大致思路是用一个slen来记录归并块的大小，每排序完一轮后slen= $s l e n * 2$ ，最后一个归并块的大小可以小于slen。每轮排序中可以根据slen来找到要归并的两个块的首节点和尾结点，需要考虑的有以下几个点：

通过merge排序后，会发现得到的有序链表会从原先的链表断开，因此得到有序链表后要重新和原先链表连接上。可以这样设计，merge(ListNode pre,int slen)，其中传入的形参是两个相连块首节点的前驱结点pre，slen是块的大小，在merge排序前还要保存下相连块尾节点的后继。排序完后将有序链表和前驱后继连起来。然后merge返回有序链表的尾节点，作为下次归并排序的前驱。
外循环中，可以设一个计数器来记录第一个有序块的长度，退出外循环条件是这个有序块的长度等于原先链表的长度，这时候说明排序完毕。

144.二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的前序遍历。

输入：root = [1,null,2,3]
输出：[1,2,3]

递归或者栈。空间O(n)。
线索二叉树，当前节点左右子树不为空，则令当前节点左孩子的最右节点(当前节点的前驱)的右指针指向当前节点右孩子。注意在这里该最右节点指向的不一定是该节点的后继节点，但一定是其父亲节点前驱的后继节点。空间O(1)。

public List<Integer> preorderTraversal(TreeNode root) {
         List<Integer> res=new ArrayList<>();
         if(root==null) return res;
         TreeNode p=root;
         while(p!=null)
         {
             if(p.right!=null&&p.left!=null)
             {
                 TreeNode pre=p.left;
                 while(pre.right!=null) pre=pre.right;
                 pre.right=p.right;
             }
             res.add(p.val);
             if(p.left!=null) p=p.left;
             else p=p.right;
         }
         return res;
    }

4.寻找两个正序数组中的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000

用两个指针分别指向两个数组，每次比较中，指向元素更小的指针向右移动，计数加一。时间O(m+n)
二分查找，比较难想到，而且边界控制条件比较恶心，没写出来。大体思路如下：

要找到两个数组中第k个元素，可以比较A[left1+k/2-1]和B[left2+k/2-1]，前面分别有A[left1…left1+k/2-2]和A[left2…left2+k/2-2]，即k/2-1个元素，假设A[left1+k/2-1]为两者中的较小值，则比A[left1+k/2-1]小的元素最多只有A和B的前k/2-1个元素，即最多总共只有k-2个元素，因此A[left1+k/2-1]不可能是第k个元素，A[left1]到A[left1+k/2-2]也不可能是，全都可以排除，更新左节点left1=left1+k/2，并且令k值减去排除掉的数目。k为0时找到的元素即为所求。时间O(log(m+n))。

今日总结

刷题