左神算法底子巩固--2

---

稳固性

稳固性是指算法在排序过程中保持相等元素之间相对次序的特性。具体来说，如果一个排序算法是稳固的，那么对于恣意两个相等的元素，在排序前它们的相对次序与排序后它们的相对次序是相同的。
稳固性对于常见进行数字排序的情况没有意义但对于复杂范例的排序来说是一个特别重要的一件事。
举例说明：我们对于一个班级的全部学生先按照年事进行排序，再按照结果进行排序，如果排序算法具有稳固性的话便会得到一个如果结果相同则年事较小的会排在前面的对象数组。这就是算法稳固性的运用。

---

前文我们提到的那几种排序算法中并不是全部的算法都具有稳固性的
选择排序

选择选择排序是不具有稳固性的，根据选择排序的算法思路来说，选择排序会先在数组中找到小值并将其与对应位置的数进行交换，故如果出现以下这种情况，那么其就不具有稳固性

冒泡排序

冒泡排序是否具有稳固性得看你在什么时间交换位置，如果相等你不交换二者的位置，那么冒泡排序便是具有稳固性的。以以下数组为例
由冒泡排序的算法头脑得在第一次遍历后0位置上的6会在5位置上只要原0位置上的数不与5位置上的6交换则此时算法是具有稳固性的

插入排序

插入排序和冒泡排序雷同，只要我们设定正确的在两数相同的情况下不交换两数的位置，那么此时该算法就是具有稳固性的以以下数组为例

该数组在0-0范围内是有序的，在0-1范围内需要交换位置，交换后数组为2 3 2 … ，在0-2范围内由于2位置上的数与0位置上的数相同只要我们不交换二者的位置，此时该算法具有稳固性
归并排序

归并排序的稳固性取决于其merge的实现，只要我们在merge的时间实现两数相等时先拷贝左侧的数便能实现稳固性
以以下数组为例

在这个数组中1与1相等，只要我们在将数组整理时，先拷贝左侧的1便能实现该算法的稳固性
快速排序

快速排序则是做不到稳固性的，重要原因在于快速排序的partition过程，在partition过程中会将从前今后的第一个小于基准值的数与左界限后的第一个数交换位置，这一步调便破坏了稳固性。
以以下数组为例

在该数组中找到第一个小于基准数的数为3此时他要与左界限后的第一个数6交换位置此时便破坏了稳固性。
堆排序

堆排序也做不到稳固性，堆排序是以维护自身的堆结构来实现排序的，因此其在筹划之初便完全没有思量稳固性
以以下数组为例

在加入这个6后堆排序会去维持其堆结构即将6挂载在第一个4的后面并进行比力由于6比4大，所以6会与第一个4交换位置，此时便破坏了稳固性
下面是算法稳固性的总结

一些常见的坑

注意：这些算法并不是相互分离不可结合的，以选择排序和快速排序为例，虽然选择排序的时间复杂度为n^2快速排序的时间复杂度为nlogn 但是在n比力小的情况下，其实选择排序的所需时间是比快速排序要少的，因此可以进行判断如果n较小便使用选择排序，如果n较大便使用快速排序。

哈希表

常用的操纵

链表

解题

笔试思路：先用快慢指针遍历这个链表得到链表的前半部门和后半部门，将这个链表的前半部门加入到一个栈中，在加入后，遍历后半个链表，每遍历一个都与使栈弹出的数进行比力如果两数相等便接着比力，如果栈或链表为空了则说明该链表是回文结构，如果出现不相等的情况则说明该链表不是回文结构。

1. import java.util.Stack;
3. class ListNode {
4.     int val;
5.     ListNode next;
6.     ListNode(int x) { val = x; }
7. }
9. public class Solution {
10.     public boolean isPalindrome(ListNode head) {
11.         if (head == null || head.next == null) {
12.             return true;
13.         }
15.         // 使用快慢指针找到中间节点
16.         ListNode slow = head;
17.         ListNode fast = head;
18.         while (fast != null && fast.next != null) {
19.             slow = slow.next;
20.             fast = fast.next.next;
21.         }
23.         // 将前半部分链表的节点值压入栈中
24.         Stack<Integer> stack = new Stack<>();
25.         ListNode temp = head;
26.         while (temp != slow) {
27.             stack.push(temp.val);
28.             temp = temp.next;
29.         }
31.         // 如果链表长度为奇数，跳过中间节点
32.         if (fast != null) {
33.             slow = slow.next;
34.         }
36.         // 比较后半部分链表的节点值与栈中的值
37.         while (slow != null) {
38.             if (slow.val != stack.pop()) {
39.                 return false;
40.             }
41.             slow = slow.next;
42.         }
44.         return true;
45.     }
47.     public static void main(String[] args) {
48.         Solution solution = new Solution();
49.         ListNode head = new ListNode(1);
50.         head.next = new ListNode(2);
51.         head.next.next = new ListNode(2);
52.         head.next.next.next = new ListNode(1);
54.         boolean isPalindrome = solution.isPalindrome(head);
55.         System.out.println("链表是否为回文结构: " + isPalindrome);
56.     }
57. }

复制代码

面试思路： 先用快慢指针，使当快指针走到尽头时，慢指针指向中点位置，然后将链表的后半部门反转，并使前半部门和后半部门均向中点靠拢并比力，如果两数相等便接着比力，直到遍历前半部门的指针和遍历后半部门的指针指向中点，就先将后半部门复原后返回true，如果不等就复原后返回false

1. class ListNode {
2.     int val;
3.     ListNode next;
4.     ListNode(int x) { val = x; }
5. }
7. public class Solution {
8.     public boolean isPalindrome(ListNode head) {
9.         if (head == null || head.next == null) {
10.             return true;
11.         }
13.         // 使用快慢指针找到中间节点
14.         ListNode slow = head;
15.         ListNode fast = head;
16.         while (fast != null && fast.next != null) {
17.             slow = slow.next;
18.             fast = fast.next.next;
19.         }
21.         // 反转链表的后半部分
22.         ListNode prev = null;
23.         ListNode curr = slow;
24.         while (curr != null) {
25.             ListNode nextTemp = curr.next;
26.             curr.next = prev;
27.             prev = curr;
28.             curr = nextTemp;
29.         }
31.         // 比较前半部分和反转后的后半部分
32.         ListNode left = head;
33.         ListNode right = prev;
34.         boolean isPalindrome = true;
35.         while (right != null) {
36.             if (left.val != right.val) {
37.                 isPalindrome = false;
38.                 break;
39.             }
40.             left = left.next;
41.             right = right.next;
42.         }
44.         // 恢复链表的后半部分
45.         curr = prev;
46.         prev = null;
47.         while (curr != null) {
48.             ListNode nextTemp = curr.next;
49.             curr.next = prev;
50.             prev = curr;
51.             curr = nextTemp;
52.         }
54.         return isPalindrome;
55.     }
57.     public static void main(String[] args) {
58.         Solution solution = new Solution();
59.         ListNode head = new ListNode(1);
60.         head.next = new ListNode(2);
61.         head.next.next = new ListNode(2);
62.         head.next.next.next = new ListNode(1);
64.         boolean isPalindrome = solution.isPalindrome(head);
65.         System.out.println("链表是否为回文结构: " + isPalindrome);
66.     }
67. }

复制代码

笔试思路：遍历链表，将链表的值加入到数组中，对数组进行partition，之后再将用得到的数组构建出一个链表。

1. class ListNode {
2.     int val;
3.     ListNode next;
4.     ListNode(int x) { val = x; }
5. }
7. public class Solution {
8.     public ListNode partition(ListNode head, int pivot) {
9.         if (head == null) return null;
11.         // 初始化三个指针，分别指向小于、等于、大于pivot的链表头部
12.         ListNode beforeSmaller = new ListNode(0);
13.         ListNode beforeEqual = new ListNode(0);
14.         ListNode beforeGreater = new ListNode(0);
16.         // 当前节点
17.         ListNode current = head;
18.         // 尾指针
19.         ListNode tailSmaller = beforeSmaller;
20.         ListNode tailEqual = beforeEqual;
21.         ListNode tailGreater = beforeGreater;
23.         while (current != null) {
24.             if (current.val < pivot) {
25.                 tailSmaller.next = current;
26.                 tailSmaller = tailSmaller.next;
27.             } else if (current.val == pivot) {
28.                 tailEqual.next = current;
29.                 tailEqual = tailEqual.next;
30.             } else {
31.                 tailGreater.next = current;
32.                 tailGreater = tailGreater.next;
33.             }
34.             current = current.next;
35.         }
37.         // 连接三个链表
38.         tailSmaller.next = beforeEqual.next;
39.         tailEqual.next = beforeGreater.next;
40.         tailGreater.next = null;
42.         // 返回新链表的头节点
43.         return beforeSmaller.next;
44.     }
46.     public static void main(String[] args) {
47.         Solution solution = new Solution();
48.         ListNode head = new ListNode(4);
49.         head.next = new ListNode(3);
50.         head.next.next = new ListNode(2);
51.         head.next.next.next = new ListNode(-1);
52.         head.next.next.next.next = new ListNode(2);
53.         head.next.next.next.next.next = new ListNode(3);
54.         head.next.next.next.next.next.next = new ListNode(5);
56.         int pivot = 2;
57.         ListNode newHead = solution.partition(head, pivot);
59.         // 打印结果，用于验证
60.         while (newHead != null) {
61.             System.out.print(newHead.val + " ");
62.             newHead = newHead.next;
63.         }
64.     }
65. }

复制代码

面试思路：遍历这个链表并根据他们的情况将链表节点加入到新建的三个链表中，遍历完成后，对链表进行拼接便能得到完整的解

1. class ListNode {
2.     int val;
3.     ListNode next;
4.     ListNode(int x) { val = x; }
5. }
7. public class Solution {
8.     public ListNode partition(ListNode head, int pivot) {
9.         // 虚拟头节点，方便操作
10.         ListNode dummyBeforeSmaller = new ListNode(0);
11.         ListNode dummyBeforeEqual = new ListNode(0);
12.         ListNode dummyBeforeGreater = new ListNode(0);
13.         
14.         ListNode smaller = dummyBeforeSmaller;
15.         ListNode equal = dummyBeforeEqual;
16.         ListNode greater = dummyBeforeGreater;
17.         
18.         while (head != null) {
19.             if (head.val < pivot) {
20.                 smaller.next = head;
21.                 smaller = smaller.next;
22.             } else if (head.val == pivot) {
23.                 equal.next = head;
24.                 equal = equal.next;
25.             } else {
26.                 greater.next = head;
27.                 greater = greater.next;
28.             }
29.             head = head.next;
30.         }
31.         
32.         // 连接三个链表
33.         smaller.next = dummyBeforeEqual.next;
34.         equal.next = dummyBeforeGreater.next;
35.         greater.next = null;
36.         
37.         return dummyBeforeSmaller.next;
38.     }
40.     public static void main(String[] args) {
41.         Solution solution = new Solution();
42.         ListNode head = new ListNode(4);
43.         head.next = new ListNode(3);
44.         head.next.next = new ListNode(2);
45.         head.next.next.next = new ListNode(-1);
46.         head.next.next.next.next = new ListNode(2);
47.         head.next.next.next.next.next = new ListNode(3);
48.         head.next.next.next.next.next.next = new ListNode(5);
49.         
50.         int pivot = 2;
51.         ListNode newHead = solution.partition(head, pivot);
52.         
53.         // 打印结果，用于验证
54.         while (newHead != null) {
55.             System.out.print(newHead.val + " ");
56.             newHead = newHead.next;
57.         }
58.     }
59. }

复制代码

笔试思路：使用hash表将原节点与原节点对应的克隆节点加入到hash表中，其中hash表的key为原节点，value为克隆节点，之后再从原链表中找到对应的next指针对应的节点，将其从hash表中找到对应的克隆节点并赋值给源节点对应克隆节点的next指针，rand指针也是一样不停重复直到全部节点都判断过

1. class Node {
2.     int value;
3.     Node next;
4.     Node rand;
5.     Node(int val) {
6.         value = val;
7.         next = null;
8.         rand = null;
9.     }
10. }
12. public class Solution {
13.     public Node copyRandomList(Node head) {
14.         if (head == null) return null;
16.         // Step 1: 创建哈希表存储原始节点和克隆节点的映射
17.         Map<Node, Node> map = new HashMap<>();
19.         // Step 2: 遍历原始链表，克隆每个节点并存储在哈希表中
20.         Node current = head;
21.         while (current != null) {
22.             map.put(current, new Node(current.value));
23.             current = current.next;
24.         }
26.         // Step 3: 复制next和rand指针
27.         current = head;
28.         while (current != null) {
29.             Node clone = map.get(current);
30.             clone.next = map.getOrDefault(current.next, null);
31.             clone.rand = map.getOrDefault(current.rand, null);
32.             current = current.next;
33.         }
35.         // Step 4: 返回新链表的头节点
36.         return map.get(head);
37.     }
38. }

复制代码

面试头脑：首先在原链表上克隆每个节点并使原节点的的next指针指向克隆节点，克隆节点的next指针指向原节点的next指针所指节点，之后再遍历原链表节点的next指针和rand指针并在克隆节点上对应指向

1. class Node {
2.     int value;
3.     Node next;
4.     Node rand;
5.     Node(int val) {
6.         value = val;
7.         next = null;
8.         rand = null;
9.     }
10. }
12. public class Solution {
13.     public Node copyRandomList(Node head) {
14.         if (head == null) return null;
16.         // 第一步：克隆节点并建立连接
17.         Node current = head;
18.         while (current != null) {
19.             Node clone = new Node(current.value);
20.             clone.next = current.next;
21.             current.next = clone;
22.             current = clone.next;
23.         }
25.         // 第二步：复制 rand 指针
26.         current = head;
27.         while (current != null) {
28.             Node clone = current.next;
29.             if (current.rand != null) {
30.                 clone.rand = current.rand.next;
31.             }
32.             current = clone.next;
33.         }
35.         // 第三步：分离链表并返回新链表的头节点
36.         Node newHead = head.next; // 新链表的头节点是原链表第一个节点的克隆节点
37.         current = head;
38.         while (current != null) {
39.             Node clone = current.next;
40.             current.next = clone.next; // 断开原始节点和克隆节点的连接
41.             if (clone.next != null) {
42.                 clone.next = clone.next.next; // 跳过原始节点，连接到下一个克隆节点
43.             }
44.             current = current.next;
45.         }
47.         return newHead;
48.     }
49. }

复制代码

这道题需要直到环中快慢指针的问题，需要明确的是用两个指针其中快指针一次走两步，慢指针一次走一步遍历这个链表当这个链表存在环时，他两一定在环上相遇，同时再将快指针指向第一个节点，再次同时出发，他两一定在入环处相遇。
这道题要分为几种情况进行讨论：
1.两个链表不相交且无环

在这种情况下，我们先用快慢指针知道是否有环后，遍历这两个链表，并记载下每个链表的末了的节点和这个数组的长度，当这两个链表不相交且无环时，这两个链表所对应的末了的节点是不同的。
2.无环但相交

这种情况的判定方法，第一种情况雷同我们先用快慢指针知道是否有环后，遍历这两个链表，并记载下每个链表的末了的节点和这两个链表的长度，并作差值n，当这两个链表相交但无环时，这两个链表所对应的末了的节点是相同的，同时记载下较长的链表让用指针指向其头部并先走n步，之后用指针指向另一链表的头部，两者同时走，两指针相等时便是两指针的相交节点。
之后便是有环结构了，这种情况需要同一分析

这三种情况的判定条件是入环节点loop1和loop2均不为空判断loop1是否等于loop2，如果相等则为情况2，否则让loop1继续往下走，如果loop1每遇见loop2就是第一种情况，如果遇见了就是情况3。
遇到情况1便可直接返回null,遇到情况二则与前面的无环链表相交范例，但以loop1为链表末了一个节点，遇到情况三则返回loop1或loop2

---

总结

提示：这里对文章进行总结：
比方：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处置惩罚数据的函数和方法。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。