数据结构+JAVA 单链表

关于java中链表的操作
求单链表中结点的个数: getListLength
将单链表反转: reverseList（遍历），reverseListRec（递归）
查找单链表中的倒数第K个结点（k > 0）: reGetKthNode
查找单链表的中间结点: getMiddleNode
从尾到头打印单链表: reversePrintListStack，reversePrintListRec（递归）
. 已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序: mergeSortedList, mergeSortedListRec
对链表的后半部分进行反转。reversePartNode
判断单链表是否存在环，isLoop。 使用两个指针，fast和low，fast一次走两步，low一次走一步。若存在环，总会有某个时刻fast和low指向同一节点
求出环的长度。getLoopLength().记录8中fast和low的遭遇点。然后让low走 对单链表进行排序,listSort（归并）,insertionSortList（插入）
*/
public class LinkedListSummary {
public static class Node {
int data;
Node next;
public Node(int value) {
data = value;
next = null;
}
}
//向链表中插入新节点
public static void addNode(Node head, int data) {
Node newNode = new Node(data);
if(head == null) {
head = newNode;
return;
} else {
Node temp = head;
while(temp.next != null) {
temp = temp.next;
}
temp.next = newNode;
}
}
//输出链表的长度
public static int getListLength(Node head) {
int len = 0;
//if(head == null) return 0;
Node temp = head;
while(temp != null) {
len++;
temp = temp.next;
}
System.out.println(“输出链表长度：” + len);
return len;
}
//顺序打印链表数据
public static void print(Node head) {
if(head == null) {
System.out.println(“链表为空”);
return;
}
Node temp = head;
while(temp != null) {
System.out.print(temp.data + " ");
temp = temp.next;
}
}
//方法1：使用栈反向遍历单链表
public static void reversePrint(Node head) {
if(head == null || head.next == null) return;
Stack nodes = new Stack();
Node temp = head;
while(temp != null) {
nodes.push(temp);
temp = temp.next;
}
while(!nodes.isEmpty()) {
//nodes.pop();
System.out.print(nodes.pop().data + " ");
}
}
//方法二：反向遍历单链表
public static Node reversePrint2(Node head) {
if(head == null || head.next == null) return head;
Node pre = null;
Node temp = null;
while(head != null) {
temp = head.next;
head.next = pre;
pre = head;
head = temp;
}
print(pre);
// System.out.println(head == null ? “空” : “非空”);
return pre;
}
//递归反向遍历单链表
public static Node reversePrintRec(Node head) {
if(head == null || head.next == null) {
System.out.println(“链表遍历完成，只有head节点或为空链表”);
return head;
}
Node reHead = reversePrintRec(head.next);
head.next.next = head;
head.next = null;
return head;
}
//从尾到头打印递归打印单链表
public static void reversePrintListRec(Node head) {
if(head == null) {
return;
} else {
reversePrintListRec(head.next);
System.out.print(head.data + “,”);
}
}
//查找单链表的倒数第K个节点（k>0）
public static Node reGetKthNode(Node head, int k) {
int len = 0;
Node temp = head;
while(temp != null) {
len++;
temp = temp.next;
}
if(k > len) {
System.out.println(“链表长度有限，小于K，找不到倒数第K个节点”);
return null;
}
Node n1 = head;
Node n2 = head;
for(int i = 0; i < k; i++) {
n1 = n1.next;
}
while(n1 != null)
{
n2 = n2.next;
n1 = n1.next;
}
System.out.println(n2.data);
return n2;
}
//查找单链表的中间结点: getMiddleNode
public static Node getMiddleNode(Node head) {
if(head == null || head.next == null) return head;
Node n1 = head;
Node n2 = head;
while(n2 != null && n2.next != null) {
n1 = n1.next;
n2 = n2.next.next;
}
//System.out.println(n1.data);
return n1;
}
//已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序: mergeSortedList
public static Node mergeSortedList(Node head1, Node head2) {
if(head1 == null) return head2;
if(head2 == null) return head1;
Node target = null;
if(head1.data > head2.data) {
target = head2;
head2 = head2.next;
} else {
target = head1;
head1 = head1.next;
}
target.next = null;
Node newHead = target;
while(head1 != null && head2 != null) {
if(head1.data > head2.data) {
target.next = head2;
head2 = head2.next;
} else {
target.next = head1;
head1 = head1.next;
}
target.next = null;

     if(head1 == null) {
         target.next = head2;
     } else {
        target.next = head1; 
     }

return newHead;
}
//已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序(递归实现): mergeSortedListRec
public static Node mergeSortedListRec(Node head1, Node head2) {
if(head1 == null) return head2;
if(head2 == null) return head1;
Node head = null;
if(head1.data > head2.data) {
head = head2;
head.next = mergeSortedListRec(head2.next, head1);
} else {
head = head1;
head.next = mergeSortedListRec(head1.next, head2);
}
return head;
}
//将链表的后半部分进行反转
public static Node reversePartNode(Node head){
Node flag = head;
Node cur = null;
Node mid = getMiddleNode(head);

     while(flag.next != mid) {     //取出中间节点的 前一个节点并保存
         flag = flag.next;
     }
     Node pre = null;
     //System.out.println("----" + flag.data);
    while(mid != null) {
         cur = mid.next;
         mid.next = pre; 
         pre = mid;
         mid = cur;
     } 
    
     flag.next = pre;
     print(head);

     return head;
 }  
 //判断链表是否存在环
 public static boolean isLoop(Node head) {
     if(head == null || head.next != null) return false;
     Node fast = head;
     Node low = head;
     while(fast != null && fast.next != null) {
         low = low.next;
         fast = fast.next.next;
         if(fast == low) break;
     }
     if(fast == null || fast.next == null) return false;
     return true;
 }
 //求出环的长度
 public static int getLoopLength(Node head) {
     if(head == null || head.next != null) return 0;
     Node fast = head;
     Node low = head;
     while(fast != null && fast.next != null) {
         low = low.next;
         fast = fast.next.next;
         if(fast == low) break;
     }
     if(fast == null || fast.next == null) return 0;
     else {
         int loopLen = 1;
         while(low.next != fast) {
             loopLen++;
             low = low.next;
         }
         return loopLen;
     }
     
 }

/*
//单链表排序
public static Node listSort(Node head) {
Node nex = null;
if(head == null || head.next == null) return head;
else if(head.next.next == null) {
nex = head.next;
head.next = null;
} else {
Node mid = getMiddleNode(head);
nex = mid.next;
mid.next = null;
}
print(mergeSortedList(listSort(head), listSort(nex)));
return mergeSortedList(listSort(head), listSort(nex));
}
*/
public static void main(String[] args) {
Node head = new Node(0);
addNode(head, 6);
addNode(head, 2);
addNode(head, 1);
addNode(head, 4);
addNode(head, 3);
addNode(head, 5);
// listSort(head);
System.out.println(“顺序打印链表数据：”);
print(head);
System.out.println();
System.out.println(“反转单链表后半部分节点：”);
reversePartNode(head);
System.out.println();

     if(isLoop(head)) {
         System.out.println("存在环");
     } else System.out.println("不存在环");
     
     Node head1 = new Node(10);
     addNode(head1, 11);
     addNode(head1, 12);
     addNode(head1, 13);
     addNode(head1, 14);
     addNode(head1, 15);
     addNode(head1, 16);
     addNode(head1, 17);
     addNode(head1, 18);
     addNode(head1, 19);
     addNode(head1, 20);
     /*
     System.out.println();
     System.out.println("反转单链表后半部分节点：");
     reversePartNode(head1);
     System.out.println();
     */
     Node head2 = new Node(100);
     for(int i = 0; i < 8; i++) {
         addNode(head2, 100+i);
     }
     
     Node head3 = new Node(1000);
     for(int i = 0; i < 8; i++) {
         addNode(head3, 1001+i);
     }
     
     getListLength(head);
     System.out.println("顺序打印链表数据：");
     print(head);
 /*
 //    System.out.println();
 //    System.out.println("使用栈反转链表:");
 //    reversePrint(head);
 //    System.out.println();
 //    reversePrint2(head);
 //    System.out.println();
 //    System.out.println("递归反向遍历单链表");
 //    System.out.println("----" + head.data);
 //    reversePrintListRec(head);
 //    System.out.println();
 //    System.out.println("查找单链表的倒数第K个节点的值");
 //    reGetKthNode(head, 3);
 //    System.out.println();
 //    System.out.println("查找单链表的中间节点的值");
 //    getMiddleNode(head);
 //    System.out.println();
 //    System.out.println("合并两个单链表：");
 //    Node mergeHead = mergeSortedList(head, head1);
 //    print(mergeHead);
 //    System.out.println();
 //    System.out.println("递归实现合并两个单链表：");
 //    Node mergeHeadRec = mergeSortedListRec(head2, head3);
 //    print(mergeHeadRec);
     */
 } 

}