java单链表头插法
时间: 2024-01-21 20:14:55 浏览: 35
单链表的头插法是指将新节点插入到链表的头部位置。具体实现步骤如下:
1. 创建一个新节点,并将要插入的值赋给新节点的数据域。
2. 将新节点的指针域指向原链表的头节点。
3. 将新节点设置为链表的头节点。
以下是Java实现单链表头插法的代码示例:
```java
public class LinkedList {
private Node head; // 链表头节点
private class Node {
int data; // 节点数据
Node next; // 指向下一个节点的指针
public Node(int data) {
this.data = data;
this.next = null;
}
}
public void insertAtHead(int data) {
Node newNode = new Node(data); // 创建新节点
if (head == null) {
head = newNode; // 如果链表为空,将新节点设置为头节点
} else {
newNode.next = head; // 将新节点的指针域指向原链表的头节点
head = newNode; // 将新节点设置为链表的头节点
}
}
}
```
相关问题
java单链表的冒泡排序
Java单链表的冒泡排序可以通过以下步骤实现:
1. 定义一个Node类表示链表节点,包含一个int类型的数据成员和一个指向下一个节点的指针。
2. 定义一个单链表类LinkedList,包含一个指向头节点的指针和一个排序方法bubbleSort()。
3. 在bubbleSort()方法中,使用两个嵌套的循环,外层循环控制排序的轮数,内层循环控制每一轮的比较和交换。
4. 在内层循环中,比较相邻两个节点的数据大小,如果前一个节点的数据大于后一个节点的数据,则交换它们的数据。
5. 在每一轮排序结束后,将最大的节点移动到链表的末尾,下一轮排序时不再考虑该节点。
6. 最后返回排序后的链表头节点。
以下是Java单链表的冒泡排序的代码实现:
```
public class Node {
int data;
Node next;
public Node(int data) {
this.data = data;
this.next = null;
}
}
public class LinkedList {
Node head;
public LinkedList() {
this.head = null;
}
public void bubbleSort() {
if (head == null || head.next == null) {
System.out.println("needn't order.");
return;
}
Node cur = head;
while (cur != null) {
Node pre = null;
Node next = cur.next;
boolean flag = false;
while (next != null) {
if (cur.data > next.data) {
flag = true;
if (pre != null) {
pre.next = next;
} else {
head = next;
}
cur.next = next.next;
next.next = cur;
pre = next;
next = cur.next;
} else {
pre = cur;
cur = next;
next = next.next;
}
}
if (!flag) {
break;
}
}
}
}
```
java单链表就地逆置
以下是Java实现单链表就地逆置的代码:
```
public class ListNode {
int val;
ListNode next;
public ListNode(int val) {
this.val = val;
this.next = null;
}
}
public class Solution {
public ListNode reverseList(ListNode head) {
if (head == null || head.next == null) {
return head;
}
ListNode prev = null;
ListNode curr = head;
while (curr != null) {
ListNode temp = curr.next;
curr.next = prev;
prev = curr;
curr = temp;
}
return prev;
}
}
```
主要思路是从头开始遍历链表,每次将当前节点的next指向前面的节点,然后将prev指向当前节点,当前节点指向下一个节点,继续遍历下去,直到遍历完整个链表。最后返回prev即为逆置后的链表头。