//主要方法是getLength方法
import java.util.Scanner;
public class 单链表 {
public static void main(String[] args) {
Node a = new Node(1);
Node a1 = new Node(88);
Node a2 = new Node(66);
Node a3 = new Node(68);
LinkedList l = new LinkedList();
l.add(a);
l.add(a1);
l.add(a2);
l.add(a3);
l.show();
l.find(88);
//l.update(88);
l.show();
System.out.println("============");
LinkedList l1 = new LinkedList();
l1.addByOrder(a);
l1.addByOrder(a1);
l1.addByOrder(a2);
l1.addByOrder(a3);
l1.show();
l1.find(88);
l1.getLength();
}
}
class LinkedList {
private Node head = new Node(0);
public LinkedList() {
}
//增加操作
public void add(Node node) {
Node temp = head;
while (temp.next != null) {
temp = temp.next;
}
temp.next = node;
}
//删除操作
public void del(int value) {
Node temp = head.next;
Node temp1 = null;
//当temp.getValue()
while (temp.getValue() != value) {
temp1 = temp;
temp = temp.next;
if (temp == null) {
System.out.println("没有找到");
break;
}
}
temp1.next = temp.next;
}
//查找操作
public void find(int value) {
Node temp = head.next;
//当temp.getValue()
while (temp.getValue() != value) {
temp = temp.next;
if (temp == null) {
System.out.println("没有找到");
return;
}
}
System.out.println("找到了" + temp.getValue());
}
//修改操作
public void update(int value) {
Node temp = head.next;
//当temp.getValue()
while (temp.getValue() != value) {
temp = temp.next;
if (temp == null) {
System.out.println("没有找到");
return;
}
}
System.out.println("找到了" + temp.getValue());
Scanner sc = new Scanner(System.in);
System.out.println("输入你要修改的值为:");
int gai = sc.nextInt();
temp.setValue(gai);
System.out.println("修改完成");
}
//显示队列
public void show() {
Node temp = head;//这里可以是头节点赋值, 也可以是头节点的next赋值
if (temp.next == null) {
System.out.println("队列空~~~");
return;
}
while (temp.next != null) {//下一个结点不为null
System.out.println(temp.next);
temp = temp.next;
}
}
//顺序添加
public void addByOrder(Node node) {
Node temp = head;
boolean flag = false; //表示是否找到该节点
while (true) {
if (temp.next == null) {//遍历完
break;
}
if (temp.next.getValue() > node.getValue()) {
break;
} else if (temp.next.getValue() == node.getValue()) {
flag = true;//value值已经存在
break;
}
temp = temp.next;//后移
}
//根据flag判断是否找到要修改的节点
if (flag) {//不能添加,说明编号存在
System.out.printf("准备插入的英雄的编号%d 已经存在,不能加入\n", node.getValue());
} else {
//插入到了链表中, temp的后面
node.next = temp.next;
temp.next = node;
}
}
//获取链表长度
public void getLength() {
Node temp = head.next;
int length = 0;
while (temp != null) {
length++;
temp = temp.next;
}
System.out.println("链表长度为 = " + length);
}
}
class Node {
private int value;
public Node next;
public Node() {
}
public Node(int value) {
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
一:链表简介
顾名思义就是链式结构,把一组内存不连续的数据(当然也可以连续),通过指针串联起来,链表中存储的数据被称为数据域,指针域也可以叫做链,是指储存下一个节点的内存地址
二:图解链表
1.单链表:单链表的Next指向下一个节点的引用地址,尾节点的Next为空
2.双链表:与单链表不同的是,Node节点类中会有Next与Previous两个引用储存
3.环形链表:特点是尾节点的下一个几点会指向头结点(看似循环,实则还是可以有头节点与尾节点的)
4.链表的增删改查(以单链表示意)
增加
增加头结点:需要把新的节点的Next指向头结点,然后把这个新节点赋值给头结点
增加尾节点:把尾节点的Next指向新节点
增加中间节点:需要确定插入的节点下标(插入到哪里),这个时候需要把新节点的Next指向下标节点下一个的引用,把插入 下标上一个节点的引用指向新增节点
删除
删除头结点:把头结点改为头结点的下一个节点
删除尾节点:需遍历链表,找到尾节点的上一个节点,把尾节点赋值
删除中间节点:需把需要删除的节点的Next指针指向删除节点的Next
![**
修改:这里的修改是指修改数据域的数据,这里就没有图了,只需要找到该节点,然后修改数据域即可
查找:链表的查找需要从头结点一节一节往下遍历frist.Next.Next.....
1.链表常用方法
2.定义接口预制功能清单ISingleLinkedListFunction
interface ISingleLinkedListFunction<T>
{
/// <summary>
/// 第一个节点
/// </summary>
SingleLinkedListNode<T> First { get; }
/// <summary>
/// 最后一个节点
/// </summary>
SingleLinkedListNode<T> Last { get; }
/// <summary>
/// 链表数量
/// </summary>
int Count { get; }
/// <summary>
/// 链表是否为空
/// </summary>
bool IsEmpty { get; }
/// <summary>
/// 清空链表
/// </summary>
void Clear();
/// <summary>
/// 链表中是否包含该数据
/// </summary>
/// <param name="value">验证数据项</param>
/// <returns></returns>
bool Contains(T value);
/// <summary>
/// 添加一个节点到节点起点
/// </summary>
/// <param name="value">节点数据</param>
/// <returns>返回Node节点</returns>
SingleLinkedListNode<T> AddFirst(T value);
/// <summary>
/// 添加一个节点到节点起点
/// </summary>
/// <param name="node">需要添加的节点</param>
/// <returns>添加的并不是参数节点,而是参数数据,返回添加的节点</returns>
SingleLinkedListNode<T> AddFirst(SingleLinkedListNode<T> node);
/// <summary>
/// 添加一个节点到链表最后
/// </summary>
/// <param name="value">节点数据</param>
/// <returns>节点</returns>
SingleLinkedListNode<T> AddLast(T value);
///<summary>
/// 添加一个节点到链表最后
/// </summary>
/// <param name="node">需要添加的节点</param>
/// <returns>添加的并不是参数节点,而是参数数据,返回添加的节点</returns>
SingleLinkedListNode<T> AddLast(SingleLinkedListNode<T> node);
/// <summary>
/// 插入一个节点到指定的下标出
/// </summary>
/// <param name="value">节点数据</param>
/// <param name="index">插入下标</param>
/// <returns>新增节点</returns>
SingleLinkedListNode<T> Insert(T value, int index);
/// <summary>
/// 插入一个节点到指定的下标出
/// </summary>
/// <param name="node">节点</param>
/// <param name="index">插入下标</param>
/// <returns>添加的并不是参数节点,而是参数数据,返回添加的节点</returns>
SingleLinkedListNode<T> Insert(SingleLinkedListNode<T> node, int index);
/// <summary>
/// 删除节点
/// </summary>
/// <param name="value">数据</param>
/// <returns>是否删除成功</returns>
bool Delete(T value);
/// <summary>
/// 删除节点
/// </summary>
/// <param name="index">删除的节点下标</param>
/// <returns>是否删除成功</returns>
bool DeleteAt(int index);
/// <summary>
/// 删除节点
/// </summary>
/// <param name="index">删除的节点</param>
/// <returns>是否删除成功</returns>
bool Delete(SingleLinkedListNode<T> node);
/// <summary>
/// 删除第一个节点
/// </summary>
/// <returns>是否删除成功</returns>
bool DeleteFirst();
/// <summary>
/// 删除最后一个节点
/// </summary>
/// <returns>是否删除成功</returns>
bool DeleteLast();
/// <summary>
/// 根据数据查找节点
/// </summary>
/// <param name="value">数据</param>
/// <returns>节点</returns>
SingleLinkedListNode<T> Find(T value);
/// <summary>
/// 根据数据查找上一个节点
/// </summary>
/// <param name="value">数据</param>
/// <returns>节点</returns>
SingleLinkedListNode<T> FindPrevious(T value);
/// <summary>
/// 索引器取数据
/// </summary>
/// <param name="index">下标</param>
/// <returns></returns>
T this[int index] { get; }
/// <summary>
/// 根据下标取数据
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
T GetElement(int index);
/// <summary>
/// 根据数据获取下标
/// </summary>
/// <param name="value">数据</param>
/// <returns>数据节点下标</returns>
int IndexOf(T value);
}
3.定义节点类SingleLinkedListNode
class SingleLinkedListNode<T>
{
public T Value { get; set; }
public SingleLinkedListNode<T> Next { get; set; }
public SingleLinkedListNode()
{
Value = default(T);
Next = null;
}
}
4.定义链表类SingleLinkedList,实现功能清单
class SingleLinkedList<T> : ISingleLinkedListFunction<T>
{
private SingleLinkedListNode<T> first = null;
/// <summary>
/// 头结点
/// </summary>
public SingleLinkedListNode<T> First
{
get
{
return first;
}
}
private SingleLinkedListNode<T> last = null;
/// <summary>
/// 尾节点
/// </summary>
public SingleLinkedListNode<T> Last
{
get
{
return last;
}
}
private int count;
/// <summary>
/// 链表节点数量
/// </summary>
public int Count
{
get
{
count = GetCount();
return count;
}
}
private bool isEmpty;
/// <summary>
/// 链表是否为空
/// </summary>
public bool IsEmpty
{
get
{
isEmpty = GetIsEmpty();
return isEmpty;
}
}
/// <summary>
/// 索引器
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T this[int index]
{
get
{
if (index >= Count || index < 0)
{
return default(T);
}
SingleLinkedListNode<T> tempNode = first;
for (int i = 0; i < index; i++)
{
tempNode = tempNode.Next;
}
return tempNode.Value;
}
}
/// <summary>
/// 添加数据到链表首节点
/// </summary>
/// <param name="value">数据</param>
/// <returns>Node节点</returns>
public SingleLinkedListNode<T> AddFirst(T value)
{
SingleLinkedListNode<T> tempNode = new SingleLinkedListNode<T>();
tempNode.Value = value;
if (first == null)
{
first = tempNode;
last = tempNode;
}
else
{
tempNode.Next = first;
first = tempNode;
}
return tempNode;
}
/// <summary>
/// 添加节点到首节点(此时储存的并不是传递过来的数据地址,而是新建节点,赋值传过来节点的数据)
/// </summary>
/// <param name="node">数据节点</param>
/// <returns>真正添加的节点</returns>
public SingleLinkedListNode<T> AddFirst(SingleLinkedListNode<T> node)
{
SingleLinkedListNode<T> tempNode = CopyToFrom(node);
tempNode.Next = null;
if (first == null)
{
first = tempNode;
last = tempNode;
}
else
{
tempNode.Next = first;
first = tempNode;
}
return tempNode;
}
/// <summary>
/// 添加数据到尾节点
/// </summary>
/// <param name="value">数据</param>
/// <returns>Node节点</returns>
public SingleLinkedListNode<T> AddLast(T value)
{
SingleLinkedListNode<T> tempNode = new SingleLinkedListNode<T>();
tempNode.Value = value;
if (first == null)
{
first = tempNode;
last = tempNode;
}
else
{
last.Next = tempNode;
last = tempNode;
}
return tempNode;
}
/// <summary>
/// 添加尾节点(此时储存的并不是传递过来的数据地址,而是新建节点,赋值传过来节点的数据)
/// </summary>
/// <param name="node">数据节点</param>
/// <returns>返回真正添加的节点</returns>
public SingleLinkedListNode<T> AddLast(SingleLinkedListNode<T> node)
{
SingleLinkedListNode<T> tempNode = CopyToFrom(node);
tempNode.Next = null;
if (first == null)
{
first = tempNode;
last = tempNode;
}
else
{
last.Next = tempNode;
last = tempNode;
}
return tempNode;
}
/// <summary>
/// 清空链表
/// </summary>
public void Clear()
{
first = null;
last = null;
}
/// <summary>
/// 判断链表中是否有该数据
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public bool Contains(T value)
{
if (first == null)
{
return false;
}
SingleLinkedListNode<T> tempNode = first;
if (tempNode.Value.Equals(value))
{
return true;
}
while (true)
{
if (tempNode.Next != null)
{
if (tempNode.Value.Equals(value))
{
return true;
}
tempNode = tempNode.Next;
}
else
{
break;
}
}
return false;
}
/// <summary>
/// 删除第一个数据T的节点
/// </summary>
/// <param name="value"></param>
/// <returns>是否删除成功</returns>
public bool Delete(T value)
{
if (Contains(value))
{
SingleLinkedListNode<T> tempNode = first;
if (tempNode.Value.Equals(value))
{
first = first.Next;
return true;
}
SingleLinkedListNode<T> tempPrevious = null;
while (true)
{
if (tempNode.Next != null)
{
tempPrevious = tempNode;
tempNode = tempNode.Next;
if (tempNode.Value.Equals(value))
{
tempPrevious.Next = tempNode.Next;
return true;
}
}
else
{
break;
}
}
}
return false;
}
/// <summary>
/// 删除下标节点
/// </summary>
/// <param name="index">下标</param>
/// <returns>是否删除成功</returns>
public bool DeleteAt(int index)
{
if (index >= Count)
{
return false;
}
else
{
if (index == 0)
{
first = first.Next;
return true;
}
else
{
SingleLinkedListNode<T> tempNode = first;
//拿到需要删除节点的上一个节点
for (int i = 0; i < index - 1; i++)
{
tempNode = tempNode.Next;
}
tempNode.Next = tempNode.Next.Next;
return true;
}
}
}
/// <summary>
/// 删除节点
/// </summary>
/// <param name="node">删除的节点</param>
/// <returns>是否删除成功</returns>
public bool Delete(SingleLinkedListNode<T> node)
{
if (first == null)
{
return false;
}
else
{
SingleLinkedListNode<T> tempNode = first;
if (tempNode.Equals(node))
{
first = first.Next;
return true;
}
SingleLinkedListNode<T> tempPrevious = null;
while (true)
{
if (tempNode.Next != null)
{
tempPrevious = tempNode;
tempNode = tempNode.Next;
if (tempNode.Equals(node))
{
tempPrevious.Next = tempNode.Next;
return true;
}
}
else
{
break;
}
}
return false;
}
}
/// <summary>
/// 删除头节点
/// </summary>
/// <returns></returns>
public bool DeleteFirst()
{
if (first == null)
{
return false;
}
else
{
first = first.Next;
return true;
}
}
/// <summary>
/// 删除尾节点
/// </summary>
/// <returns></returns>
public bool DeleteLast()
{
if (first == null)
{
return false;
}
else
{
if (first == last)
{
last = null;
first = null;
}
else
{
//获取last的上一个节点
SingleLinkedListNode<T> tempNode = first;
SingleLinkedListNode<T> tempPrevious = null;
while (true)
{
if (tempNode.Next != null)
{
tempPrevious = tempNode;
tempNode = tempNode.Next;
}
else
{
tempPrevious.Next = null;
last = tempPrevious;
break;
}
}
}
return true;
}
}
/// <summary>
/// 查找数据所属节点
/// </summary>
/// <param name="value">数据</param>
/// <returns></returns>
public SingleLinkedListNode<T> Find(T value)
{
if (Contains(value))
{
SingleLinkedListNode<T> tempNode = first;
if (tempNode.Value.Equals(value))
{
return first;
}
while (true)
{
if (tempNode.Next != null)
{
if (tempNode.Value.Equals(value))
{
return tempNode;
}
tempNode = tempNode.Next;
}
else
{
break;
}
}
}
return null;
}
/// <summary>
/// 查找数据上一个节点
/// </summary>
/// <param name="value">数据</param>
/// <returns></returns>
public SingleLinkedListNode<T> FindPrevious(T value)
{
if (first == null)
{
return null;
}
SingleLinkedListNode<T> tempNode = first;
if (tempNode.Value.Equals(value))
{
return null;
}
SingleLinkedListNode<T> tempPrevious = null;
while (true)
{
if (tempNode.Next != null)
{
tempPrevious = tempNode;
tempNode = tempNode.Next;
if (tempNode.Value.Equals(value))
{
return tempPrevious;
}
}
else
{
break;
}
}
return null;
}
/// <summary>
/// 获取下标的数据域
/// </summary>
/// <param name="index">下标</param>
/// <returns>数据</returns>
public T GetElement(int index)
{
if (index >= Count)
{
return default(T);
}
else
{
if (index == 0)
{
return first.Value;
}
else
{
SingleLinkedListNode<T> tempNode = first;
//拿到需要删除节点的上一个节点
for (int i = 0; i < index; i++)
{
tempNode = tempNode.Next;
}
return tempNode.Value;
}
}
}
/// <summary>
/// 查找数据下标
/// </summary>
/// <param name="value">数据</param>
/// <returns>返回该数据第一次出现的下标</returns>
public int IndexOf(T value)
{
if (Contains(value))
{
int tempIndex = 0;
SingleLinkedListNode<T> tempNode = first;
if (tempNode.Value.Equals(value))
{
return tempIndex;
}
while (true)
{
if (tempNode.Next != null)
{
if (tempNode.Value.Equals(value))
{
return tempIndex;
}
tempNode = tempNode.Next;
tempIndex++;
}
else
{
break;
}
}
}
return -1;
}
/// <summary>
/// 插入数据到Index下标处
/// </summary>
/// <param name="value">数据</param>
/// <param name="index">下标</param>
/// <returns>Node节点</returns>
public SingleLinkedListNode<T> Insert(T value, int index)
{
if (index > Count || index < 0)
{
return null;
}
if (index == 0)
{
return AddFirst(value);
}
else if (index == Count)
{
return AddLast(value);
}
else
{
if (first == null) return null;
SingleLinkedListNode<T> tempNode = first;
for (int i = 0; i < index - 1; i++)
{
tempNode = tempNode.Next;
}
SingleLinkedListNode<T> newNode = new SingleLinkedListNode<T>();
newNode.Value = value;
newNode.Next = tempNode.Next;
tempNode.Next = newNode;
return newNode;
}
}
/// <summary>
/// 插入Node节点到Index下标节点
/// </summary>
/// <param name="node">数据节点</param>
/// <param name="index">下标</param>
/// <returns>真正添加的Node节点</returns>
public SingleLinkedListNode<T> Insert(SingleLinkedListNode<T> node, int index)
{
if (index > Count || index < 0)
{
return null;
}
if (index == 0)
{
return AddFirst(node);
}
else if (index == Count)
{
return AddLast(node);
}
else
{
if (first == null) return null;
SingleLinkedListNode<T> tempNode = first;
for (int i = 0; i < index - 1; i++)
{
tempNode = tempNode.Next;
}
SingleLinkedListNode<T> newNode = CopyToFrom(node);
newNode.Next = tempNode.Next;
tempNode.Next = newNode;
return newNode;
}
}
/// <summary>
/// 打印链表
/// </summary>
/// <returns></returns>
public override string ToString()
{
string str = "链表信息";
if (first == null)
{
Console.WriteLine("空链表");
return str;
}
SingleLinkedListNode<T> tempNode = first;
str += tempNode.Value.ToString();
while (true)
{
if (tempNode.Next != null)
{
tempNode = tempNode.Next;
str += tempNode.Value.ToString();
}
else
{
break;
}
}
Console.WriteLine(str);
return str;
}
/// <summary>
/// 获取链表数量
/// </summary>
/// <returns></returns>
private int GetCount()
{
if (first == null) return 0;
int tempCount = 1;
SingleLinkedListNode<T> tempNode = first;
while (true)
{
if (tempNode.Next != null)
{
tempNode = tempNode.Next;
tempCount++;
}
else
{
break;
}
}
return tempCount;
}
/// <summary>
/// 判断链表是否为空
/// </summary>
/// <returns></returns>
private bool GetIsEmpty()
{
return first == null;
}
/// <summary>
/// 为避免参数重复赋值(比如已经加了头结点,又加入了尾节点)
/// </summary>
/// <returns></returns>
private SingleLinkedListNode<T> CopyToFrom(SingleLinkedListNode<T> node)
{
SingleLinkedListNode<T> tempNode = new SingleLinkedListNode<T>();
tempNode.Value = node.Value;
tempNode.Next = tempNode.Next;
return tempNode;
}
}
5.使用此链表
class Program
{
static void Main(string[] args)
{
SingleLinkedList<int> singleLinkedList = new SingleLinkedList<int>();
SingleLinkedListNode<int> singleLinkedListNode = new SingleLinkedListNode<int>();
singleLinkedListNode.Value = 6;
//singleLinkedList.AddFirst(1);
//singleLinkedList.AddFirst(2);
//singleLinkedList.AddFirst(3);
//singleLinkedList.AddFirst(4);
//singleLinkedList.AddFirst(singleLinkedListNode);
singleLinkedList.AddLast(1);
singleLinkedList.AddLast(2);
singleLinkedList.AddLast(3);
singleLinkedList.AddLast(4);
singleLinkedList.Insert(singleLinkedListNode, 3);
//singleLinkedList.AddLast(4);
//singleLinkedList.AddLast(3);
//singleLinkedList.AddLast(2);
//singleLinkedList.AddLast(singleLinkedListNode);
Console.WriteLine("获取:" + singleLinkedList[1]);
Console.WriteLine("链表数量" + singleLinkedList.Count);
Console.WriteLine("链表是否为空" + singleLinkedList.IsEmpty);
singleLinkedList.ToString();
Console.ReadKey();
}
}
以上只贴出了,单链表的实现,双链表只是在节点类中添加上一个节点的引用,然后在实现链表功能中赋值即可,环形链表也是一样的,只需要把尾节点的Next指向头结点即可~
好了,文章到此就结束了,本文有什么错误的观点或者用法,希望各位看官能够及时提出,希望在自己积累知识的同时,能帮助到大家~