链表的原理

1.单链表有两个属性：

value，值

next，指向下一个节点的指针

2.双链表附加一个属性：

pre,指向前一个节点的指针

3.下面自定义一个链表节点的类：

/**
* Created by liupf
*/
public class ListNode<T> {
public T value;
public ListNode<T> next;

public ListNode(T value, ListNode<T> next) {
this.value = value;
this.next = next;
}

public ListNode() {
}
public ListNode<T> pre;//指向前一个节点的指针
}

4.有上面的基础，就可以实现一个微型的单链表API
/**
* Created by liupf
*/
public class MiniList<T> {
private ListNode<T> head=new ListNode<>(null,null);

public Comparator<T> comp;//定义比较器
public int compare(T a,T b){
if (comp!=null){
return comp.compare(a,b);
}else{
Comparable<T> c= (Comparable<T>) a;
return c.compareTo(b);
}
}

/**
* 获取链表中的最大值
* @return
*/
public T getMax(){
if (head.next==null){
return null;
}
ListNode<T> p=head.next;
T max=p.value;
p=p.next;
while(p!=null){
if (compare(p.value,max)>0){
max=p.value;
}
p=p.next;
}
return max;
}

/**
* 将一个数组转化成单链表
* @param array
*/
public void arrayToList(T[] array){
ListNode<T> p=head;//指定头指针
for (T t:array){
ListNode<T> node=new ListNode<>(t,null);
p.next=node;
p=node;
}
}
public void printList(){
ListNode<T> p=head.next;
while (p!=null){
System.out.print(p.value+" ");
p=p.next;
}
System.out.println(" ");
}

/**
* 链表的插入
* @param index
* @param value
*/
public void insert(int index,T value){
ListNode<T> p=head;
for (int i=0;i<=index;i++){
p=p.next;//链表指针向后移动
}
ListNode<T> node=new ListNode<>(value,null);
node.next=p.next;
p.next=node;
}

/**
* 链表的删除
* @param index
* @return
*/
public T remove(int index){
ListNode<T> pre=head;
for (int i=0;i<index;i++){
pre=pre.next;
}
ListNode<T> node=pre.next;
pre.next=node.next;
return node.value;
}

/**
* 链表的查询
* @param index
* @return
*/
public T get(int index){//查询
ListNode<T> p=head;
for (int i=0;i<=index;i++){
p=p.next;
}
return p.value;
}

/**
* 修改链表
* @param index
* @param value
*/
public void set(int index,T value){
ListNode<T> p=head;
for (int i=0;i<=index;i++){
p=p.next;
}
p.value=value;
}

/**
* 非递归逆序打印链表
*/
public void printReverse(){
if (head.next==null){
return;
}
Stack<T> stack=new Stack();
ListNode<T> node=head.next;
while (node!=null){
stack.push(node.value);
node=node.next;
}
while (!stack.isEmpty()){
System.out.print(stack.pop()+" ");
}
System.out.println();
}

/**
* 递归逆序打印链表
*/
public void printInverseRecursive(){
if (head.next==null){
return ;
}
recursive(head.next);
System.out.println();
}
private void recursive(ListNode<T> p){
if (p!=null){
recursive(p.next);
System.out.print(p.value+" ");
}
}
}


相信通过上面的讲解，应该对单链表有一定的认识了