Java 单链表的实现，实现链表反转，排序，求最值

1. Node的初始化

   //基于java良好的面向对象的属性，我们可以创建Node类，用来作为指针和数据
   public class Node {
        public Node next;
        public int date;
        
        public Node(Node next) {
       	 this.next = next;
   	}
   	public Node(int date) {
   		this.date=date;
   	}
   	public Node(Node next, int date) {
   		this.next = next;
   		this.date = date;
   	}
   	public Node() {
   		
   	}
   

2. 单链表初始化

   
   public class listNode {
   //	长度
   	public int size;
   //	头节点
       public static Node head;
   	
   	public listNode() {
   	}
   	

3. 单链表的添加数据

    public void insert(int x,int index) {
   	    	if(index<1||index>size){
   	            System.out.println("插入位置不合法。");
   	            return;
   	        }
   	        int i = 1;  //记录我们遍历到第几个结点了，也就是记录位置。
   	        Node p= head;        //可移动的指针
   	        Node newNode = new Node(x); //创建存储x数据的Node节点
   	        
   	        while(p.next != null){//遍历单链表
   	            if(index == i++){        //判断是否到达指定位置。
   	                //注意，我们的p代表的是当前位置的前一个结点。
   	                //前一个结点        当前位置        后一个结点
   	                //temp            temp.next     temp.next.next
   	                //插入操作。
   	              newNode.next=p.next;
   	              p.next=newNode;
   	                return;
   	            }
   	            p = p.next;
   	            size++;
   	        }
   	    }

4. 单链表删除数据

   public void delete(int index) {
   	    	if(index<1||index>size){
   	            System.out.println("插入位置不合法。");
   	            return;
   	        } //步骤跟insert是一样的，只是操作不一样。    
   	        int length=1;
   	        Node temp = head;
   	        while(temp.next != null){
   	            if(index == length++){
   	                //删除操作。
   	            	/*
   	            	 * 1->2->3->4->5->6->7->8->null
   	            	 * 比如我们从里面找到第四个位置（从0位开始）
   	            	 *          p   p.next   p.next.next
   	            	 * 1->2->3->4->5(index)->     6     ->7->8(null)
   	            	 * 变为：
   	            	 * 1->2->3->4->6->7->8(null)
   	            	 * 
   	            	 * 
   	            	 * 
   	            	 */
   	                temp.next = temp.next.next;    
   	                return;
   	            }
   	            temp = temp.next;
   	        }    
   	 }

5. 单链表修改数据

   public void modify(int val,int key) {
       	if (isEmpty()) {
   			System.out.println("链表为空");
   		}
       	else {
       		if (key<0||key>size) {
       			System.out.println("key值不合法");
   			}
       	}
       	
       	Node p = head;
       	if(key>=1) {
   	     for (int i = 0; i < key; i++) {
   	    	 p=p.next;
   	     }
       	p.date=val;
       } 
       	else {
   			p.date=val;
   		}
   	}

6. 单链表数据的排序（寻找最大值）

   //   链表的排序
   public Node sortList() {
   	        //记录每次循环的最小值.冒泡排序
   	        int temp ;
   	        Node curNode = head;
   	        while (curNode != null) {
   	            /**
   	             * 内重循环从当前节点的下一个节点循环到尾节点，
   	             * 找到和外重循环的值比较最小的那个，然后与外重循环进行交换
   	             */
   	            Node nextNode = curNode.next;
   	            while (nextNode != null) {
   	                //比外重循环的小值放到前面
   	                if (nextNode.date < curNode.date) {
   //	                	类似交换排序
   	                    temp = nextNode.date;
   	                    nextNode.date = curNode.date;
   	                    curNode.date = temp;
   	                }
   	                nextNode = nextNode.next;
   	            }
   	            curNode = curNode.next;
   	        }
   	        return head;
   	    }
      

7. 查找数据（可以先把链表转化成数组，在这里直接查找）

   //   查找下标对应的数据
   	 public int find(int key) {
   	    	if (isEmpty()) {
   				System.out.println("链表为空");
   			}
   	    	else {
   	    		if (key<1||key>size) {
   	    			System.out.println("key值不合法");
   				}}
   	    	 Node cur = head;
   	    	    //为什么是position - 1，因为要使用遍历，让cur指向下一个，
   	    	 	//所以position - 1的下个node就是要找的值
   	    	  for (int i = 0; i <key; i++) {
   				cur=cur.next;
   			}
   	    	    return cur.date;
   	    	  }
   	

8. 清空，查询长度，找最值，

   public void clear() {
      	 size=0;
      	 head.next=null;
      }
      
      
      
      
      
      
      
      public int getSize() {
      	System.out.println(+size);
      	return size;
      	
      }
   
      
      
      public int findmax() {
      	Node p = head;
      	while (p.next!=null) {
      		if(p.date>p.next.date) {
      			int temp = p.date;
      			p.date=p.next.date;
      			p.next.date=temp;
      		}
   			p=p.next;
   		}
      	return p.date;
   	}
   
       public void display() {
   	   Node p = head;
   	    if (p.next==null) {
   		return ;
   	        }
      	
              	System.out.print("[");
              	while(p!= null)//注意判断条件
      	{
      	        System.out.print(p.date+"  ");
      	        p = p.next;//下一个结点
      	}
      	        System.out.print("]");
      	        System.out.println();
      }

   打印数据

• 单链表反转的两种算法  

1. 迭代算法：

•  public void reverse2() {
  //    	设置一个前驱指针，后继指针
  //    	前驱：作为空指针
  //    	后继：循环条件
      Node pre = null,nextNode=null;
      Node cur = head;
      while (cur!=null) {
  //    	创建后继指针，用来进行循环
      	nextNode=cur.next;
  //    	当前指针下一位指向空指针
      	cur.next=pre;
  //    	反转结束，将cur结点数据传给pre结点，此时，当前指针应为pre
      	pre = cur;
  //    	在pre结点后进行以上的循环
      	cur=nextNode;
  	}
      //传参
     if (pre!=null) {
  	head=pre;
  }
     
      }

 2.递归算法：

//反转图解: 
    
//    1->2->3->4->5(null)
//    第一步：遍历这一串链表，直到找到空，或者空的前一位即【h位为5】
//    第二步：h.next为null即h为4，故h.next为5
//       初始化：           h  h.next
//           1->2->3->4->5
//       第一轮:      h.next指向h(h.next.next=h);      
//           1->2->3->4 <-5
//                    断开【4->5】的环 h.next=null  
//           1->2->3->4(指向null)<-5
//       第二轮：
//           1->2->3<-4(null) 出5
//       第三轮：
//           1->2<-3(null)    出4
//    
    public Node reverse3(Node h) {
    	if (h==null || h.next==null) 
			return h;
    	Node p = reverse3(h.next);
    	h.next.next=h;
    	h.next=null;
    	  if (p!=null) {
    			head=p;
    		}
		return p;
				
    }
    
   

---