数组去重,合并两个有序表,按顺序合并两个顺序有序表(非递减)(数组+链表实现)

已于 2024-03-23 15:27:16 修改
阅读量112 收藏
点赞数 4
分类专栏： java数据结构和算法 文章标签： 链表 java 数据结构
于 2024-03-23 13:48:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44847284/article/details/136965996
版权

数组去重

    //数组去重 设置一个指针定义,只会添加一个
    @Test
    public void testOrderOne() {
        int[] arr1 = {1, 7, 8};
        int[] arr2 = {1, 2, 7, 8, 9, 10, 22};
        int[] arr3 = new int[arr1.length + arr2.length];
        int index = 0;
        //        while(index<arr1.length&&index<arr2.length){
        //            if(arr1[index]<=arr2[index]){
        //                arr3[index]=arr1[index];
        //            }else {
        //                arr3[index]=arr2[index];
        //            }
        //                 index++;
        // }
        while(index<arr1.length&&index<arr2.length) {
            arr3[index] = arr1[index] < arr2[index] ? arr1[index] : arr2[index];
            index++;
        }

        if(index>=arr1.length){ //先遍历完了arr1,继续添加arr2
         //就循环添加
            while(index<arr2.length){
                arr3[index]=arr2[index];
                index++;
            }
        }else{
            while(index<arr1.length){
                arr3[index]=arr1[index];
                index++;
            }
        }
        for (int i = 0; i <index; i++) {
            System.out.println(arr3[i]);
        }

    }

合并两个有序表(数组+链表)

       数组实现

 //1.合并两个有序表(数组+链表)
    @Test //数组
    public void testArrayUnion(){
        int[] arr2={1,7,8};
        int[]arr1={1,2,7,8,9,10,22};
        int[]arr3=new int[arr1.length+arr2.length];
        int index=0;
        int index1=0;
        int index2=0;
        while(index1<arr1.length&&index2<arr2.length){
            if(arr1[index1]<=arr2[index2]){
                arr3[index]=arr1[index1];
                index++;
                index1++;
            }else {
                arr3[index]=arr2[index2];
                index++;
                index2++;
            }
            //            arr3[index]=arr1[index]<arr2[index]?arr1[index]:arr2[index];
            //            index++;
        }

        if(index1>=arr1.length){ //先遍历完了arr1,继续添加arr2
            //就循环添加
            while(index2<arr2.length){
                arr3[index]=arr2[index2];
                index2++;
                index++;
            }
        }else{//先遍历完了arr2,继续添加arr1
            while(index1<arr1.length){
                arr3[index]=arr1[index1];
                index1++;
                index++;
            }
        }
        for (int i = 0; i <arr3.length; i++) {
            System.out.println(arr3[i]);
        }

    }

链表实现

import org.junit.Test;
public class UnionTwoLink {
 
    @Test //链表
    public void testLinkUnion(){
        //两个有序单链表合并(不按照顺序)
        SingLinkListUnion singLinkList1=new SingLinkListUnion();
        SingLinkPool s1=new SingLinkPool(1);
        SingLinkPool s2=new SingLinkPool(7);
        SingLinkPool s3=new SingLinkPool(8);
        singLinkList1.add(s1);
        singLinkList1.add(s2);
        singLinkList1.add(s3);
        SingLinkListUnion singLinkList2=new SingLinkListUnion();
        SingLinkPool s4=new SingLinkPool(1);
        SingLinkPool s5=new SingLinkPool(7);
        SingLinkPool s6=new SingLinkPool(8);
        SingLinkPool s7=new SingLinkPool(17);
        SingLinkPool s8=new SingLinkPool(4);
        SingLinkPool s9=new SingLinkPool(88);
        singLinkList2.add(s4);
        singLinkList2.add(s5);
        singLinkList2.add(s6);
        singLinkList2.add(s7);
        singLinkList2.add(s8);
        singLinkList2.add(s9);
        //合并到新链表
        System.out.println("链表1:");
        singLinkList1.show();
        System.out.println("链表2:");
        singLinkList2.show();
        //数据初始化完毕
        //定义链表一指针，和链表二指针
        SingLinkPool index1=singLinkList1.getHead();
        SingLinkPool index2=singLinkList2.getHead();
        //不能和前面数组一样方式，要不然每次都要new SingLinkPool()添加到新链表内,否则抛出空指针异常
        SingLinkPool index3=index1; //假设index3->index1 || index3->index2 都可以
        //
        while((index1=index1.next)!=null){
            index3=index3.next;
            index3.data=index1.data;
        }
        while((index2=index2.next)!=null){
            index3.next=index2;
            index3=index3.next;
        }
        System.out.println("新链表:");
        singLinkList1.show();
    }
}

class SingLinkListUnion{
    SingLinkPool head=new SingLinkPool();//定义头节点

    public SingLinkPool getHead() {
        return head;
    }

    //向链表尾部添加
    public void add(SingLinkPool singLinkPool){
        SingLinkPool temp=head;
        while(temp.next!=null){
            temp=temp.next;
        }
        //当temp.next指向空时跳出循环
        temp.next=singLinkPool;
    }
    //遍历链表
    public void  show(){
        SingLinkPool temp=head.next;
        if(temp==null){
            System.out.println("链表为空~ ~");
            return;
        }
        while(temp!=null){
            System.out.println(temp.toString());
            temp=temp.next;
        }
    }
}
//定义单链表结构
class SingLinkPool{
    public int data; //值
    public SingLinkPool next;
    public SingLinkPool() { }
    public SingLinkPool(int data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "SingLinkPool{" + "data=" + data + '}';
    }
}

按递增顺序合并两个递增顺序有序表(数组+链表)

        数组实现

 //数组实现
    @Test
    public void testIncrementArrayUnion(){
        int[] arr1 = {1, 3,7, 8, 8,10};
        int[] arr2 = {1, 2, 7, 8, 9,9,10, 22};
        int[] arr3 = new int[arr1.length + arr2.length];
        //思路: 1.先遍历arr1 如果arr1中小于arr2中数就添加到arr3
        //2.反之比arr2中大,就再去遍历arr2，谁小谁先添加进arr3
        int index1=0;
        int index2=0;
        int index=0;
        //必须加上判断条件  要不然去下一个while循环 会数组越界
        while(index1<arr1.length&&index2<arr2.length){
                while(index1<arr1.length&&index2<arr2.length&&arr1[index1]<=arr2[index2]){
                    arr3[index]=arr1[index1]; //添加完后index=3
                    index++;
                    index1++;
                }
                //arr1[3]越界
                while (index1<arr1.length&&index2<arr2.length&&arr1[index1]>arr2[index2]){
                    arr3[index]=arr2[index2];
                    index++;index2++;
                }
        }
        //其中一个遍历完了就跳出循环
        if(index1>=arr1.length){ //arr1遍历完了，再依次把arr2中的数据添加到arr3中
            while(index2<arr2.length){
                arr3[index++]=arr2[index2++];
            }
        }else{ //反之 把arr1剩余的数据添加到arr3中
            while(index1<arr1.length){
                arr3[index++]=arr1[index1++];
            }
        }
        System.out.println("排序后:");
        for (int i = 0; i <arr3.length ; i++) {
            System.out.printf("arr[%d]=%d\t",i,arr3[i]);
        }
    }

链表实现

public class UnionTwoLink {

 //链表实现
    @Test
    public void testIncrementLinkUnion(){
        //两个有序单链表合并(不按照顺序)
        SingLinkListUnion singLinkList1=new SingLinkListUnion();
        SingLinkPool s1=new SingLinkPool(1);
        SingLinkPool s2=new SingLinkPool(2);
        SingLinkPool s3=new SingLinkPool(8);
        singLinkList1.add(s1);
        singLinkList1.add(s2);
        singLinkList1.add(s3);
        SingLinkListUnion singLinkList2=new SingLinkListUnion();
        SingLinkPool s4=new SingLinkPool(1);
        SingLinkPool s5=new SingLinkPool(3);
        SingLinkPool s6=new SingLinkPool(8);
        SingLinkPool s7=new SingLinkPool(8);
        SingLinkPool s8=new SingLinkPool(10);
        SingLinkPool s9=new SingLinkPool(88);
        singLinkList2.add(s4);
        singLinkList2.add(s5);
        singLinkList2.add(s6);
        singLinkList2.add(s7);
        singLinkList2.add(s8);
        singLinkList2.add(s9);
        //合并到新链表
        System.out.println("链表1:");
        singLinkList1.show();
        System.out.println("链表2:");
        singLinkList2.show();
        //数据初始化完毕
        //定义链表一指针，和链表二指针
        SingLinkPool index1=singLinkList1.getHead().next; //指针一
        SingLinkPool index2=singLinkList2.getHead().next; //指针二
        SingLinkPool temp=index1; //定义一个赋值指针
        //如果temp=index2  逻辑就要反过来处理
        //不能直接跳，再判断
        while(index1!=null||index2!=null){
            if(index1.data<= index2.data&&index1==temp){
                if(index1.next!=null){
                    temp=index1.next;
                    index1.next=index2;
                    index1=temp;
                    temp=index2;
                }else{
                    index1.next=index2;
                    break;
                }
            }else{
                if(index2.next!=null){
                    temp=index2.next;
                    index2.next=index1;
                    index2=temp;
                    temp=index1;
                }else{
                    index2.next=index1;
                    break;
                }
            }
        }

        System.out.println("新链表:");
        singLinkList1.show();
    }
}

class SingLinkListUnion{
    SingLinkPool head=new SingLinkPool();//定义头节点

    public SingLinkPool getHead() {
        return head;
    }

    //向链表尾部添加
    public void add(SingLinkPool singLinkPool){
        SingLinkPool temp=head;
        while(temp.next!=null){
            temp=temp.next;
        }
        //当temp.next指向空时跳出循环
        temp.next=singLinkPool;
    }
    //遍历链表
    public void  show(){
        SingLinkPool temp=head.next;
        if(temp==null){
            System.out.println("链表为空~ ~");
            return;
        }
        while(temp!=null){
            System.out.println(temp.toString());
            temp=temp.next;
        }
    }
}
//定义单链表结构
class SingLinkPool{
    public int data; //值
    public SingLinkPool next;
    public SingLinkPool() { }
    public SingLinkPool(int data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "SingLinkPool{" + "data=" + data + '}';
    }
}

上述所有代码

package link;


import org.junit.Test;


public class UnionTwoLink {

    //数组去重 设置一个指针定义,两个
    @Test
    public void testOrderOne() {
        int[] arr1 = {1, 7, 8};
        int[] arr2 = {1, 2, 7, 8, 9, 10, 22};
        int[] arr3 = new int[arr1.length + arr2.length];
        int index = 0;
        //        while(index<arr1.length&&index<arr2.length){
        //            if(arr1[index]<=arr2[index]){
        //                arr3[index]=arr1[index];
        //            }else {
        //                arr3[index]=arr2[index];
        //            }
        //                 index++;
        // }
        while(index<arr1.length&&index<arr2.length) {
            arr3[index] = arr1[index] < arr2[index] ? arr1[index] : arr2[index];
            index++;
        }

        if(index>=arr1.length){ //先遍历完了arr1,继续添加arr2
         //就循环添加
            while(index<arr2.length){
                arr3[index]=arr2[index];
                index++;
            }
        }else{
            while(index<arr1.length){
                arr3[index]=arr1[index];
                index++;
            }
        }
        for (int i = 0; i <index; i++) {
            System.out.println(arr3[i]);
        }

    }

    //1.合并两个有序表(数组+链表)
    @Test //数组
    public void testArrayUnion(){
        int[] arr2={1,7,8};
        int[]arr1={1,2,7,8,9,10,22};
        int[]arr3=new int[arr1.length+arr2.length];
        int index=0;
        int index1=0;
        int index2=0;
        while(index1<arr1.length&&index2<arr2.length){
            if(arr1[index1]<=arr2[index2]){
                arr3[index]=arr1[index1];
                index++;
                index1++;
            }else {
                arr3[index]=arr2[index2];
                index++;
                index2++;
            }
            //            arr3[index]=arr1[index]<arr2[index]?arr1[index]:arr2[index];
            //            index++;
        }

        if(index1>=arr1.length){ //先遍历完了arr1,继续添加arr2
            //就循环添加
            while(index2<arr2.length){
                arr3[index]=arr2[index2];
                index2++;
                index++;
            }
        }else{//先遍历完了arr2,继续添加arr1
            while(index1<arr1.length){
                arr3[index]=arr1[index1];
                index1++;
                index++;
            }
        }
        for (int i = 0; i <arr3.length; i++) {
            System.out.println(arr3[i]);
        }

    }

    @Test //链表
    public void testLinkUnion(){
        //两个有序单链表合并(不按照顺序)
        SingLinkListUnion singLinkList1=new SingLinkListUnion();
        SingLinkPool s1=new SingLinkPool(1);
        SingLinkPool s2=new SingLinkPool(7);
        SingLinkPool s3=new SingLinkPool(8);
        singLinkList1.add(s1);
        singLinkList1.add(s2);
        singLinkList1.add(s3);
        SingLinkListUnion singLinkList2=new SingLinkListUnion();
        SingLinkPool s4=new SingLinkPool(1);
        SingLinkPool s5=new SingLinkPool(7);
        SingLinkPool s6=new SingLinkPool(8);
        SingLinkPool s7=new SingLinkPool(17);
        SingLinkPool s8=new SingLinkPool(4);
        SingLinkPool s9=new SingLinkPool(88);
        singLinkList2.add(s4);
        singLinkList2.add(s5);
        singLinkList2.add(s6);
        singLinkList2.add(s7);
        singLinkList2.add(s8);
        singLinkList2.add(s9);
        //合并到新链表
        System.out.println("链表1:");
        singLinkList1.show();
        System.out.println("链表2:");
        singLinkList2.show();
        //数据初始化完毕
        //定义链表一指针，和链表二指针
        SingLinkPool index1=singLinkList1.getHead();
        SingLinkPool index2=singLinkList2.getHead();
        //不能和前面数组一样方式，要不然每次都要new SingLinkPool()添加到新链表内,否则抛出空指针异常
        SingLinkPool index3=index1; //假设index3->index1 || index3->index2 都可以
        //
        while((index1=index1.next)!=null){
            index3=index3.next;
            index3.data=index1.data;
        }
        while((index2=index2.next)!=null){
            index3.next=index2;
            index3=index3.next;
        }
        System.out.println("新链表:");
        singLinkList1.show();


    }


    // 2.按递增顺序合并两个递增顺序有序表(数组+链表)
    //数组实现
    @Test
    public void testIncrementArrayUnion(){
        int[] arr1 = {1, 3,7, 8, 8,10};
        int[] arr2 = {1, 2, 7, 8, 9,9,10, 22};
        int[] arr3 = new int[arr1.length + arr2.length];
        //思路: 1.先遍历arr1 如果arr1中小于arr2中数就添加到arr3
        //2.反之比arr2中大,就再去遍历arr2，谁小谁先添加进arr3
        int index1=0;
        int index2=0;
        int index=0;
        //必须加上判断条件  要不然去下一个while循环 会数组越界
        while(index1<arr1.length&&index2<arr2.length){
                while(index1<arr1.length&&index2<arr2.length&&arr1[index1]<=arr2[index2]){
                    arr3[index]=arr1[index1]; //添加完后index=3
                    index++;
                    index1++;
                }
                //arr1[3]越界
                while (index1<arr1.length&&index2<arr2.length&&arr1[index1]>arr2[index2]){
                    arr3[index]=arr2[index2];
                    index++;index2++;
                }
        }
        //其中一个遍历完了就跳出循环
        if(index1>=arr1.length){ //arr1遍历完了，再依次把arr2中的数据添加到arr3中
            while(index2<arr2.length){
                arr3[index++]=arr2[index2++];
            }
        }else{ //反之 把arr1剩余的数据添加到arr3中
            while(index1<arr1.length){
                arr3[index++]=arr1[index1++];
            }
        }
        System.out.println("排序后:");
        for (int i = 0; i <arr3.length ; i++) {
            System.out.printf("arr[%d]=%d\t",i,arr3[i]);
        }
    }
    //链表实现
    @Test
    public void testIncrementLinkUnion(){
        //两个有序单链表合并(不按照顺序)
        SingLinkListUnion singLinkList1=new SingLinkListUnion();
        SingLinkPool s1=new SingLinkPool(1);
        SingLinkPool s2=new SingLinkPool(2);
        SingLinkPool s3=new SingLinkPool(8);
        singLinkList1.add(s1);
        singLinkList1.add(s2);
        singLinkList1.add(s3);
        SingLinkListUnion singLinkList2=new SingLinkListUnion();
        SingLinkPool s4=new SingLinkPool(1);
        SingLinkPool s5=new SingLinkPool(3);
        SingLinkPool s6=new SingLinkPool(8);
        SingLinkPool s7=new SingLinkPool(8);
        SingLinkPool s8=new SingLinkPool(10);
        SingLinkPool s9=new SingLinkPool(88);
        singLinkList2.add(s4);
        singLinkList2.add(s5);
        singLinkList2.add(s6);
        singLinkList2.add(s7);
        singLinkList2.add(s8);
        singLinkList2.add(s9);
        //合并到新链表
        System.out.println("链表1:");
        singLinkList1.show();
        System.out.println("链表2:");
        singLinkList2.show();
        //数据初始化完毕
        //定义链表一指针，和链表二指针
        SingLinkPool index1=singLinkList1.getHead().next; //指针一
        SingLinkPool index2=singLinkList2.getHead().next; //指针二
        SingLinkPool temp=index1; //定义一个赋值指针
        //如果temp=index2  逻辑就要反过来处理
        //不能直接跳，是连接下一个，继续判断
        while(index1!=null||index2!=null){
            if(index1.data<= index2.data&&index1==temp){
                if(index1.next!=null){
                    temp=index1.next;
                    index1.next=index2;
                    index1=temp;
                    temp=index2;
                }else{
                    index1.next=index2;
                    break;
                }
            }else{
                if(index2.next!=null){
                    temp=index2.next;
                    index2.next=index1;
                    index2=temp;
                    temp=index1;
                }else{
                    index2.next=index1;
                    break;
                }
            }
        }

        System.out.println("新链表:");
        singLinkList1.show();
    }

}

class SingLinkListUnion{
    SingLinkPool head=new SingLinkPool();//定义头节点

    public SingLinkPool getHead() {
        return head;
    }

    //向链表尾部添加
    public void add(SingLinkPool singLinkPool){
        SingLinkPool temp=head;
        while(temp.next!=null){
            temp=temp.next;
        }
        //当temp.next指向空时跳出循环
        temp.next=singLinkPool;
    }
    //遍历链表
    public void  show(){
        SingLinkPool temp=head.next;
        if(temp==null){
            System.out.println("链表为空~ ~");
            return;
        }
        while(temp!=null){
            System.out.println(temp.toString());
            temp=temp.next;
        }
    }
}
//定义单链表结构
class SingLinkPool{
    public int data; //值
    public SingLinkPool next;
    public SingLinkPool() { }
    public SingLinkPool(int data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "SingLinkPool{" + "data=" + data + '}';
    }
}

知识灌溉
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表和链表的归并，归并排序
any_ways的博客
03-30 1559
１，顺序表的归并 #include <stdio.h> #include <stdlib.h> #define MAX(X,Y) (X>Y?X:Y) #define MAXSIZE 10 typedef struct List//创建一个顺序表类型 { int arr[MAXSIZE]; int size; }List; int check(int a, List*b)//检查顺序表里是否包含某个整型 { int i = 0; for(i =
合并两个有序链表（精美图示详解哦）
weixin_73450183的博客
03-08 8628
合并两个有序链表，两种解法。有详细图示包理解哦，确定不进来看看嘛
有序表的合并(算法思路)
asddoa的博客
10-04 578
1.顺序表的实现 void MergeList_Sq(SqList LA,SqList LB,SqList &LC) { pa=LA.elem pb=LB.elem //此处指针pa和pb的初值分别指向两个表的第一个元素 LC.length = LA.length + LB.length; LC.elem = new ElemType[LC.length]; //为合并后的新表分配一个数组空间 pc = LC.elem;
【数据结构】--oj_合并两个有序链表（详解）
m0_74044018的博客
04-08 4783
链表力扣面试题系列，包含c，c++和java代码
合并两个有序链表（LeetCode 21）
Dablelv 的博客专栏。
03-20 4334
不能开辟新空间来存储合并后的链表。如果第一次做该题，很容易会想到使用新链表来存储合并后的有序链表。虽然可以如此实现，但是不符合要求。从上面合并两个有序链表的步骤中可以看出，每次合并的步骤（2）都是一样的，由此我们想到了递归。将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。输入：两个有序的单链表 head1 与 head2。输出：合并后的有序单链表 mergeHead。
顺序表的合并
zjxzjx123456789的博客
08-03 521
define MAXSIZE 10 //数组的最大长度typedef struct{ //顺序表的初始化int *data;//定义顺序表中元素类型的数组指针int length;//当前顺序表的长度}SqList;
Leetcode88 21 合并俩个有序数组、合并俩个有序链表（数组链表）
Hansry的博客
10-25 248
给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。 说明: 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。 示例: 输入: nums1 = [1,2,3,0,0,0], m = 3 nums2 = [2,...
Python实现合并两个有序链表的方法示例
09-19
在这个问题中，我们需要合并两个已排序的链表，确保合并后的链表依然保持有序。这通常是一个常见的面试题，它考察了对链表操作的理解和逻辑处理能力。 首先，我们需要定义链表节点的结构。在Python中，我们可以创建...
两个有序链表的去重合并
10-15
两个有序链表的去重合并，
链表_链表_用链表将两个数组升序合并到另一个数组_
10-02
本主题探讨的是如何利用链表将两个已排序的数组升序合并到一个新的数组中。这个操作在数据处理、排序算法以及各种复杂的数据结构实现中都有广泛的应用。 链表与数组相比，它的主要优势在于插入和删除操作的时间...
工程实践第一部分
05-29
题目一 求两个集合的合并运算 编程实现两个集合的并运算，即A=A∪B，要求分别采用数组与链表实现，并分析两种方法各自的优缺点。
归并算法之有序数组合并算法实现
01-01
归并算法之有序数组合并算法实现 一个简单的有序数组合并算法：写一个函数，传入 2 个有序的整数数组，返回一个有序的整数数组。实现相当简单，创建一个长度为这两个长度之和的数组，然后分别用三个指针指向这三个数组，找到这两个数组中各个元素在合并数组中的位置并插入，直到某个数组指针到达尾部。再将另一个数组剩下的所有元素，直接放入归并数组尾部。算法的简单实现，需要注意的是对参数的校验，判断数组是否有序。 public class MergeOrderedArray { public static int[] merge(int [] a,int []b){ if(!isOrderedArra
C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
07-03
C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
两个有序链表序列的合并python实现.rar
最新发布
03-25
下面我们将深入探讨这个话题，包括链表的概念、Python中链表的表示以及如何实现两个有序链表的合并。 首先，链表不同于数组，它不连续存储数据。每个节点包含数据和指向下一个节点的引用，形成了一个链式结构。在...
合并两个有序的单链表
dycljj的博客
07-14 832
链表1和链表2是两个递增排序的单链表，合并这两个链表得到升序的链表如上图。 链表1的头结点的值小于链表2的头结点的值，所以链表1的头结点是合并后链表的头结点。（如图）在剩余的链表中，链表2的头结点的值小于链表1的头结点的值，因此链表2的头结点是剩余结点的头结点，把这个结点和之前合并好的链表的尾节点链接起来。（如图）递归可以得到合并后的新链表。下面是一段参考代码：#include <iostream
两个有序单链表的合并
Junds0的博客
10-18 226
本关任务：已知两个链表head1和head2各自有序，请把它们合并成一个链表依然有序。结果链表要包含head1和head2的所有节点，即使节点值相同。（3）重复步骤2，直到链表head1或者head2遍历完成，未遍历完的链表，直接挂接到mergelist的尾节点。（2）选择head1与head2链表当前节点值较小的节点，挂接到后并后的链表mergelist；（1）如果head1或head2为空链表，则直接返回另外一个链表；输入：两个有序的单链表head1与head2；开始你的任务吧，祝你成功！
【数据结构--顺序表】合并两个有序数组
awww224112的博客
09-09 317
【代码】【数据结构--顺序表】合并两个有序数组。
【Leetcode数据结构算法题】合并两个有序数组（顺序表篇）
大家好我叫张同学
01-01 1293
题目内容： 给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2中的元素数目。 请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。 注意：最终合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。 leetcode题目链接（点击即可跳转
算法（数组）：有序数组合并
小羊羊
07-23 444
/** 两个有序数组合并后依然有序 示例: 给定 arr1 = [2, 7, 11, 15] arr2 = [1, 5, 6, 8] 返回 arr = [1,2,5,6,7,8,11,15] */ + (void)mergeArray { NSArray *array1 = @[@"1",@"7",@"9",@"22",@"30",@"...
3 两个非递减的有序链表合并
09-05
将两个非递减的有序链表合并，可以使用原来两个链表的存储空间，不需要额外的空间。这可以通过比较两个链表中节点的值，将较小的节点放在新链表中，并将对应链表的指针向后移动，直到其中一个链表为空。然后将剩余的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值