单链表节点定义
/**
* className:LNode
*
* @author:zjl
* @version:0.1
* @date:2020/7/1622:25
* @since:jdk1.8
*/
public class LNode {
private Object data;
private LNode next;
public LNode() {
this.data = null;
this.next = null;
}
public LNode(LNode next) {
this.next = next;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public LNode getNext() {
return next;
}
public void setNext(LNode next) {
this.next = next;
}
}
单链表定义
/**
* className:LinkList
*
* @author:zjl
* @version:0.1
* @date:2020/7/1622:28
* @since:jdk1.8
*/
public class LinkList {
private LNode p;
public LinkList() {
this.p = new LNode();
}
public LinkList(LNode p){this.p =p;}
public LNode getP() {
return p;
}
public void setP(LNode p) {
this.p = p;
}
}
单链表逆置实现及测试类
/**
* className:LinkListInverse
*
* @author:zjl
* @version:0.1
* @date:2020/7/1622:23
* @since:jdk1.8
*/
public class LinkListInverse {
public static void main(String[] args) {
//创建一个单链表
LinkList linkList = new LinkList();
LNode p = linkList.getP();
for (int i = 0; i <10 ; i++) {
LNode lNode = new LNode();
lNode.setData(i);
p.setNext(lNode);
p=p.getNext();
}
//输出原始链表
System.out.print("原始链表linkList:");
show(linkList);
//使用方法①逆置链表linkList得到linkList1
LinkList linkList1 = method1(linkList);
System.out.println();
//输出方法①逆置后的链表linkList1
System.out.print("使用方法①逆置链表linkList得到linkList1:");
show(linkList1);
//使用方法②逆置链表linkList1得到linkList2
LinkList linkList2 = method2(linkList1);
System.out.println();
//输出方法②逆置后的链表linkList2
System.out.print("使用方法②逆置链表linkList1得到linkList2:");
show(linkList2);
//使用方法③逆置链表linkList1得到linkList3
LinkList linkList3 = method3(linkList);
System.out.println();
//输出方法③逆置后的链表linkList3
System.out.print("使用方法③逆置链表linkList2得到linkList3:");
show(linkList3);
}
/**
* 方法① 头插法 将头节点之后的节点依次次用头插法插入到头节点之后
* 插入到头节点后
* @param linkList
* @return
*/
public static LinkList method1(LinkList linkList){
LNode r = linkList.getP().getNext();//始终指向要进行插入操作的节点
LNode t;
while (r!=null){
t=r.getNext();//暂存r节点的next域
r.setNext(linkList.getP().getNext());//第一个节点next域会指向自己
if(linkList.getP().getNext()==r) //并且最后会成为尾节点
r.setNext(null); //将其next域置为null
linkList.getP().setNext(r);
r=t;
}
return linkList;
}
/**
* 方法② 就地逆置
* @param linkList
* @return
*/
public static LinkList method2(LinkList linkList){
LNode p=linkList.getP().getNext();//初始时候p指向第1个节点
LNode q =p.getNext();//初始时候p指向第2个节点
while (q!=null){
LNode temp = q.getNext();//暂存p的next域名
q.setNext(p);//q的next指针指向其前驱结点
p=q; //p后移
q=temp;//q后移
}
linkList.getP().getNext().setNext(null);//尾节点next域置为null
linkList.getP().setNext(p);//使用原头节点作为逆置后链表的头节点
return linkList;
}
/**
* 方法③ 递归法 核心部分在inverse(LNode head)方法中
* @param linkList
* @return
*/
public static LinkList method3(LinkList linkList){
LNode k = linkList.getP();
LNode t =k.getNext();
LNode node = inverse(t); //调用方法将从头结点之后的链表逆置
k.setNext(node); //将逆置的链表链接在头结点之后
return linkList;
}
public static LNode inverse(LNode head){
if(head.getNext()==null)
return head;
LNode node = inverse(head.getNext()); //最终node指向原链表的尾结点
head.getNext().setNext(head);
head.setNext(null);
return node;
}
/**
* 控制台输出链表
* @param linkList
*/
public static void show(LinkList linkList){
LNode p = linkList.getP();
while (p.getNext()!=null){
p = p.getNext();
System.out.print(p.getData());
if(p.getNext()==null)
continue;
System.out.print("->");
}
}
}
单链表逆置测试结果
顺序表【数组】逆置实现及测试类
/**
* className:SeListInvers
*
* @author:zjl
* @version:0.1
* @date:2020/7/1621:51
* @since:jdk1.8
*/
public class SeListInvers {
public static void main(String[] args) {
//Test
int a[] = {0,1,2,3,4,5,6,7,8,9};
System.out.println("============逆置前的数组a=============");
for (int i : a) {
System.out.print(i+" ");
}
//逆置
int[] ls = sequenceListInvers(a);
System.out.println("\n============逆置后的数组a=============");
for (int i : ls) {
System.out.print(i+" ");
}
System.out.println("\n======================================");
}
/**
* 顺序表(数组)逆置
* @param objs
* @return
*/
public static int[] sequenceListInvers(int[] sl ){
int temp;
int i,j;
i=0;j=sl.length-1;
while (i<j){
temp = sl[j];
sl[j] = sl[i];
sl[i] = temp;
i++;
j--;
}
return sl;
}
}
顺序表(数组)逆置测试结果