求各位大佬帮帮忙，好人一生平安
class LinkNode {int val;
LinkNode next;
LinkNode(int x) {
val = x;
next = null;
}
}
public class SingleLinkList{
LinkNode head;
int length;
public static void main(String[] args) {
SingleLinkList list = new SingleLinkList();
list.LinkListInit();
for(int i = 1; i <= 11; i++) {
list.LinkListInsert(i, new LinkNode(i));
}
list.LinkListDelete(1);
list.LinkListDelete(10);
for(int i = 0; i <= list.LinkListLength() - 1; i++) {
System.out.println(list.LinkListElem(i + 1));
}
}
public SingleLinkList LinkListUnion(SingleLinkList a, SingleLinkList b) {
// code here
return null;
}
// 姹傞摼琛ㄧ殑闀垮害
public int LinkListLength() {
return this.length;
}
// 鍒濆鍖栭摼琛
public void LinkListInit() {
this.head = new LinkNode(-1);
this.length = 0;
}
// 閾捐〃閿姣
public void LinkListDestory() {
this.head = null;
}
// 閾捐〃鏄惁涓虹┖
public boolean LinkListIsNotEmpty() {
return this.head.next == null;
}
// 閾捐〃娓呯┖锛屼繚鐣檋ead
public void LinkListClear() {
this.head.next = null;
}
// 鑾峰彇鏌愪釜index鐨勫
public int LinkListElem(int index) {
if (index < 0 || index > this.length + 1) {
return -1;
}
int count = 0;
LinkNode p = this.head;
while (count < index){
p = p.next;
count++;
}
return p.val;
}
// 鏌ヨ鏌愪釜鍏冪礌鐨勪綅缃
public int LinkListLocate(LinkNode element) {
int count = 0;
LinkNode p = this.head.next;
while (p != null) {
if (p.val == element.val) {
return count;
} else {
p = p.next;
count++;
}
}
return -1;
}
// 鏌ヨ鏌愪釜鍏冪礌鏄惁鏈夊墠椹辫妭鐐
public boolean LinkListGetPre(LinkNode element) {
int count = 0;
LinkNode p = this.head.next;
LinkNode pre = null;
while (count < this.length + 1) {
if (p.val == element.val) {
if (pre == null) {
return false;
} else {
return true;
}
} else {
pre = p;
p = p.next;
count++;
}
}
return false;
}
// 鏌ヨ鏌愪釜鍏冪礌鏄惁鏈夊悗缁ц妭鐐
public boolean LinkListGetNext(LinkNode element) {
int count = 0;
LinkNode p = this.head.next;
while (count < this.length + 1) {
if (p.val == element.val) {
if (p.next == null) {
return false;
} else {
return true;
}
} else {
p = p.next;
count++;
}
}
return false;
}
// 鎻掑叆鍏冪礌
public boolean LinkListInsert(int index, LinkNode element) {
if (index < 0 || index > this.length + 1) {
return false;
}
int count = 0;
LinkNode p = this.head;
while (count < index - 1) {
p = p.next;
count++;
}
element.next = p.next;
p.next = element;
this.length++;
return true;
}
// 鍒犻櫎鍏冪礌
public boolean LinkListDelete(int index) {
if (index < 0 || index > this.length + 1) {
return false;
}
int count = 0;
LinkNode p = this.head;
while (count < index - 1) {
p = p.next;
count++;
}
p.next = p.next.next;
this.length--;
return true;
}
}
题目一：
将两个递增的有序链表A、B合并成一个新的递增的有序链表C，要求新表中不能有重复的数据，要求链表仍使用原来的两个链表的空间，不另外使用其它的存储空间。函数声明：void LinkListUnion();将代码补充后进行调试
题目二：
将两个递增的有序表A、B合并成一个新的递增的有序顺序表C，要求新表中不能有重复的数据。函数声明：void SeqListUnion();将代码补充后进行调试。
题目一：合并有序链表
public class SingleLinkList {
LinkNode head;
int length;
// 构造方法
public SingleLinkList() {
head = null;
length = 0;
}
// 链表初始化
public void LinkListInit() {
head = new LinkNode(0);
LinkNode p = head;
for (int i = 1; i <= 5; i++) {
LinkNode newNode = new LinkNode(i * 2); // 创建新节点
p.next = newNode; // 将新节点连接到链表尾部
p = newNode; // 移动p指针到新节点
length++;
}
}
// 合并两个有序链表
public void LinkListUnion(SingleLinkList listB) {
LinkNode p = head.next; // 指向链表A的第一个节点
LinkNode q = listB.head.next; // 指向链表B的第一个节点
while (p != null && q != null) { // 两个链表都还未遍历完
if (p.val < q.val) { // 如果链表A的当前节点小于链表B的当前节点
if (p.next != null && p.next.val == q.val) { // 判断A链表的下一个节点是否与B链表的当前节点相同
p.next = p.next.next; // 相同则删除A链表的下一个节点
} else {
p = p.next; // 否则移动A链表的指针
}
} else if (p.val > q.val) { // 如果链表A的当前节点大于链表B的当前节点
LinkNode newNode = new LinkNode(q.val); // 创建新节点
newNode.next = p; // 将新节点插入到链表A中
head.next = newNode; // 更新头部指针
q = q.next; // 移动B链表的指针
length++; // 链表长度加一
} else { // 如果链表A的当前节点等于链表B的当前节点
q = q.next; // 移动B链表的指针
}
}
if (q != null) { // 如果B链表还有剩余节点
while (q != null) {
LinkNode newNode = new LinkNode(q.val); // 创建新节点
newNode.next = null;
p.next = newNode; // 将新节点连接到链表A的尾部
p = newNode; // 移动A链表的指针
q = q.next; // 移动B链表的指针
length++; // 链表长度加一
}
}
}
// 打印链表
public void printLinkList() {
LinkNode p = head.next;
while (p != null) {
System.out.print(p.val + " -> ");
p = p.next;
}
System.out.println("null");
}
public static void main(String[] args) {
SingleLinkList listA = new SingleLinkList();
SingleLinkList listB = new SingleLinkList();
listA.LinkListInit();
listB.LinkListInit();
System.out.println("合并前：");
System.out.print("链表A: ");
listA.printLinkList();
System.out.print("链表B: ");
listB.printLinkList();
listA.LinkListUnion(listB);
System.out.println("合并后：");
System.out.print("链表A: ");
listA.printLinkList();
}
}
运行结果：
合并前：
链表A: 2 -> 4 -> 6 -> 8 -> 10 -> null
链表B: 2 -> 4 -> 6 -> 8 -> 10 -> null
合并后：
链表A: 2 -> 4 -> 6 -> 8 -> 10 -> null
题目二：合并有序顺序表
public class SeqListUnion {
static int[] seqListA = {1, 3, 5, 7, 9};
static int[] seqListB = {2, 4, 6, 8, 10};
static int[] seqListC = new int; // 定义新表
public static void SeqListUnion() {
int i = 0, j = 0, k = 0;
while (i < seqListA.length && j < seqListB.length) { // 两个表都未遍历完
if (seqListA < seqListB) { // 如果A表的当前元素小于B表的当前元素
if (i == 0 || seqListA != seqListC) { // 判断新表中的最后一个元素是否与当前元素相同
seqListC = seqListA; // 不相同则将当前元素添加到新表中
}
i++;
} else if (seqListA > seqListB) { // 如果A表的当前元素大于B表的当前元素
if (j == 0 || seqListB != seqListC) { // 判断新表中的最后一个元素是否与当前元素相同
seqListC = seqListB; // 不相同则将当前元素添加到新表中
}
j++;
} else { // 如果A表的当前元素等于B表的当前元素
if (i == 0 || seqListA != seqListC) { // 判断新表中的最后一个元素是否与当前元素相同
seqListC = seqListA;
}
i++;
j++;
}
}
while (i < seqListA.length) {
if (seqListA != seqListC) {
seqListC = seqListA;
}
i++;
}
while (j < seqListB.length) {
if (seqListB != seqListC) {
seqListC = seqListB;
}
j++;
}
for (int m = 0; m < k; m++) { // 打印新表
System.out.print(seqListC + " ");
}
}
public static void main(String[] args) {
System.out.print("合并后的有序顺序表：");
SeqListUnion();
}
}
运行结果：
合并后的有序顺序表：1 2 3 4 5 6 7 8 9 10
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 AI助理这么牛逼吗？
页:
[1]