算法练习LeetCode初级算法之链表
-
删除链表中的节点
|
/** |
|
* Definition for singly-linked list. |
|
* public class ListNode { |
|
* int val; |
|
* ListNode next; |
|
* ListNode(int x) { val = x; } |
|
* } |
|
*/ |
|
class Solution { |
|
public void deleteNode(ListNode node) { |
|
node.val=node.next.val; |
|
node.next=node.next.next; |
|
} |
|
} |
-
删除链表的倒数第N个节点
-
两次遍历算法
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode dummy=new ListNode(0);
dummy.next=head;
int length=0;
ListNode p=head;
while (p!=null) {
length++;
p=p.next;
}
ListNode first=dummy;
length-=n;
while (length>0) {
length--;
first=first.next;
}
first.next=first.next.next;
return dummy.next;
}
}
-
一次遍历算法
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode first = dummy;
ListNode second = dummy;
// Advances first pointer so that the gap between first and second is n nodes apart
for (int i = 1; i <= n + 1; i++) {
first = first.next;
}
// Move first to the end, maintaining the gap
while (first != null) {
first = first.next;
second = second.next;
}
second.next = second.next.next;
return dummy.next;
}
}
-
反转链表
-
我的解法：利用Linklist比较好理解，有点投机取巧，面试不一定可以得吧！！！哈哈哈，但是测试通过了
class Solution {
public ListNode reverseList(ListNode head) {
LinkedList<Integer> list=new LinkedList<>();
for(ListNode x=head;x!=null;x=x.next) {
list.add(x.val);
}
for(ListNode x=head;x!=null;x=x.next) {
x.val=list.removeLast();
}
return head;
}
}
-
迭代法，一开始不好理解，仔细琢磨后还是很好理解的
class Solution {
public ListNode reverseList(ListNode head) {
if (head==null||head.next==null) {
return head;
}
ListNode newHead=null;
while (head!=null) {
ListNode temp=head.next;//先把后面的数据储存到temp
head.next=newHead;//把head添加到newHead
newHead=head;//把head添加到newHead，newHead重新作为新的头指针
head=temp;//让头指针指向下一个数据，已保存在temp里
}
return newHead;
}
}
-
递归法，仔细研究后还是可以理解的
class Solution {
public ListNode reverseList(ListNode head) {
return newHead(head);
}
public ListNode newHead(ListNode head) {
if (head==null||head.next==null) {
return head;
}
ListNode newHead=newHead(head.next);
head.next.next=head;//反转链表，把把下一个数连接到newHead上
head.next=null;//指向空，防止再次递归导致覆盖后面的内容。
return newHead;
}
}
以上两种方法，通过从网站学习理解，必须站在巨人的肩膀上，哈哈哈！
注明学习网址：https://blog.csdn.net/fx677588/article/details/72357389，虽然不是转载，但有借鉴。
-
合并两个有序链表
-
我的解法：很好实现，思路简单，但耗时长一点
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
LinkedList<Integer> list=new LinkedList<>();
for(ListNode x=l1;x!=null;x=x.next)
{
list.add(x.val);
}
for(ListNode x=l2;x!=null;x=x.next) {
list.add(x.val);
}
Collections.sort(list);
ListNode head=null;
for (int i = list.size()-1; i>=0; i--) {
ListNode n=new ListNode(list.get(i));
n.next=head;
head=n;
}
return head;
}
}
-
大神一解法，递归解法，代码简洁
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode rspHead=new ListNode(0);
ListNode rsp=rspHead;
while(l1!=null && l2!=null){
if(l1.val<l2.val){
rspHead.next=l1;
rspHead=rspHead.next;
l1=l1.next;
}else{
rspHead.next=l2;
rspHead=rspHead.next;
l2=l2.next;
}
}
if(l1==null){
rspHead.next=l2;
}else{
rspHead.next=l1;
}
return rsp.next;
}
}
-
大神二解法，利用双指针，现将带头链表头指针用rsp保存，最后返回rsp.next
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode rspHead=new ListNode(0);
ListNode rsp=rspHead;
while(l1!=null && l2!=null){
if(l1.val<l2.val){
rspHead.next=l1;
rspHead=rspHead.next;
l1=l1.next;
}else{
rspHead.next=l2;
rspHead=rspHead.next;
l2=l2.next;
}
}
if(l1==null){
rspHead.next=l2;
}else{
rspHead.next=l1;
}
return rsp.next;
}
}
-
回文链表
-
我的解法：感觉已经脱离了链表，不行，不好，时间太长！
class Solution {
public boolean isPalindrome(ListNode head) {
if (head==null||head.next==null) {
return true;
}
LinkedList<Integer> list=new LinkedList<>();
for(ListNode x=head;x!=null;x=x.next) {
list.add(x.val);
}
for (int i = 0; i < list.size()/2; i++) {
if (list.get(i).compareTo(list.get(list.size()-i-1))!=0){
return false;
}
}
return true;
}
}
-
大神解法：挺好！先找链表中点，然后再反转后半部分，最后再分别遍历比较，直到后半部分遍历完！
class Solution {
ListNode node1=new ListNode(0);
ListNode node2=new ListNode(0);
public boolean isPalindrome(ListNode head) {
if (head==null||head.next==null) {
return true;
}
ListNode slow=head;
ListNode fast=head;
while (fast.next!=null&&fast.next.next!=null) {
fast=fast.next.next;
slow=slow.next;
}
slow=reverse(slow.next);//此处如果是show的话，将从中点的前一个匹配,比较难理解，后面附图说明
while (slow!=null) {
if (head.val!=slow.val) {//到这里，head短的话会成为空指针而报错！！！
return false;
}
head=head.next;
slow=slow.next;
}
return true;
}
private ListNode reverse(ListNode head) {
if (head==null||head.next==null) {
return head;
}
ListNode newHead=reverse(head.next);
head.next.next=head;
head.next=null;
return newHead;
}
}
说明：如果测试样例输入0,0的话，黄色标记为什么会报错！
-
环形链表
-
我的解法：利用hashset
class Solution {
public boolean hasCycle(ListNode head) {
if (head==null||head.next==null) {
return false;
}
Set<ListNode> set=new HashSet<>();
int n=0;
ListNode x=head;
while (set.size()>=n) {
set.add(x);
x=x.next;
n++;
if (x==null) {
return false;
}
}
return true;
}
}
-
大神解法：
class Solution {
public boolean hasCycle(ListNode head) {
if (head==null) {
return false;
}
ListNode l1=head,l2=head.next;
while (l1!=null&&l2!=null&&l2.next!=null) {
l1=l1.next;
l2=l2.next.next;
if (l1==l2) {
return true;
}
}
return false;
}
}
-
递归解法，更为简洁
class Solution {
public boolean hasCycle(ListNode head) {
if(head==null||head.next==null)return false;
if(head.next==head)return true;
ListNode l=head.next;
head.next=head;
boolean isCycle=hasCycle(l);
return isCycle;
}
}
