java实现数据结构之单向链表

数据结构是编程语言的基础学科之一，这门学科还是蛮重要的，如果掌握数据结构这门学科，以后可以轻松的读懂一些底层的代码。在java语言中集合这块，相信大家都经常听见链表这种数据的结构，开发中我们只是使用这种java封装好的链表这种数据结构，但是相信大多数程序员并不太懂链表的实现。那么下边我们可以使用java面向对象的这种思想简单的额实现以下链表。

链表简介

链表有多个节点组成，每个节点中都有存放的数据和下一个接点的地址，通过这些节点就组成了单项的链表。链表的第一个节点称之为首节点，最后一个节点为尾节点，为节点指向下一个节点地址这个属性为空。

链表的优缺点

和数组相比数组更容易进行查询操作，因为数组每个元素都有索引，但是不方便插入删除操作，进行插入删除操作后。后边的元素的位置都要前移或后移。链表比较方便删除，插入操作，查询比较慢因为查询的话还要从头结点开始遍历找到到这个节点

单项链表的结构图

                       


单项链表的节点数据类

/**
* 单项链表的节点类
*/
public class ListNode {
private int data;//节点中存放的数据
private ListNode next;//指向下一个节点

public int getData() {
return data;
}

public void setData(int data) {
this.data = data;
}

public ListNode getNext() {
return next;
}

public void setNext(ListNode next) {
this.next = next;
}
}

链表数据类

该数据了类中包含了一些常用方法，该类仅作为参考其实还有可以添加链表的尾节点属性和大小属性。

/**
* 单项链表结构
*/
class LinkList{
//头结点
ListNode head = null;
//单项链表的大小
public int size(){
if (head == null){
return 0;
}
int size = 1;
ListNode content = head;
while (content.getNext() != null){
size ++;
content = content.getNext();
}
return size;
}
//通过位置添加节点
public void addListNode(ListNode node , int option){
if (head == null){
head = node;
}else if(option < 0 || option > this.size()){
System.out.print("输入的位置不正确");
}else if(option == 0){
addListNodeFromHead(node);
}else if (option == size()){
addListNodeFormTail(node);
}else{
ListNode content = head;
int count = 0;
//循环得到传入位置的节点
while (count < option-2){
content = content.getNext();
count++;
}
ListNode next = content.getNext();
//先清空next
if(node.getNext() != null){
node.setNext(null);
}
node.setNext(next);
content.setNext(node);

}
}
//从头添加节点
public void addListNodeFromHead(ListNode node){
ListNode content = head;
head = node;
head.setNext(content);
}
//从尾部添加节点
public void addListNodeFormTail(ListNode node){
if (head == null){
head = node;
return;
}
ListNode content = head;
int count = 0;
int size = size();
//循环得到尾节点
while (count < size-1){
content = content.getNext();
count++;
}
content.setNext(node);
}
//清空单项链表
public void clear(){
ListNode itor = head;
while(itor.getNext() != null){
head = itor;
itor = itor.getNext();
//将各个链接断开
head.setNext(null);
head = null;
}
}
//头部删除
public void delFromHead(){
ListNode next = head.getNext();
head.setNext(null);
head = next;
}
//尾部删除
public  void delFromTail(){
int size = size();
int count = 0;
ListNode content = head;
while(count < size-2){
content = content.getNext();
count++;
}
content.setNext(null);
}
//某个位置进行删除
public void delFromIndex(int index){
if (head == null){
System.out.println("该链表为空不能进行此操作");
}else if(index <0 || index >size()){
System.out.println("不存在该位置");
}else if(index == 0){
delFromHead();
}else if (index == size()){
delFromTail();
}else {
int count = 0;
ListNode provid = head;
while(count < index-2){
provid = provid.getNext();
count++;
}
ListNode del = provid.getNext();
ListNode delNext = del.getNext();
del.setNext(null);
provid.setNext(delNext);
}
}
//修改节点的数据
public void update(int index , int data){
//循环遍历到该节点、
int count = 0;
ListNode content = head;
while(count < index-1){
content = content.getNext();
count++;
}
content.setData(data);
}
//根据节点的data删除节点
public void delBydata(int data){
ListNode provide = head;
int count = 0;
//等于两个节点的时候有点特殊
if (size() == 2){
if (head.getData() == data){
delFromHead();
}else {
delFromTail();
}
}

997d
while (count < size()-2){
provide = provide.getNext();
ListNode del = provide.getNext();
ListNode delNext = del.getNext();
if (del.getData() == data){
del.setNext(null);
provide.setNext(delNext);
}
count++;
}
}
// 根据位置查找节点数据
public int getDataByIndex(int index){
//遍历节点
ListNode content = head;
int count = 0;
while (count < index-1){
content = content.getNext();
count++;
}
return content.getData();
}
// 根据数据判断是否包含该节点
public boolean isCludeNode(int data){
//遍历节点
ListNode content = head;
int count = 0;
while (count < size()-1){
content = content.getNext();
if (content.getData() == data){
return true;
}
count++;
}
return false;
}
//新值替换旧值
public int replaceData(int index , int data){
//遍历节点
ListNode content = head;
int count = 0;
int old = 0;
while (count < index-1){
content = content.getNext();
old = content.getData();
content.setData(data);
count++;
}
return old;
}
//链表中是否包含此元素
public boolean iscludeData(int data){
ListNode content = head;
while(content .getNext() != null){
content=content.getNext();
if (content.getData() == data){
return true;
}
}
return false;
}
//判断链表是否为空
public boolean isEmpty(){
if (size() == 0){
return true;
}else {
return false;
}
}
//遍历所有的节点信息
public void showAllNode(){
ListNode content = head;
while(content .getNext() != null){
content=content.getNext();
System.out.println(content.getData()+" ");
}
}
}

测试类

链表的内容等可以通过debug进行测试更容易理解

class Demo{
public static void main(String[] args) {
ListNode node1 = new ListNode();
node1.setData(1);
ListNode node2 = new ListNode();
node2.setData(2);
ListNode node3 = new ListNode();
node3.setData(3);
ListNode node4 = new ListNode();
node4.setData(4);
LinkList list = new LinkList();
//测试链表是否为空
System.out.println(list.isEmpty());
//测试从头部添加
list.addListNodeFromHead(node1);
list.addListNodeFromHead(node2);
list.addListNodeFromHead(node3);
System.out.println(list.size());
//测试链表是否为空
System.out.println(list.isEmpty());
//测试遍历链表的方法
list.showAllNode();
//测试链表中是否包含此元素
Boolean boo = list.iscludeData(2);
System.out.println(boo);
//测试清空的方法
list.clear();
System.out.println(list.size());
//测试从尾部添加的方法
list.addListNodeFormTail(node1);
list.addListNodeFormTail(node2);
list.addListNodeFormTail(node3);
list.addListNodeFormTail(node4);
System.out.println(list.size());
ListNode node5 = new ListNode();
node5.setData(5);
//option =-1 || 5 || 4
list.addListNode(node5, 4);
System.out.println(list.size());
list.delFromHead();
System.out.println(list.size());
list.delFromTail();
System.out.println(list.size());
//测试新值换旧值
list.replaceData(2,100);
System.out.println(list.size());
//测试根据数据查询是否包含该节点
System.out.println(list.iscludeData(100));
//通过索引查找该节点的数据
System.out.println(list.getDataByIndex(2));
//根据位置进行删除
list.delFromIndex(2);
//根据数据删除节点
list.delBydata(4);
System.out.println(list.size());
System.out.println(list.size());

}

}