单链表和双链表如何反转

1.概述
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点；
链表是由结点构成，head指针指向第一个成为表头结点，而终止于最后一个指向NULL的指针。
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

//1.单项链表
@Test
public void node() {
//拼接链表：
Node headNode = new Node(0);
Node current = headNode;
int[] a = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
Node temp = new Node(a[i]);
current.setNext(temp);//当前节点是指向2 添加新的接点(next)3
current = temp; //把这个节点地址从指向2 变成指向3
}
//单链表双链表
//1.单链表和双链表如何反转
//2.把给定值删除
Node pre=null;
Node next =null;
while(headNode!=null){
next=headNode.getNext(); //第一个几点
headNode.setNext(pre); //pre 第二个节点 set第一个节点
pre=headNode; // 得到倒叙head 的节点存入 pre
headNode=next; //初始head 节点
}
System.out.println(pre.toString());

//单链表去除某一个值
public Node removeNode(Node head, int num) {

    while (head != null) {
        if (head.value != num) {
            break;
        }
        head = head.next;
    }
    Node pre = head;
    Node cur = head;
    while (cur != null) {
        if (cur.value == num) {
            pre.next = cur.next;
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    return head;
}

//2.双向链表曾删改查

/**

双向链表-节点类
/
public class DoubleNode {
int value;
String name;
DoubleNode next;
DoubleNode pre;
}
/*
双向链表-链表类
*/
public class DoubleLinkedClass {
// 实际存储元素个数
int size;
// 双向链表的头节点
private DoubleNode first;
// 双向链表的尾节点
private DoubleNode last;

//头插法
public void addFirst(int val){
// 暂存头节点
DoubleNode head = first;
// 1.先 new 一个节点
DoubleNode node = new DoubleNode(val);
// 2.再将头节点指向新插入的节点
first = node;
// 注意判空
if (head == null) {
// 如果链表为空，尾节点就是头节点
last = node;
} else { // 3.将新节点的后继与原来的第一个元素相连，再将原来第一个节点的前驱与新节点相连
node.next = head;
head.pre = node;
}
size++;
System.out.println(“dfksjfi”);
System.out.println(head.toString());
}

// 尾插法
public void addLast(int val) {
DoubleNode l = last;
DoubleNode node = new DoubleNode(val);
last = node;
// 注意判空
if (l == null) {
// 头节点就是尾节点
first = node;
} else {
node.pre = l;
l.next = node;
}
size++;
System.out.println(“dfksjfi”);
}
//初始化头节点
private DoubleNode head = new DoubleNode(0 );
//返回头节点
public DoubleNode getHead(){
return head;
}
/**
- 双向链表节点的添加节点间是相互独立的用上下指针来进行关系链接
- @param heroNode
  */
  public void add(DoubleNode heroNode){
  DoubleNode temp = head;
  while(true){
  if(temp.next == null){
  break;
  }
  temp = temp.next;
  }
  //形成双向链表
  temp.next = heroNode;
  heroNode.pre = temp;
  }
public void addByOrder(DoubleNode heroNode){
DoubleNode temp = head;
boolean flag = false;
while(true){
if(temp.next == null){
break;
}
if(temp.next.value == heroNode.value){
flag = true;
break;
}
if(temp.next.value > heroNode.value){
break;
}
temp = temp.next;
}
```
 if(flag){
     System.out.println("要添加的节点编号已经存在");
 }else{
     if (temp.next != null) {
         temp.next.pre = heroNode;  //heroNode和后一个节点建立链接
         heroNode.next = temp.next;
     }
     temp.next = heroNode; //heroNode和前一个节点建立链接
     heroNode.pre = temp;
 }
```
}

/**
- 双向链表节点的修改
- @param newHeroNode
  */
  public void update(DoubleNode newHeroNode){
  if(head.next == null){
  System.out.println(“链表为空”);
  return;
  }
  DoubleNode temp = head.next;
  boolean flag = false;
  while(true){
  if(temp == null){
  break;
  }
  if(temp.value == newHeroNode.value){
  flag = true;
  // break;
  }
  if(flag){
  temp.name = newHeroNode.name;
  flag = false;
  // temp.nickname = newHeroNode.nickname;
  }else {
  System.out.println(“没有找到编号为” + newHeroNode.value + “的节点”);
  }
  temp = temp.next;
  }
}

/**
- 双向链表中节点的删除
- @param no
  */
  public void delete(int no){
  
  //这里与单链表不同的是，直接从head后第一个节点开始找就可以，辅助指针直接指向第一个有效节点
  if(head.next == null){
  System.out.println(“链表为空”);
  return;
  }
  DoubleNode temp = head.next;
  boolean flag = false;
  while(true){
  if(temp.next == null){
  break;
  }
  if(temp.next.value == no){
  flag = true;
  break;
  }
  temp = temp.next;
  }
  if(flag){
  // //找到待删除的节点位置
  // temp.pre.next = temp.next;
  // //注意，如果是最后一个节点，就不需要执行下面这段话
  // if(temp.next != null) {
  // temp.next.pre = temp.pre;
  // }
  //去除的是最后一个节点
  if(temp.next.next==null){
  temp.next.pre=null;
  temp.next=null;
  }
  //如果不是最后一个节点
  if(temp.next.next!=null){
  temp.next.next.pre=temp.next.pre;
  temp.next= temp.next.next;
  }
  }else {
  System.out.println(“要删除的编号为” + no + “节点不存在”);
  }
  }
/**
- 双向链表节点的遍历
  */
  public void list(){
  if(head.next == null){
  System.out.println(“链表为空”);
  return;
  }
  
  DoubleNode temp = head.next;
  while(true){
  if(temp == null){
  break;
  }
  //输出节点信息
  System.out.println(temp);
  temp = temp.next;
  }
  }
@Test
public void testNode(){
DoubleNode node = new DoubleNode(6);
DoubleNode node1 = new DoubleNode(2);
DoubleNode node2 = new DoubleNode(3);
DoubleNode node3 = new DoubleNode(2);
//初始化头节点
DoubleLinkedClass linkedClass=new DoubleLinkedClass();
linkedClass.add(node);
linkedClass.add(node1);
linkedClass.add(node2);
linkedClass.addByOrder(node3);

// first=node;
// int val=4;
// addFirst(val);
// addLast(5);
System.out.println(“sdkfjshdkfh”);

    linkedClass.list();

// System.out.println(“---------------------------------------------------------”);
// //修改
DoubleNode newHeroNode = new DoubleNode(2,“nike”);
linkedClass.update(newHeroNode);
linkedClass.list();
System.out.println(“---------------------------------------------------------”);
//
// //删除
linkedClass.delete(2);
linkedClass.list();
System.out.println(“---------------------------------------------------------”);
//
// //按照顺序添加
// HeroNode2 newHeroNode2 = new HeroNode2(6,“科科”,“小马”);
// HeroNode2 newHeroNode3 = new HeroNode2(5,“菲菲”,“小羊”);
// linkedClass.addByOrder(newHeroNode2);
// linkedClass.addByOrder(newHeroNode3);
// linkedClass.list();
System.out.println(“---------------------------------------------------------”);
}
}

单链表和双链表如何反转

猜你喜欢