合并单链表

线性表接口

public interface ILinarList<E>{
    boolean add(E item); //添加元素
    boolean add(int index, E item);//插入元素
    E remove(int index); //删除元素
    int indexOf(E item); //定位元素
    E get(int index); //取表元素
    int size(); //求线性表长度
    void clear();//清空线性表
    boolean isEmpty(); //判断线性表是否为空
}

单链表实现线性表

public class SLinkList<E> implements ILinarList<E> {
  private Node<E> start;// 单链表的头引用
  int size;// 单链表的长度
  //链表数据类以及构造方法
  private static class Node<E> {
     E item;
     Node<E> next;
     Node(E element, Node<E> next) {
        this.item = element;
        this.next = next;
   }
}
// 初始化线性表
public SLinkList() {
   start = null;
}
// 添加元素，将元素添加在单链表的末尾
public boolean add(E item) {
  if (start == null) {
    start = new Node<E>(item, null);
   }else{
       Node<E> current = start;
       while (current.next != null) {
         current = current.next;
       }
       current.next = new Node<E>(item, null);
   } 
   size++;
   return true;
}
// 在单链表的第index索引位置前插入一个数据元素
public boolean add(int index, E item) {
   Node<E> current;
   Node<E> previous;
   if (index < 0 || index > size) {
   return false;
   }
   Node<E> newnode = new Node<E>(item, null);
   // 在空链表或第一个元素前插入第一个元素
   if (index == 0) {
     newnode.next = start;
     start = newnode;
     size++;
   }else{
   // 单链表的两个元素间插入一个元素
   current = start;
   previous = null;
   int j = 0;
   while (current != null && j < index) {
     previous = current;
     current = current.next;
     j++;
    }
    if (j == index) {
     previous.next = newnode;
     newnode.next = current;
     size++;
    }
  }
  return true;
}
// 删除单链表中的索引位置为index的数据元素
public E remove(int index) {
  E oldValue = null;
  if (isEmpty() || index < 0 || index > size - 1) {
    oldValue = null;
  }
  Node<E> current = start;
  if (index == 0) {
     oldValue = current.item;
     start = current.next;
     size--;
   } else {
     Node<E> previous = null;
     int j = 1;
     while (current.next != null && j <= index) {
     previous = current;
     current = current.next;
     j++;
   }
   previous.next = current.next;
   oldValue = current.item;
   current = null;
   size--; 
 }
 return oldValue;
}
// 在单链表中查找数据元素item数据位置
public int indexOf(E item) {
   int index = 0;
   if (item == null) {
     for (Node<E> x = start; x != null; x = x.next) {
       if (x.item == null)
          return index;
       index++;
     }
   } else {
      for (Node<E> x = start; x != null; x = x.next) {
        if (item.equals(x.item))
          return index;
        index++;
      }
   }
   return -1;
}
// 获得单链表的第index索引位置的数据元素
public E get(int index) {
   E item = null;
   if (isEmpty() || index < 0 || index > size - 1) {
      item = null;
   }
   Node<E> current = start;
   int j = 0;
   while (current.next != null && j < index) {
     current = current.next;
     j++;
   }
   if (j == index) {
      item = current.item;
   }
     return item;
}
//求单链表长度
public int size() {
   return size;
}
//清空单链表
public void clear() {
  for (Node<E> x = start; x != null;) {
    Node<E> next = x.next;
    x.item = null;
    x.next = null;
    x = next;
  }
  start = null;
  size = 0;
}
//判断单链表是否为空
public boolean isEmpty() {
    return size == 0;
}

//输出单链表
public void P(){
 Node<E> current = start;
 while(current != null){
     System.out.print(current.item + " ");
     current=current.next;
 }
 System.out.println();
 }
}

测试类

public class Test1 {
  public static void main(String[] args) {
     Scanner read=new Scanner(System.in);
     while(read.hasNext()){
        int n=read.nextInt();int m=read.nextInt();
        int[] a=getRandomArrayByIndex(n,100);
        int[] b=getRandomArrayByIndex(m,100);
        SLinkList<Integer> A = new SLinkList<Integer>();
        SLinkList<Integer> B = new SLinkList<Integer>();
        System.out.println("排序前:");
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
        System.out.println("排序后:");
        Arrays.sort(a);Arrays.sort(b);
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
        for(int i=0;i<n;i++){
           A.add(a[i]); 
        }
        for(int i=0;i<m;i++){
           B.add(b[i]); 
        }
        System.out.println("合并后:");
        merge(A,B);
        A.P();

     }
     read.close();
  } 
 //参数说明：num--无重复随机数的个数   scope--随机数所在范围(不包含scope)
  public static int[] getRandomArrayByIndex(int num,int scope){
        //1.获取scope范围内的所有数值，并存到数组中
        int[] randomArray=new int[scope];
        for(int i=0;i<randomArray.length;i++){
            randomArray[i]=i;
        }
        //2.从数组random中取数据，取过后的数改为-1 
        int[] numArray=new int[num];//存储num个随机数
        int i=0;
        while(i<numArray.length){
            int index=(int)(Math.random()*scope+1);
            if(randomArray[index]!=-1){
                numArray[i]=randomArray[index];
                randomArray[index]=-1;
                i++;
            }
        }
        return numArray;
    }
   //合并单链表
  public static void merge(SLinkList<Integer> A,SLinkList<Integer> B) {
  int o=0,p=0,s=0;
        while(s<B.size()){
           p=s;
           while(p<B.size()){
             if(A.get(o)>B.get(p)){
                   A.add(o,B.get(p));s++;  
                } 
             p++;
           }
           o++;   
         }
  }
 
}