链表学习笔记--java语言实现

1、定义

链表是由一系列节点组成，每一个节点节点都包含两部分，一部分是元素数据本身，另一部分是指针下一个元素地址的指针。链表是一种物理上非连续、非顺序的存储结构，元素之间的顺序是通过每个元素的指针关联的。

2、链表的操作

创建、插入、删除、输出。

3、java实现（内部类创建节点）

package Link;

class MyLink {
Node head = null;

class Node {
Node next = null; // 节点的指引，指向下一个节点
int data; // 节点内容

public Node(int data) {
this.data = data;
}
}

/*
* 向列表中插入数据
*/
public void addNode(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
return;
}
Node temp = head;
while (temp.next != null) {
temp = temp.next;
}
temp.next = newNode;
}
/*
* 指定位置插入数据
**/

public void addNode1(int index, int data) {
Node newNode = new Node(data);
Node temp = head;
if (index == 1) {
head = newNode;
head.next = temp;
return;
}
if (index > length()) {
Node temp1 = head;
// System.out.println("test");
while (temp1.next != null) {
temp1 = temp1.next;
}
temp1.next = newNode;
return;
}
int init = 1;
Node preNode = head;
Node curNode = head;
while (init != index) {
preNode = curNode;
curNode = curNode.next;
init++;
}
preNode.next = newNode;
newNode.next = curNode;
}

/*
* 删除第i个节点
*/
public boolean delete(int i) {
if (i < 1 || i > length()) {
return false;
}
if (i == 1) {
head = head.next;
return true;
}
int j = 1;
Node preNode = head;
Node curNode = head;
while (j != i) {
preNode = curNode;
curNode = curNode.next;
j++;
}
if (j == i) {
preNode.next = curNode.next;
return true;
}
return false;
}

// 根据数据删除节点
public Node deleteByData(int data) {
Node curNode = head;
Node preNode = head;
while (curNode.data != data) {
if (curNode.next == null) {
return null;
}
preNode = curNode;
curNode = curNode.next;
}
if (curNode == head) {
head = head.next;
} else {
preNode.next = curNode.next;
}
return curNode;
}

/*
* 返回节点长度
*/
public int length() {
int length = 0;
Node tmp = head;
while (tmp.next != null) {
length++;
tmp = tmp.next;
}
return length;
}

/*
* 打印链表
**/
public void printList() {
Node temp = head;
while (temp != null) {
System.out.print(temp.data + " ");
temp = temp.next;
}
}

// 链表反转
public Node ReverseIteratively(Node head) {
Node ReversedHead = head;
Node curNode = head;
Node preNode = null;
while (curNode != null) {
Node nextNode = curNode.next;
if (nextNode == null) {
ReversedHead = curNode;
}
curNode.next = preNode;
preNode = curNode;
curNode = nextNode;
}
this.head = ReversedHead;
return this.head;
}

// 查找单链表中间节点
public Node SearchMid(Node head) {
Node pNode = head, q = head;
while (pNode != null && pNode.next != null && pNode.next.next != null) {
pNode = pNode.next.next;
q = q.next;
}
System.out.println("Mid:" + q.data);
return q;
}
//查找倒数第k个元素
public Node findElem(Node head, int k) {
if (k < 1 || k > this.length()) {
return null;
}
Node pNode = head;
Node qNode = head;
for (int i = 0; i < k; i++) {
pNode = pNode.next;
}
while (pNode.next != null) {
pNode = pNode.next;
qNode = qNode.next;
}
return qNode;
}

//升序排序
public Node orderList() {
Node nextNode = null;
int tmp = 0;
Node curNode = head;
while(curNode.next != null){
nextNode = curNode.next;
while (nextNode != null) {
if (curNode.data > nextNode.data) {
tmp = curNode.data;
curNode.data = nextNode.data;
nextNode.data = tmp;
}
nextNode = nextNode.next;
}
curNode = curNode.next;
}
return head;
}
//删除重复节点
public void deleteDuplecate(Node head) {
Node first = new Node(0);
first.next = head;
Node last = first;
Node p = head;
while(p!=null && p.next != null){
if (p.data == p.next.data) {
int value = p.data;
while(p!=null && p.data == value){
p = p.next;
last.next = p;
}
}else{
last = p;
p = p.next;
}
}
//去除重复元素
//      while (p != null) {
//          Node q = p;
//          while(q.next != null){
//              if (p.data == q.next.data) {
//                  q.next = q.next.next;
//              }else{
//                  q = q.next;
//              }
//          }
//          p = p.next;
//      }

}
//递归输出链表
public void printListrecursive(Node head) {
if (head != null) {
System.out.print(head.data + " ");
printListrecursive(head.next);
}
}
}

测试类

package Link;

public class TestLink {

public static void main(String[] args) {
// TODO Auto-generated method stub
MyLink mLink= new MyLink();
mLink.addNode(2);
mLink.addNode(5);
mLink.addNode(5);
mLink.addNode1(1, 3);
mLink.addNode1(4,7);
mLink.addNode(2);
mLink.addNode(2);
mLink.addNode1(2,8);
mLink.addNode1(3,9);
mLink.addNode(10);
mLink.addNode(11);
mLink.printList();
System.out.println();
//      mLink.deleteByData(2);
mLink.deleteDuplecate(mLink.head);
//      mLink.ReverseIteratively(mLink.head);
//      mLink.printList();
//      mLink.SearchMid(mLink.head);
//      mLink.orderList();
mLink.printListrecursive(mLink.head);
}

}