单链表
概述
-
采用链式存储方法的线性表叫做链表
-
链表通常由一连串节点组成,每个节点包含任意的实例数据(data fields)和一或两个用来指向上一个/或下一个节点的位置的链接(“links”) (data 和 指针)
-
链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)
性质:
- 其节点的存储单元可以不连续,每个节点中除存储原表结点中的数据外,还须存储上一个/下一个节点的地址,以反映节点之间的逻辑关系
- 获取数据麻烦,需要遍历查找,比数组慢
- 方便插入、删除
实现原理
① 创建一个节点类,其中节点类包含两个部分,第一个是数据域(你到时候要往节点里面储存的信息),第二个是引用域(相当于指针,单向链表有一个指针,指向下一个节点;双向链表有两个指针,分别指向下一个和上一个节点)。
② 创建
一个链表类,其中链表类包含三个属性:头结点、尾节点和大小,方法包含添加、删除、插入等等方法。
package com.security.controller;
/**
* 单向链表
*/
public class MyLink {
//头节点
Node head = null;
/**
* 链表中的节点
*/
class Node{
//节点的引用,指向下一个节点
Node next = null;
//节点的对象,即内容
int data;
public Node(int data){
this.data = data;
}
}
/**
* 向链表中插入数据
* @param d
*/
public void addNode(int d){
//实例化一个节点
Node newNode = new Node(d);
if (head == null) {
head = newNode;
return;
}
Node tmp = head;
while (tmp.next != null){
tmp = tmp.next;
}
tmp.next = newNode;
}
/**
* 除第index个节点
* @param index
* @return
*/
public boolean deleteNode(int index){
if (index < 1 || index > length()){
return false;
}
if (index == 1){
head = head.next;
return true;
}
int i = 1;
Node preNode = head;
Node curNode = preNode.next;
while (curNode != null){
if (i == index){
preNode.next = curNode.next;
return true;
}
preNode = curNode;
curNode = curNode.next;
i++;
}
return false;
}
/**
* 返回节点长度
* @return
*/
public int length(){
int length = 0;
Node tmp = head;
while (tmp != null){
length++;
tmp = tmp.next;
}
return length;
}
/**
* 在不知道头指针的情况下删除指定节点
* @param n
* @return
*不知道头结点就无法遍历到这个节点,就不能采用将上一个节点的指针跳过该节点,只能造一个“前一个节点”
*/
public boolean deleteNode11(Node n){
if (n == null || n.next == null){
return false;
}
int tmp = n.data;
n.data = n.next.data;
n.next.data = tmp;
n.next = n.next.next;
System.out.println("删除成功!");
return true;
}
public void printList(){
Node tmp = head;
while (tmp != null){
System.out.println(tmp.data);
tmp = tmp.next;
}
}
public static void main(String[] args) {
MyLink list = new MyLink();
list.addNode(88);
list.addNode(66);
list.addNode(77);
list.addNode(2);
list.addNode(55);
list.addNode(36);
System.out.println("linkLength:" + list.length());
System.out.println("head.data:" + list.head.data);
list.printList();
list.deleteNode(4);
System.out.println("After deleteNode(4):");
list.printList();
}
}
链表的创建和遍历(头插法和尾插法)
public class LinkList {
//定义链表的头结点
ListNode head = null;
/**
* 尾插法添加元素生成链表
* @param val 值
*/
public void EndInsert(int val) {
//每次执行这个方法的时候,都要新建路一个节点用来存储数据、
ListNode listNode = new ListNode(val);
//判断头特点是否为空,如果是那么将头结点指向新的节点,然后结束
if (head == null) {
head = listNode;
return;
}
//定义一个临时结点由他的充当指针,指针最开始指向头节点
ListNode indexNode = listNode;
//从头结点可是遍历,到最尾部插入
while (indexNode.next != null) {
indexNode = indexNode.next;
}
indexNode.next = listNode;
}
/**
* 头插法添加元素生成链表
* @param val
*/
public void HeadInsert(int val) {
//每次执行这个方法的时候,都要新建路一个节点用来存储数据、
ListNode listNode = new ListNode(val);
//判断头特点是否为空,如果是那么将头结点指向新的节点,然后结束
if (head == null) {
head = listNode;
return;
}
listNode.next = head;
head= listNode;
}
/**
* 链表的输出
*/
public void printLink() {
//定义一个临时结点充当指针,从头结点喀什不断想向后移动
ListNode tempListNode = head;
//将临时结点不断的往后边移动,直到临时结点指向了 null;
while (tempListNode !=null) {
System.out.print(tempListNode.val);
tempListNode = tempListNode.next;
}
System.out.println();
}
/**
* @return 链表的长度
*/
public int GetListLenght() {
//定义一个节点指向该链表
ListNode tempListNode = head;
int length = 0;
while (tempListNode != null) {
length ++;
tempListNode = tempListNode.next;
}
return length;
}
}
判断链表是否有环
方法一:循环遍历节点,遍历一个便标记一个,遍历过程判断是否被标记,若已被标记则表示有环
方法二:声明两个指针,一个指针走一次经过两个节点(快指针quick),另一个走一次经过一个节点(慢指针slow)
public class Solution {
public boolean hasCycle(ListNode head) {
==//声明两个节点从头开始遍历节点==
ListNode quick = head;
ListNode slow = head;
//当快指针能够走到头表示无环
while(quick!=null&&quick.next!=null){
quick = quick.next.next;
slow = slow.next;
if(quick==slow){
return true;
}
}
return false;
}
}
2.两数相加
给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。
请你将两个数相加,并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外,这两个数都不会以 0 开头。
示例 1:
输入:l1 = [2,4,3], l2 = [5,6,4]
输出:[7,0,8]
解释:342 + 465 = 807.
示例 2:输入:l1 = [0], l2 = [0]
输出:[0]
示例 3:输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出:[8,9,9,9,0,0,0,1]提示:
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode pre =new ListNode(0);
ListNode cur = pre;
int carry =0;
int sum =0;
while(l1!=null || l2!= null){
int x =l1==null? 0 :l1.val;
int y =l2==null? 0: l2.val;
sum = x+y+carry;
carry = sum/10;
sum = sum%10;
cur.next = new ListNode(sum);
cur = cur.next;
if(l1!=null){
l1 = l1.next;
}
if(l2!=null){
l2 = l2.next;
}
}
if(carry!=0){
cur.next = new ListNode(carry);
}
return pre.next;
}}
//判断两个链表至少有一个有数值,才继续计算,不然直接返回当前新链表
//该思路进行循环的条件是,两个列表至少一个不为空
//通过设置预先节点pre和当前节点cur来进行结果链表的生成
//假设两个链表长度一致,短链表缺的部分补0即可
//要注意处理最后一位的进位,若为1要新建节点加上