文章主要是对链表进行一些操作,下面是相关代码:
ListNode类
package com.cs.algorithm.algorithm;
public class ListNode {
public ListNode() {
}
public ListNode(int val, ListNode nextnode) {
super();
this.val = val;
this.nextnode = nextnode;
}
private int val;
private ListNode nextnode;
public int getVal() {
return val;
}
public void setVal(int val) {
this.val = val;
}
public ListNode getNextnode() {
return nextnode;
}
public void setNextnode(ListNode nextnode) {
this.nextnode = nextnode;
}
}
package com.cs.algorithm.algorithm;
import java.util.HashMap;
import java.util.Map;
public class App
{
public static ListNode getList(int count) {
ListNode head = new ListNode();
ListNode r = head;
for(int i = 0; i < count; i++) {
ListNode node = new ListNode();
//node.setVal(new Random().nextInt(count));
node.setVal(i);
r.setNextnode(node);
r = node;
}
return head;
}
public static void scanList(ListNode node) {
if(null == node) return;
while(node.getNextnode() != null) {
node = node.getNextnode();
System.out.println(node.getVal()+"");
}
}
//链表普通反转
public static void reserveList(ListNode node) {
if(null == node || null == node.getNextnode()) return;
ListNode head = node;
ListNode pre = null;
ListNode next = null;
node = node.getNextnode();
while(node.getNextnode() != null) {
next = node.getNextnode();
node.setNextnode(pre);
pre = node;
node = next;
}
node.setNextnode(pre);
head.setNextnode(node);
node = head;
}
//链表递归反转
public static ListNode reserveOtherList(ListNode head,ListNode node) {
if(null == node) {
return node;
}
if(node.getNextnode() == null) {
head.setNextnode(node);
}
ListNode temp = reserveOtherList(head,node.getNextnode());
if(temp != null) {
//if(temp.getNextnode() != null) {
temp.setNextnode(node);
//}
}
node.setNextnode(null);
return node;
}
//链表中环的检测
public static boolean checkCircle(ListNode node) {
boolean bret = false;
if(null == node) return bret;
node = node.getNextnode();
Map<ListNode,String> map = new HashMap<>();
while(node != null) {
if(map.containsKey(node)) {
bret = true;
break;
}
map.put(node, "1");
node = node.getNextnode();
}
return bret;
}
//链表中环的检测
public static boolean checkOtherCircle(ListNode node) {
boolean bret = false;
if(null == node) return bret;
ListNode fastnode = node.getNextnode(),slownode = node;
while(slownode != null) {
if(null == fastnode) {
bret = false;
break;
}
if(slownode == fastnode) {
bret = true;
break;
}
slownode = slownode.getNextnode();
fastnode = fastnode.getNextnode().getNextnode();
}
return bret;
}
//两个有序链表合并
public static ListNode combinList(ListNode firstnode,ListNode secondnode) {
ListNode head = new ListNode();
ListNode curhead = head;
ListNode ohead = firstnode;
firstnode = firstnode.getNextnode();
ohead.setNextnode(null);
ohead = secondnode;
secondnode = secondnode.getNextnode();
ohead.setNextnode(null);
while(firstnode != null && secondnode != null) {
if(firstnode.getVal() < secondnode.getVal()) {
head.setNextnode(firstnode);
head = firstnode;
firstnode = firstnode.getNextnode();
}else if(firstnode.getVal() > secondnode.getVal()){
head.setNextnode(secondnode);
head = secondnode;
secondnode = secondnode.getNextnode();
}else {
ListNode firstnext = firstnode.getNextnode();
ListNode secondnext = secondnode.getNextnode();
head.setNextnode(firstnode);
firstnode.setNextnode(secondnode);
head = secondnode;
firstnode = firstnext;
secondnode = secondnext;
}
head.setNextnode(null);
}
if(firstnode != null) {
head.setNextnode(firstnode);
}else if(secondnode != null) {
head.setNextnode(secondnode);
}
return curhead;
}
//删除链表中倒数第n个节点
/*
* 思路:
* 两个指针,一个先走n-1步(从head开始),然后一起走,先走的指针到了尾部,那么后走的指针所在的位置就是要求的节点
* 为什么是这样,可以这样想,针对后走的指针,要保证先走的指针刚到尾部,后走的指针刚好到达指定的点,后走的点离尾点
* 相差的就是先走的指针领先的步伐。
*/
public static void deletePosNode(ListNode node,int n) {
ListNode flow = node;
ListNode fast = node;
ListNode preflow = node;
int ncount = 0;
while(fast.getNextnode() != null) {
if(ncount++ >= n - 1) {
preflow = flow;
flow = flow.getNextnode();
}
fast = fast.getNextnode();
}
//此时flow所在的点就是要删除的点
preflow.setNextnode(flow.getNextnode());
flow = null;
}
//获取链表的中间节点
public static ListNode getMidleNode(ListNode node) {
ListNode flow = node.getNextnode();
ListNode fast = node.getNextnode();
while(fast != null && fast.getNextnode() != null) {
flow = flow.getNextnode();
fast = fast.getNextnode().getNextnode();
}
return flow;
}
public static void main( String[] args )
{
ListNode node = getList(10);
//遍历链表
scanList(node);
System.out.println("链表反转后");
//反转链表
/*reserveList(node);
scanList(node);*/
//递归反转链表
reserveOtherList(node,node.getNextnode());
scanList(node);
//node.getNextnode().getNextnode().getNextnode().setNextnode(node);
if(checkCircle(node)) {
System.out.println("存在环");
}else {
System.out.println("不存在环");
}
ListNode deletenode = getList(10);
System.out.println("删除点前的链表为:");
scanList(deletenode);
System.out.println("中间节点值为"+getMidleNode(deletenode).getVal());
deletePosNode(deletenode,5);
System.out.println("删除点后的链表为:");
scanList(deletenode);
System.out.println("中间节点值为"+getMidleNode(deletenode).getVal());
deletePosNode(deletenode,2);
System.out.println("删除点后的链表为:");
scanList(deletenode);
System.out.println("中间节点值为"+getMidleNode(deletenode).getVal());
System.out.println("--------------------");
//ListNode node1 = getList(10);
//ListNode node2 = getList(10);
ListNode node10 = new ListNode(19,null);
ListNode node11 = new ListNode(12,node10);
ListNode node12 = new ListNode(9,node11);
ListNode node13 = new ListNode(5,node12);
ListNode node14 = new ListNode(1,node13);
ListNode node15 = new ListNode(0,node14);
ListNode node22 = new ListNode(17,null);
ListNode node23 = new ListNode(16,node22);
ListNode node24 = new ListNode(8,node23);
ListNode node25 = new ListNode(4,node24);
ListNode node26 = new ListNode(2,node25);
ListNode node27 = new ListNode(0,node26);
scanList(combinList(node15,node27));
}
}