线性表___顺序表示和实现

以下涉及到的算法，都是关于线性表的顺序表示和实现这部分的算法题目

package com.linearList;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * @author MJC
 *2018年2月13日
 * 上午11:05:42
 */
public class LinearListTest {

    public static void main(String[] args) {
        LinearListTest llt = new LinearListTest();
        
        int[] arrayA = {1, 3, 5,8,9,12,13,15};
        int[] arrayB = {2, 4, 6,7,10,11,15,16};
        int[] arrayC = new int[16];
        int[] result = new int[16];
        
        List<Integer> linkList = new LinkedList<Integer>();
        linkList.add(1);
        
        //定位元素的位置
        System.out.println(llt.locateElem(arrayA,8));
        //删除第i个元素
        result=llt.listDelete(arrayB,3);
        for (int i = 0; i < result.length; i++) {
            System.out.print(result[i]+",");
        }
        System.out.println("=======================");
        //在第i元素之前 插入一个元素insertElem,
        result = llt.listInsert(arrayA,4,6);
        
        for (int i = 0; i < result.length; i++) {
            System.out.print(result[i]+",");
        }
        System.out.println();
        System.out.println("====分割线====");
        
        //非递减有序线性表，合并成一个非递减有序线性表
        arrayC = llt.Mergelist(arrayA,arrayB,arrayC);
        for (int i = 0; i < arrayC.length; i++) {
            System.out.print(arrayC[i]+",");
            
        }
        System.out.println();
        System.out.println("========================");
        List<Integer> La = new ArrayList<Integer>();
        List<Integer> Lb = new ArrayList<Integer>();
        La.add(1);
        La.add(2);
        La.add(3);
        
        Lb.add(2);
        Lb.add(5);
        Lb.add(6);
        Lb.add(6);
        //存在于Lb但是不存在于La中的数，存入到La
        System.out.println(llt.union(La,Lb));
        
    }
    /** 算法 2.6
     * 定位元素的位置
     * @param array
     * @param elem
     * @return
     */
    public int locateElem(int[] array,int elem){
        for (int i = 0; i < array.length; i++) {
            if(array[i] == elem){
                return i+1;
            }
        }
        return -1;
    }
    /** 算法 2.5
     * 删除第i个元素
     * @param array
     * @param i
     * @return
     */
    public int[] listDelete(int[] array,int i){
        int[] tempArr = new int[16];
        for (int j = 0; j < array.length; j++) {
            if(j<i-1){
                tempArr[j] = array[j];
            }else if(j>i-1){
                tempArr[j-1] = array[j];
            }
        }
        
        return tempArr;
    }
    /** 算法 2.4
     * 在第i元素之前 插入一个元素insertElem, 
     * @param arr
     * @param i
     * @param insertElem
     * @return
     */
    public int[] listInsert(int[] arr,int i,int insertElem){
        int lenth=arr.length;
        if(i<1||i>=lenth){
            try {
                throw new Exception("位置不合法");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //临时数组,最终数组
        int[] temp = new int[17];
        for (int j = 0; j < i-1; j++) {
            temp[j]=arr[j];
        }
        for (int j = i-1; j < temp.length; j++) {
            if(j < lenth){
                temp[j]=arr[j];
            }
        }
        for (int j = arr.length; j >= i-1; j--) {
            temp[j+1] = temp[j];
        }
        temp[i-1] = insertElem;
        return temp;
    }
    /** 算法 2.2
     * 非递减有序线性表，合并成一个非递减有序线性表
     * @param arrayA
     * @param arrayB
     * @param arrayC
     * @return
     */
    public int[] Mergelist(int[] arrayA,int[] arrayB,int[] arrayC){
        
        int LaLenth = arrayA.length;
        int LbLenth = arrayB.length;
        int i = 0, j = 0, k = 0;
        while(i < LaLenth && j<LbLenth){
            if(arrayA[i] < arrayB[j] ){
                arrayC[k] =     arrayA[i];
                i++;//在这里i++与++i没有区别，因为没有涉及到赋值运算，比如q=i++;
                
            }else{
                arrayC[k] = arrayB[j];
                j++;
            }
            k++;
        }
        
        while(i < LaLenth){
            arrayC[k] = arrayA[i];
            k++;
            i++;
        }
        while(j < LbLenth){
            arrayC[k] = arrayB[j];
            k++;
            j++;
        }
        return arrayC;
    }
    /** 算法2.1
     * 存在于Lb但是不存在于La中的数，存入到La
     * @param La
     * @param Lb
     * @return
     */
    public List<Integer> union(List<Integer> La,List<Integer> Lb){
        for (Iterator<Integer> iterator = Lb.iterator(); iterator.hasNext();) {
            Integer item = (Integer) iterator.next();
            if(item!=null){
                if(!La.contains(item)){
                    La.add(item);
                }
            }
        }
        return La;
    }
}