Leetcode的AC指南 —— 链表：707. 设计链表
摘要：
Leetcode的AC指南 —— 链表：707. 设计链表。题目介绍：你可以选择使用单链表或者双链表，设计并实现自己的链表。单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
文章目录
- 一、题目
- 二、解析
- 1、单链表
- 2、双链表
- 三、总结
一、题目
题目介绍：
你可以选择使用单链表或者双链表，设计并实现自己的链表。
单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList 类：
- MyLinkedList() 初始化 MyLinkedList 对象。
- int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
- void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
- void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
- void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
- void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。
力扣题目链接
示例 1:
输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]
解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2); // 链表变为 1->2->3
myLinkedList.get(1); // 返回 2
myLinkedList.deleteAtIndex(1); // 现在，链表变为 1->3
myLinkedList.get(1); // 返回 3
提示：
0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。
二、解析
这道题目设计链表的五个接口：
获取链表第index个节点的数值
在链表的最前面插入一个节点
在链表的最后面插入一个节点
在链表第index个节点前面插入一个节点
删除链表的第index个节点
可以说这五个接口，已经覆盖了链表的常见操作，是练习链表操作非常好的一道题目
1、单链表
设置一个虚拟头节点在进行操作。
public class SingleLink {
int size;
ListNode head;
public SingleLink(){
size = 0;
head = new ListNode(-1);
}
//获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
public int get(int index){
if(index < 0 || index >= size) return -1;
ListNode cur = head;
//包含一个虚拟头节点，所以查找第 index+1 个节点
for(int i = 0; i <= index; i++){
cur = cur.next;
}
return cur.val;
}
// 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度，则返回空
public void addAtIndex(int index, int val){
if(index > size) return;
if(index < 0) index = 0;
size++;
//找到要插入节点的前驱
ListNode pre = head;
for (int i = 0; i < index; i++){
pre = pre.next;
}
ListNode node = new ListNode(val);
node.next = pre.next;
pre.next = node;
}
//在链表最前面插入一个节点，等价于在第0个元素前添加
public void addAtHead(int val) {
addAtIndex(0, val);
}
//在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
public void addAtTail(int val) {
addAtIndex(size, val);
}
//删除第index个节点
public void deleteAtIndex(int index) {
if (index < 0 || index >= size) {
return;
}
size--;
if (index == 0) {
head = head.next;
return;
}
ListNode pred = head;
for (int i = 0; i < index ; i++) {
pred = pred.next;
}
pred.next = pred.next.next;
}
// 用数组初始化链表
public SingleLink Init_SingleLink(int[] nums){
for(int i = nums.length - 1; i >= 0; i--){
ListNode node = new ListNode(nums[i]);
node.next = this.head.next;
this.head.next = node;
}
this.size = nums.length;
return this;
}
// 输出链表的值
public void show_linked_list(){
ListNode p = this.head;
for(int i = 0; i < size; i++){
System.out.print(p.next.val);
p = p.next;
}
System.out.println(" ");
}
}
2、双链表
//双链表
class ListNode{
int val;
ListNode next,prev;
ListNode() {};
ListNode(int val){
this.val = val;
}
}
class MyLinkedList {
//记录链表中元素的数量
int size;
//记录链表的虚拟头结点和尾结点
ListNode head,tail;
public MyLinkedList() {
//初始化操作
this.size = 0;
this.head = new ListNode(0);
this.tail = new ListNode(0);
//这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
head.next=tail;
tail.prev=head;
}
public int get(int index) {
//判断index是否有效
if(index<0 || index>=size){
return -1;
}
ListNode cur = this.head;
//判断是哪一边遍历时间更短
if(index >= size / 2){
//tail开始
cur = tail;
for(int i=0; i< size-index; i++){
cur = cur.prev;
}
}else{
for(int i=0; i<= index; i++){
cur = cur.next;
}
}
return cur.val;
}
public void addAtHead(int val) {
//等价于在第0个元素前添加
addAtIndex(0,val);
}
public void addAtTail(int val) {
//等价于在最后一个元素(null)前添加
addAtIndex(size,val);
}
public void addAtIndex(int index, int val) {
//index大于链表长度
if(index>size){
return;
}
//index小于0
if(index<0){
index = 0;
}
size++;
//找到前驱
ListNode pre = this.head;
for(int i=0; i<index; i++){
pre = pre.next;
}
//新建结点
ListNode newNode = new ListNode(val);
newNode.next = pre.next;
pre.next.prev = newNode;
newNode.prev = pre;
pre.next = newNode;
}
public void deleteAtIndex(int index) {
//判断索引是否有效
if(index<0 || index>=size){
return;
}
//删除操作
size--;
ListNode pre = this.head;
for(int i=0; i<index; i++){
pre = pre.next;
}
pre.next.next.prev = pre;
pre.next = pre.next.next;
}
}
/**
* Your MyLinkedList object will be instantiated and called as such:
* MyLinkedList obj = new MyLinkedList();
* int param_1 = obj.get(index);
* obj.addAtHead(val);
* obj.addAtTail(val);
* obj.addAtIndex(index,val);
* obj.deleteAtIndex(index);
*/
三、总结
我的代码：
-
单链表实现
- 直接使用原来的链表来进行操作
public class SingleLink { int size; ListNode head; public SingleLink() { // MyLinkedList() 初始化 MyLinkedList 对象。 } public SingleLink(int size, ListNode head) { this.size = size; this.head = head; } // 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。 public int get(int index) { ListNode cur = this.head; while (cur != null && index >= 0){ if(index == 0) return cur.val; cur = cur.next; --index; } return -1; } // 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。 public void addAtHead(int val) { ListNode node = new ListNode(val); node.next = this.head; this.head = node; } // 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。 public void addAtTail(int val) { ListNode node = new ListNode(val); if (head == null){ head = node; } else { ListNode cur = head; while(cur.next != null){ cur = cur.next; } cur.next = node; } } // 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。 // 如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。 // 如果 index 比长度更大，该节点将 不会插入 到链表中。 public void addAtIndex(int index, int val) { if(index == 0) { addAtHead(val); } else { if(this.head != null) { ListNode cur = this.head; while (index > 1 && cur.next != null) { cur = cur.next; --index; } if (index == 1) { ListNode node = new ListNode(val); node.next = cur.next; cur.next = node; } } } } // 如果下标有效，则删除链表中下标为 index 的节点。 public void deleteAtIndex(int index) { if(this.head != null){ if(index == 0){ this.head = this.head.next; } else { ListNode cur = this.head; while (index > 1 && cur.next != null){ --index; cur = cur.next; } if(index == 1 && cur.next != null){ cur.next = cur.next.next; } } } } // 用数组初始化链表 public SingleLink Init_SingleLink(int[] nums){ ListNode head= new ListNode(-1); this.head = head; for(int i = nums.length - 1; i >= 0; i--){ ListNode node = new ListNode(nums[i]); node.next = this.head.next; this.head.next = node; } this.size = nums.length; this.head = this.head.next; return this; } // 输出链表的值 public void show_linked_list(){ ListNode p; p = this.head; while(p != null){ System.out.print(p.val); p = p.next; } System.out.println(" "); } } -
双链表实现
public class ListNode {
int val;
ListNode next, prev;
public ListNode() {
}
public ListNode(int val) {
this.val = val;
this.next = null;
this.prev = null;
}
}
public class DoubleLink {
int size;
ListNode head, tail;
public DoubleLink(){
this.size = 0;
this.head = new ListNode(-1);
this.tail = new ListNode(-1);
head.next = tail;
tail.prev = head;
}
//获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
public int get(int index){
if(index < 0 || index >= size) return -1;
ListNode cur = head;
for(int i = 0; i <= index; i++){
cur = cur.next;
}
return cur.val;
}
void addAtHead(int val){
addAtIndex(0, val);
}
void addAtTail(int val){
addAtIndex(size, val);
}
void deleteAtIndex(int index){
if(index < 0 || index >= size) return;
size--;
ListNode pre = head;
for (int i = 0; i < index; i++){
pre = pre.next;
}
pre.next = pre.next.next;
pre.next.prev = pre;
}
// 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度，则返回空
public void addAtIndex(int index, int val){
if(index > size) return;
if(index < 0) index = 0;
size++;
ListNode pre = this.head;
for(int i = 0; i < index; i++){
pre = pre.next;
}
ListNode node = new ListNode(val);
node.next = pre.next;
node.prev = pre;
pre.next.prev = node;
pre.next = node;
}
public void Init_DoubleLink(int[] nums){
size = nums.length;
for(int j = nums.length - 1; j >= 0; j--){
ListNode node = new ListNode(nums[j]);
node.next = head.next;
head.next.prev = node;
head.next = node;
node.prev = head;
}
}
public void show_head(){
if(head == null) return;
ListNode cur = head.next;
for(int i = 0; i < size; i++){
System.out.print(cur.val);
cur = cur.next;
}
System.out.println(" ");
}
public void show_tail(){
if(tail == null) return;
ListNode cur = tail.prev;
for(int i = 0; i < size; i++){
System.out.print(cur.val);
cur = cur.prev;
}
System.out.println(" ");
}
}