java单链表查询功能_Java实现单链表，包含增删改查以及排序等功能

单链表的Java类结构如下：

下面上源码：

1.定义链表结点类，每一个结点包含数据data和下一个结点的引用。

package singlelinkedlist;

/**

* @date on 16:08 2018/8/14

* @describe 模拟单链表的节点信息，这里将属性设为public不用设置get和set方法。

*/

public class Node {

/**

* 包含两个属性一个是结点数据，和下一个结点的引用

*/

public Node next;

public int data;

/**

* constructor

*/

public Node(int data) {

this.data = data;

}

}

2. 自定义异常类

package singlelinkedlist;

/**

* @date on 16:43 2018/8/14

* @describe 自定义异常类

*/

public class MyException extends Exception{

private String errorMessage;

public MyException(String message) {

super(message);

this.errorMessage = message;

}

@Override

public String getMessage() {

return errorMessage;

}

}

3. 链表类包含增删改查、打印、排序反转等功能！以及Junit测试！

package singlelinkedlist;

import org.junit.Test;

/**

* @date on 16:13 2018/8/14

* @describe 单链表的一些操作方法

*/

public class SingleLinkedList {

/**

* 链表的头节点

*/

private  Node head ;

private  int length = 0;

/**

* 获取链表的长度

*/

public  int length(){

return length;

}

/**

* 尾插法增加结点操作

* @param data

*/

public  void addLastNode(int data){

Node tNode = new Node(data);

if (head == null){

head = tNode;

length++;

return;

}

Node temp = head;

while (temp.next != null){

temp = temp.next;

}

temp.next = tNode;

length++;

}

/**

* 头插法增加结点的操作

* @param data

*/

public  void addHeadNode(int data){

Node tNode = new Node(data);

if (head == null){

head = tNode;

length++;

return;

}

Node temp = head;

tNode.next = temp;

head = tNode;

length++;

}

/**

* 插入结点到链表的指定位置

* @param index

* @param data

*/

public  void insertNodeByIndex(int index,int data){

//先判断指定位置是否合法

if (index < 1 || index > length+1){

try {

throw new MyException("指定位置不合法，插入结点失败");

} catch (MyException e) {

e.printStackTrace();

}

}

if (index == 1){

addHeadNode(data);

return;

}

if (index == length+1){

addLastNode(data);

return;

}

Node temp = head;

Node tNode = new Node(data);

int tlength = 1;

while (temp.next != null){

if (index == ++tlength){

//当前结点向后移动一位

tNode.next = temp.next;

temp.next = tNode;

length++;

return;

}

temp = temp.next;

}

}

/**

* 删除指定位置的结点

* @param index

*/

public  void delNodeByIndex(int index){

//先判断指定索引合不合法

if (index < 1 || index > length){

try {

throw new MyException("指定位置参数不合法");

} catch (MyException e) {

e.printStackTrace();

}

}

Node temp = head;

int tlength = 1;

while (temp.next != null){

//如果到达了指定结点则进行删除

if (index == ++tlength){

temp.next = temp.next.next;

length--;

return;

}

temp = temp.next;

}

}

/**

* 删除链表重复结点

* @return

*/

public boolean deleteRepeatNode(){

Node temp = head;

while (temp != null){

Node tNode = head;

while (tNode.next != temp && tNode.next != null){

if (tNode.next.data == temp.data){

tNode.next = tNode.next.next;

}else {

tNode = tNode.next;

}

}

temp = temp.next;

}

return true;

}

/**

* 遍历单链表，打印链表中的值

*/

public  void printData(){

Node temp = head;

System.out.print(temp.data);

while (temp.next != null){

System.out.print(","+temp.next.data);

temp = temp.next;

}

System.out.println(",长度："+length());

}

/**

* 修改指定结点的值

* @param index

* @param data

*/

public boolean updateNode(int index,int data){

//判断指定位置是否存在结点

if (index < 0 || index > length){

try {

throw new MyException("不存在该指定结点，修改值失败");

} catch (MyException e) {

e.printStackTrace();

}

}

Node temp = head;

int i=1;

while(index != i){

temp = temp.next;

i++;

}

temp.data = data;

return true;

}

/**

* 单链表的选择排序---正序

* 注意排序的只是data而不是结点本身,不要混淆！！

* @return

*/

public boolean selectedSortNode(){

Node temp = head;

while (temp != null){

Node tNode = temp.next;

while (tNode != null){

//判断大小交换data

if (temp.data > tNode.data){

int da = tNode.data;

tNode.data = temp.data;

temp.data = da;

}

tNode = tNode.next;

}

temp = temp.next;

}

return true;

}

/**

* 冒泡排序法排序----倒序

* @return

*/

public boolean bubbleSortNode(){

Node temp = head;

int len_temp = 1;

while (temp != null){

Node tNode = temp.next;

int len_tNode = 1;

if (len_tNode++ < length-len_temp){

while (tNode != null){

if (temp.data < tNode.data){

int da = temp.data;

temp.data = tNode.data;

tNode.data = da;

}

tNode = tNode.next;

}

}

temp = temp.next;

len_temp++;

}

return true;

}

/**

* 反转排序，将第一个和倒数第一个位置交换，以此类推

* @return

*/

public boolean reverseSortNode(){

Node temp = head;

for (int i = 1; i<=length/2; i++){

//找到倒数第i个结点

Node q = head;

int len = 1;

while (q != null && len != length-i+1){

len++;

q = q.next;

}

int da = q.data;

q.data = temp.data;

temp.data = da;

temp = temp.next;

}

return true;

}

public  boolean isEmpty(){

if (head == null){

return true;

}

return false;

}

@Test

public void test(){

SingleLinkedList linkedList = new SingleLinkedList();

linkedList.addLastNode(5);

linkedList.addLastNode(21);

linkedList.addLastNode(22);

linkedList.addLastNode(9);

linkedList.addLastNode(7);

System.out.println(linkedList.length());

linkedList.printData();

System.out.println(linkedList.isEmpty());

linkedList.addHeadNode(78);

linkedList.addHeadNode(101);

System.out.println("*************************************");

linkedList.printData();

System.out.println(linkedList.isEmpty());

System.out.println("*************************************");

linkedList.insertNodeByIndex(8,222);

linkedList.printData();

System.out.println("*************************************");

linkedList.insertNodeByIndex(2,600);

linkedList.printData();

// linkedList.delNodeByIndex(10);

linkedList.updateNode(2,1000);

linkedList.selectedSortNode();

linkedList.printData();

linkedList.bubbleSortNode();

linkedList.printData();

linkedList.reverseSortNode();

linkedList.printData();

linkedList.addLastNode(22);

linkedList.printData();

linkedList.deleteRepeatNode();

linkedList.printData();

}

}

---------------------

作者：清溪先生

来源：CSDN

原文：https://blog.csdn.net/qingxixiansheng/article/details/81706351

版权声明：本文为博主原创文章，转载请附上博文链接！