双指针可以应用到数组、链表，是一种 思考方法，使用快慢指针，分别以不同的形式进行遍历，最后得到题目要求的结果。
1、移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
思路：使用快、慢双指针进行遍历，快指针从头到尾遍历，慢指针只记录不等于val的值，最终slowIndex的大小就是所求数组大小
public int removeElement(int[] nums, int val) {
int slowIndex = 0;
//使用快、慢双指针进行遍历，快指针从头到尾遍历，慢指针只记录不等于val的值，最终slowIndex的大小就是所求数组大小
for (int fastIndex = 0; fastIndex < nums.length; fastIndex ++) {
if (nums[fastIndex] != val) {
nums[slowIndex ++] = nums[fastIndex];
}
}
return slowIndex;
}
2、反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 ：
输入：s = [“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]
思路：用两个指针i j进行遍历，i从头开始，j从尾开始，遍历时交换两指针的值，直到遍历到链表中间即完成
代码：
public void reverseString(char[] s) {
//用两个指针i j进行遍历，i从头开始，j从尾开始，遍历时交换两指针的值，直到遍历到链表中间即完成
for (int i = 0, j = s.length - 1; i < s.length / 2; i ++, j --) {
char temp = s[i];
s[i] = s[j];
s[j] = temp;
}
}
3、替换空格
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1：
输入：s = “We are happy.”
输出：“We%20are%20happy.”
思路1：将字符串转成字符数组进行操作
public String replaceSpace(String s) {
//遍历寻找空格，每次替换从一个字符变成3个，创建一个字符数组用于替换操作，因为String是不可变的
int count = 0;//求空格数量
for (int i = 0; i < s.length(); i ++) {
if (s.charAt(i) == ' ') {
count ++;
}
}
//新建一个字符数组
count = 0;
char[] arr = new char[s.length() * 3];
for (int i = 0; i < s.length(); i ++) {
char c = s.charAt(i);
if (c == ' ') {
arr[count ++] = '%';
arr[count ++] = '2';
arr[count ++] = '0';
} else {
arr[count ++] = c;
}
}
//将字符数组转回字符串
String newS = new String(arr, 0, count);
return newS;
}
思路2：使用双指针，首先将字符串进行扩容，为替换后的长度，再用双指针从尾部开始遍历替换，一个指向原始字符串，一个指向新字符串
public String replaceSpace(String s) {
if(s == null || s.length() == 0){
return s;
}
//扩充空间，空格数量2倍
StringBuilder str = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if(s.charAt(i) == ' '){
str.append(" ");
}
}
//若是没有空格直接返回
if(str.length() == 0){
return s;
}
//有空格情况 定义两个指针
int left = s.length() - 1;//左指针：指向原始字符串最后一个位置
s += str.toString();
int right = s.length()-1;//右指针：指向扩展字符串的最后一个位置
char[] chars = s.toCharArray();
while(left>=0){
if(chars[left] == ' '){
chars[right--] = '0';
chars[right--] = '2';
chars[right] = '%';
}else{
chars[right] = chars[left];
}
left--;
right--;
}
return new String(chars);
4、颠倒字符串中的单词
151. 颠倒字符串中的单词
给你一个字符串 s ，颠倒字符串中 单词 的顺序。单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
示例 1：
输入：s = "the sky is blue"
输出："blue is sky the"
示例 2：
输入：s = " hello world "
输出："world hello"
解释：颠倒后的字符串中不能存在前导空格和尾随空格。
示例 3：
输入：s = "a good example"
输出："example good a"
解释：如果两个单词间有多余的空格，颠倒后的字符串需要将单词间的空格减少到仅有一个。
思路：
1、移除多余空格
2、将整个字符串反转
3、将每个单词反转
- 源字符串为："the sky is blue "
- 移除多余空格 : “the sky is blue”
- 字符串反转：“eulb si yks eht”
- 单词反转：“blue is sky the”
public String reverseWords(String s) {
//1.去除多余字符串
StringBuilder sb = removeExtraSpaces(s);
//2.反转整个字符串
reverseString(sb, 0, sb.length() - 1);
//3.反转每个单词
reverseEachWord(sb);
return sb.toString();
}
/**
* 1.利用双指针去除多余的空格
*/
StringBuilder removeExtraSpaces(String s) {
int start = 0, end = s.length() - 1;
//去除首部空格
while (s.charAt(start) == ' ') {
start ++;
}
//去除尾部空格
while (s.charAt(end) == ' ') {
end --;
}
//去除中间部分多余空格
StringBuilder sb = new StringBuilder();
while (start <= end) {
char c = s.charAt(start);
if (c != ' ' || sb.charAt(sb.length() - 1) != ' ') {
sb.append(c);
}
start ++;
}
return sb;
}
/**
* 2.反转字符串
*/
void reverseString(StringBuilder sb, int start, int end) {
while (start < end) {
char temp = sb.charAt(start);
sb.setCharAt(start, sb.charAt(end));
sb.setCharAt(end, temp);
start++;
end--;
}
}
/**
* 3.
*/
void reverseEachWord(StringBuilder sb) {
int start = 0, end = 1, len = sb.length();
while (start < len) {
while (end < len && sb.charAt(end) != ' ') {
end ++;
}
reverseString(sb, start, end - 1);
start = end + 1;
end = start + 1;
}
}
5、链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
思路：定义快慢指针，快指针先走k步，慢指针才和快指针一起走，当快指针走到尾为空时，慢指针所指的节点就是倒数第k个节点
public ListNode getKthFromEnd(ListNode head, int k) {
ListNode fast = head, slow = head;
while (k-- > 0) {
fast = fast.next;
}
while (fast != null) {
fast = fast.next;
slow = slow.next;
}
return slow;
}
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
6、链表的中间结点
给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
思路：定义快慢指针，快指针一次走两步，慢指针一次走一步，当快指针走到尾，慢指针刚好到中间
public ListNode middleNode(ListNode head) {
ListNode fast = head, slow = head;
while (fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
}
return slow;
}
7、环形链表
给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。
思路：定义快慢指针，同时遍历，快指针一次走两步，慢指针一次走一步，如果存在环，两指针会相遇
public boolean hasCycle(ListNode head) {
//初始条件判断
if (head == null || head.next == null) {
return false;
}
ListNode fast = head.next, slow = head;
while (fast != slow) {
if (fast == null || fast.next == null) {
return false;
}
fast = fast.next.next;
slow = slow.next;
}
return true;
}
未完待续…
390
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
