//自底向上合并排序
public class BottomUpSort {
    public static void main(String args[])
    {
        int a[] = {9,4,5,2,1,7,4,6};
        bottomUpSort(a);
        for(int i=0;i<a.length;i++)
            System.out.print(a[i] + " ");
        System.out.println();
    }
    
    public static void bottomUpSort(int a[])
    {
        int i, s, t = 1;
        while(t < a.length-1)
        {
            s = t;
            t = 2*s;
            i = 0;
            for(;i+t < a.length;i+=t)
                merge(i, i+s-1, i+t-1, a);    //自底向上进行排序
            if(i+s-1 < a.length-1)    //判断是否有落单元素
                merge(i, i+s-1, a.length-1, a);
            
        }
    }
    
    public static void merge(int low, int mid, int high, int a[])
    {
        int b[] = new int[a.length];    //    建立转存数组
        int f = low, s = mid+1, p = low;
        //f为第一个数组索引,s为第二个数组索引,p为b数组索引
        while(f<=mid && s<=high)
        {
            //在两个数组元素中值小的一方放入b数组
            if(a[f] <= a[s])
            {
                b[p] = a[f];
                f++;
            }
            else
            {
                b[p] = a[s];
                s++;
            }
            p++;
        }
        
        if(f == mid+1)    //若第一个数组中的元素全部存储进去了,那么将第二个数组中的剩余元素全部放入b数组
            for(;s <= high && p<=high;p++,s++)
                b[p] = a[s];
        else //否则将第一个数组中的元素全部放入b数组
            for(;f<=mid && p<=high;p++,f++)    
                b[p] = a[f];
        
        for(int i=low;i<=high;i++)
            a[i] = b[i];
    }
}

//合并排序算法
public class MergeSort {
    public static void main(String args[])
    {
        int a[] = {9,4,5,2,1,7,4,6};
        mergeSort(0, a.length-1, a);
        for(int i=0;i<a.length;i++)
            System.out.print(a[i] + " ");
        System.out.println();
    }
    
    //合并排序
    public static void mergeSort(int low, int high, int a[])
    {
        if(low < high)
        {
            int mid = (low + high)/2;
            mergeSort(low, mid, a);
            mergeSort(mid+1, high, a);
            merge(low, mid, high, a);
        }
    }
    
    //合并两个数组
    public static void merge(int low, int mid, int high, int a[])
    {
        int b[] = new int[a.length];    //    建立转存数组
        int f = low, s = mid+1, p = low;
        //f为第一个数组索引,s为第二个数组索引,p为b数组索引
        while(f<=mid && s<=high)
        {
            //在两个数组元素中值小的一方放入b数组
            if(a[f] <= a[s])
            {
                b[p] = a[f];
                f++;
            }
            else
            {
                b[p] = a[s];
                s++;
            }
            p++;
        }
        
        if(f == mid+1)    //若第一个数组中的元素全部存储进去了,那么将第二个数组中的剩余元素全部放入b数组
            for(;s <= high && p<=high;p++,s++)
                b[p] = a[s];
        else //否则将第一个数组中的元素全部放入b数组
            for(;f<=mid && p<=high;p++,f++)    
                b[p] = a[f];
        
        for(int i=low;i<=high;i++)
            a[i] = b[i];
    }
}

package com.tongcaipay.merchant.apply.study;
import java.util.Arrays;
/**
 * * 顺序栈
 * Created by xiaolei on 19-08-27
 */
public class ArrayStack<T> {
    private final int DEFAULT_SIZE = 10;   //设置默认尺寸
    private int capacity;  //保存当前数组长度
    private int addCapacity; //设置当超出原数组长度时增加的长度
    private Object[] elements; //初始化顺序栈数组
    private int size; //保存顺序栈中元素的个数


    //创建默认长度的空顺序栈
    public ArrayStack(){
        capacity = DEFAULT_SIZE;
        elements = new Object[capacity];
    }

    //创建指定长度的空顺序栈
    public ArrayStack(int capacity){
        this.capacity = capacity;
        elements = new Object[capacity];
    }

    /**
     * 创建指定长度的空顺序栈，并指定超出数组范围后的增量
     * @param capacity 设置指定长度
     * @param addCapacity 设置增量
     */
    public ArrayStack(int capacity,int addCapacity) {
        this.capacity = capacity;
        this.addCapacity = addCapacity;
        elements = new Object[capacity];
    }

    //获取顺序栈的长度
    public int getSize(){
        return size;
    }

    //判断顺序栈是否为空栈
    public boolean isEmpty(){
        return size == 0;
    }

    //确保数组长度，如果超出就进行拓展
    private void ensureCapacity(int inputCapacity){
        //如果输入的数组长度大于原有数组的长度
        if (inputCapacity > capacity){
            //若果有设定数组增量
            if(addCapacity > 0){
                while (inputCapacity > addCapacity)
                    capacity += inputCapacity;
            } else{
                while (inputCapacity > addCapacity)
                    capacity <<= 1;
            }
            //扩容后，将原数组复制到新数组中
            elements = Arrays.copyOf(elements, capacity);
        }
    }

    //进栈
    public void push(T element){
        //确保数组长度
        ensureCapacity(size+1);
        //元素进栈
        elements[size++] = element;
    }

    //出栈
    //同时返回弹出的元素
    public T pop(){
        //如果是空栈
        if (isEmpty())
            return null;
        T element = (T) elements[size-1];
        //释放栈顶元素并将长度减一
        elements[--size] = null;
        return element;
    }

    //获取栈顶元素
    public T getTop() {
        return (T) elements[size - 1];
    }

    //清空顺序栈
    public void clear(){
        for (int i = 0;i<size;i++)
            elements[i] = null;
        size = 0;
    }

    public String toString(){
        if(isEmpty())
            return "[]";
        else {
            //实例化对sb,构造方法

            StringBuilder sb = new StringBuilder("[");  //StringBuilder 的内容是可变的
            for (int i = size -1;i>=0;i--)
                sb.append(elements[i].toString()+" ");  //链式编程.append特点:能放很多类型的数据
            sb.append("]");
            int len = sb.length();
            return sb.delete(len - 2,len - 1).toString();
        }
    }

    public static void main(String[] args) {
        ArrayStack<String> ll = new ArrayStack<String>();
        System.out.println("原栈中的元素： "+ll);
        System.out.println("----------进栈----------");
        //压栈
        ll.push("haha");
        ll.push("hehe");
        ll.push("xixi");
        ll.push("hiahia");
        ll.push("heihei");
        System.out.println("压栈后栈中所含元素： "+ll);
        //获取栈顶元素
        System.out.println("栈顶元素为： "+ll.getTop());
        //获取栈中元素个数
        System.out.println("当前栈中元素个数为： "+ll.getSize());
        //出栈
        System.out.println("----------出栈----------");
        ll.pop();
        System.out.println("出栈后栈中所含元素： "+ll);
        //获取栈顶元素
        System.out.println("栈顶元素为： "+ll.getTop());
        //获取栈中元素个数
        System.out.println("当前栈中元素个数为： "+ll.getSize());
    }
}

package com.tongcaipay.merchant.apply.study;

public class LinkListStack<T> {

    //定义一个内部类 Node 表示单链表的结点
    private class Node {
        private T element;
        private Node next;

        //初始化空构造器
        
        public Node() {

        }

        //初始化含参数构造器
        public Node(T element, Node next) {
            this.element = element;
            this.next = next;
        }
    }

    private Node top;//存放栈顶结点
    private int size;//存放栈中结点数

    //初始化空栈
    public LinkListStack() {
    }

    //获取栈长度
    public int getSize() {
        return size;
    }

    //判断栈是否为空栈
    public boolean isEmpty() {
        return size == 0;
    }

    public void push(T element) {
        //进栈时,新结点的后驱指针next指向旧top
        Node newNode = new Node(element, top);
        //进来的新结点更新为top
        top = newNode;
        size++;

    }


    //出栈
    //返回弹出的元素
    public T pop() {
        //如果弹出时栈为空则返回空
        if (isEmpty())
            return null;
        //用一个结点保存原头结点
        Node p = top;
        //将现在的头结点更新为原结点的下一个结点
        top = top.next;
        //将原头结点释放
        p.next = null;
        size--;
        return p.element;
    }

    //获取栈顶元素
    public T getTop() {
        //如果为空栈则返回空
        if (isEmpty())
            return null;
        return top.element;
    }

    //清空栈
    public void clear() {
        top = null;
        size = 0;
    }

    public String toString() {
        if (isEmpty())
            return "[]";
        else {
            StringBuilder sb = new StringBuilder("[");
            for (Node current = top; current != null; current = current.next)
                sb.append(current.element.toString() + "->");
            sb.append("]");
            int len = sb.length();
            return sb.delete(len - 3, len - 1).toString();
        }
    }

public static void main(String[] args) {
        LinkListStack<String> ll = new LinkListStack<String>();
        System.out.println("原栈中的元素： " + ll);
        System.out.println("----------进栈啦----------");
        //压栈
        ll.push("haha");
        ll.push("hehe");
        ll.push("xixi");
        ll.push("hiahia");
        ll.push("heihei");
        System.out.println("压栈后栈中所含元素： " + ll);
        //获取栈顶元素
        System.out.println("栈顶元素为： " + ll.getTop());
        //获取栈中元素个数
        System.out.println("当前栈中元素个数为： " + ll.getSize());
        //出栈
        System.out.println("----------出栈啦----------");
        ll.pop();
        System.out.println("出栈后栈中所含元素： " + ll);
        //获取栈顶元素
        System.out.println("栈顶元素为： " + ll.getTop());
        //获取栈中元素个数
        System.out.println("当前栈中元素个数为： " + ll.getSize());
}

/**
 * 向指定位置插入数据
 * 1.先将带插入的这个放在备用链表的第一条，记做k，然后将首元素的游标指向备用链表的下一个的下标k+1
 * 2.不在第一条的情况：插入前index-1的位置list[index-1].cur = list[k]的下标
 * 3.list[k]的游标指向原来第三个位置处的坐标
 * @param index
 * @param element
 * @return
 */
public boolean addTo(int index, Object element) {
if (index < -1 || index > length || element == null) {
return false;
}
// 备用链表的第一个元素下标，也是待插入元素位置的下标newcur
int newCur = linklist[0].cur;
 
// 拿到前一个元素的下标
int ccur = linklist.length - 1;// 获取第一个有效元素的下标
for (int i = 1; i < index; i++) {
ccur = linklist[ccur].cur;
}
// 出来后ccur=2
int tmp = linklist[ccur].cur;//存储原来前一个元素的cur == 3（此时为3）
linklist[ccur].cur = newCur;// 将原来之前有个元素的游标设置为新插入的元素位置的下标（newcur）
linklist[newCur].cur = tmp;// 将新插入的这个元素的下标设置为插入前，index元素前一个元素的游标ccur
linklist[newCur] = new Node(tmp, element);
linklist[0].cur = newCur + 1;
length++;
return true;
}

/**
 * 1.找出前一个元素的cur ，也就是删除位置元素的下标 --- 并将前一个元素的cur指向删除索引的后一个元素的下标
 * 2.删除的这个索引处元素进入备用链表的第一个，cur指向原来的备用链表第一个下标，首元素cur指向该索引处元素下标
 * 
 * @param index
 * @return
 */
public boolean delete(int index) {
 
// 以index = 1为例
if (index < -1 || index > length) {
return false;
}
int ccur = size - 1;
for (int i = 1; i < index; i++) {
ccur = linklist[ccur].cur;
}
 
int tmp = linklist[ccur].cur;// 获取前一个元素的cur，也就是删除元素的下标
int newCur = linklist[tmp].cur;// 获取删除元素的cur
linklist[ccur].cur = newCur;
 
int newFree = linklist[0].cur;// 获取原来链表的备用链表的第一个坐标
 
linklist[0].cur = tmp;// 将首元素的cur设置成删除位置处的下标
linklist[tmp].cur = newFree;
size--;
return true;
}

/* 初始条件：顺序线性表L已存在，1 <= i <= length */
/* 操作结果：在L中第 index 个位置之前插入新的元素e,L的长度加1 */
public void add(int i, T e) 
if (data.length == Maxsize)
throw new RuntimeException("数组越界");
   if (i < 1 || i > data.length + 1)
   throw new RuntimeException("数组越界");
   if (i <= data.length){
   for(int i = data.length - 1; i>= i - 1;k-s-)
   data[k+1] =data[k];
}
data[i-1] = e;
data.length++;
}

/* 初始条件：顺序线性表L已存在，1 <= i <= length */
/* 操作结果：删除第i元素，并用e返回其值，L的长度减1 */
public void remove(int i,T e){
int k;
if(data.length == 0)
throw new RuntimeException("数组越界");
if(i < 1 || i > data.length
throw new RuntimeException("数组越界");
e = data[i - 1];
if(i < data.length)
{
for(k = i;k < data.length;k++)
data[k-1] = data[k];
}
data.lenrth--;
}

/**
 * 　定义一个节点结点Node
 */
private class Node<E> {
E data;  //数据域
Node<E> next;  //指针域

public Node(E data, Node<E> next) {
   this.data = data;
   this.next = next;
    }
}

public Node index(int index){
     if(index==0){
         //头一个结点下标为0
         current=head;
         
         return current;
         //删除后链表为空
     }else{
         current=head;
         for(int i = 0;i < index - 1;i++){
             current=current.next;
             //因为current.next赋值给了current，所以要设置为index-1
         }
         
     }
     return current;
 }

/**
  * 获取第i个结点（包括第0个结点，头结点）
  * 获取结点值只需要GetNode(i).data即可，不再写方法了
  */
public Node<E> GetNode(int i) {
if (i < 0 || i > count) {
throw new RuntimeException("元素位置错误！");
    } else if (i == 0) {
    return head;    //第0个节点为head
    } else {   //1 <= i <= count
    Node<E> node = head.next;
    for (int k = 1; k < i; k++) {
    node = node.next;
    }
    return node;
    }
}



/**
  * 第i个位置插入新的元素
  */
public void ListInsert(int i, E e) {
if (i < 1 || i > count + 1) {
throw new RuntimeException("插入位置错误！");
} else {
Node<E> newNode = new Node<E>(e, null);
newNode.next = GetNode(i - 1).next;  //因为GetNode()方法中包含了获取头结点，所以不需单独判断了
GetNode(i - 1).next = newNode;
count++;
System.out.println("插入成功！");
   }
}

/**
  * 获取第i个结点（包括第0个结点，头结点）
  * 获取结点值只需要GetNode(i).data即可，不再写方法了
  */
public Node<E> GetNode(int i) {
if (i < 0 || i > count) {
throw new RuntimeException("元素位置错误！");
    } else if (i == 0) {
    return head;    //第0个节点为head
    } else {   //1 <= i <= count
    Node<E> node = head.next;
    for (int k = 1; k < i; k++) {
    node = node.next;
    }
    return node;
    }
}



/**
* 删除第i个位置元素，并返回其值
*/
public E ListDelete(int i) {
if (i < 1 || i > count)
throw new RuntimeException("删除位置错误！");
Node<E> node = GetNode(i);
   E e = node.data;
   GetNode(i - 1).next = node.next;
   node = null;
   count--;
   System.out.println("删除成功!");
   return e;
}

/**
  * 查找元素，0代表查找失败
  */
public int LocateElem(E e) {
Node<E> node;
node = head.next;
if (node.data == e)
return 1;
   for (int k = 1; k < count; k++) { 
    node = node.next;
        if (node.data == e)
         return k + 1;
   }
   System.out.println("查找失败！");
   return 0;
}

package com.tongcaipay.merchant.apply.study;
/**
 * 说明：
 * 1.《大话数据结构》中没有线性表的长度，但提到可以存储于头节点的数据域中。
 *   本程序的线性表长度存放于count变量中，线性表长度可以使程序比较方便。
 * 2.程序中，第i个位置代表第i个结点，头结点属于第0个结点
 * 3.因为链表为泛型，整表创建采用整型（随机整数做元素），所以有出现一些类型转换
 * 4.Java程序的方法一般以小写开头，但为和书上一致，程序中方法采用了大写开头。
 *
 * 注意点：
 * 1.count在增删元素时要加一或减一千万别忘了
 * 2.清空线性表要每个元素都null
 *
 * @ xiao lei
 *
 */
public class LinkList<E> {
    private Node<E> head;  //头结点
    private int count;  //线性表长度

    /**
     * 　定义一个节点结点Node
     */
    private class Node<E> {
        E data;  //数据域
        Node<E> next;  //指针域

        public Node(E data, Node<E> next) {
            this.data = data;
            this.next = next;
        }
    }

        /**
         * 线性表的初始化
         */
        public LinkList() {
            head = new Node<E>(null,null);  //不是head=null;
            count = 0;  //线性表第长度
        }

        /**
         * 判断线性表是否为空
         */
        public boolean IsEmpty() {
            if (count == 0) {
                System.out.println("表为空！");
                return true;
            } else {
                System.out.println("表不为空！");
                return false;
            }
            //return count==0;
        }


        /**
         * 清空线性表
         */
        public void ClearList() {
            Node<E> node;
            while (count != 0) {
                node = head.next;
                head.next = node.next;
                node = null;
                count--;
            }
            System.out.println("线性表已清空！");
        }

        /**
         * 获取第i个结点（包括第0个结点，头结点）
         * 获取结点值只需要GetNode(i).data即可，不再写方法了
         */
        public Node<E> GetNode(int i) {
            if (i < 0 || i > count) {
                throw new RuntimeException("元素位置错误！");
            } else if (i == 0) {
                return head;    //第0个节点为head
            } else {   //1 <= i <= count
                Node<E> node = head.next;
                for (int k = 1; k < i; k++) {
                    node = node.next;
                }
                return node;
            }
        }

        /**
         * 获取第i个结点的数据(包括头结点)
         */
        public E GetData(int i) {
            return GetNode(i).data;
        }

        /**
         * 查找元素，0代表查找失败
         */
        public int LocateElem(E e) {
            Node<E> node;
            node = head.next;
            if (node.data == e)
                return 1;
            for (int k = 1; k < count; k++) {
                node = node.next;
                if (node.data == e)
                    return k + 1;
            }
            System.out.println("查找失败！");
            return 0;
        }

        /**
         * 第i个位置插入新的元素
         */
        public void ListInsert(int i, E e) {
            if (i < 1 || i > count + 1) {
                throw new RuntimeException("插入位置错误！");
            } else {
                Node<E> newNode = new Node<E>(e, null);
                newNode.next = GetNode(i - 1).next;  //因为GetNode()方法中包含了获取头结点，所以不需单独判断了
                GetNode(i - 1).next = newNode;
                count++;
                System.out.println("插入成功！");
            }
        }

        /**
         * 删除第i个位置元素，并返回其值
         */
        public E ListDelete(int i) {
            if (i < 1 || i > count) {
                throw new RuntimeException("删除位置错误！");
            }else {
                Node<E> node = GetNode(i);
                E e = node.data;
                GetNode(i - 1).next = node.next;
                node = null;
                count--;
                System.out.println("删除成功!");
                return e;
            }
        }



        /**
         * 获取线性表长度
         */
        public int ListLength() {
            return count;
        }

public static void main(String[] args) {
           LinkList<Integer> nums = new LinkList<Integer>();
           System.out.println("——————————插入5个元素到表中,并读取内容——————————");
           for (int i = 1; i <= 5; i++)
               nums.ListInsert(i, 2 * i);
           nums.IsEmpty();
           int num;
           for (int i = 1; i <= 5; i++) {
               num = nums.GetData(i);
               System.out.println("第" + i + "个位置的值为：" + num);
           }
           System.out.println("——————————查找0、2、10是否在表中——————————");
           System.out.print("0的位置：");
           System.out.println(nums.LocateElem(0));
           System.out.print("2的位置：");
           System.out.println(nums.LocateElem(2));
           System.out.print("10的位置：");
           System.out.println(nums.LocateElem(10));
           System.out.println("——————————删除2、10——————————");
           num = nums.ListDelete(1);
           System.out.println("已删除：" + num);
           num = nums.ListDelete(4);
           System.out.println("已删除：" + num);
           System.out.println("当前表长：" + nums.ListLength());
           for (int i = 1; i <= nums.ListLength(); i++) {
               num = nums.GetData(i);
               System.out.println("第" + i + "个位置的值为：" + num);
           }
           nums.ClearList();
           nums.IsEmpty();
       }

public class LinkedList<E>
     extends AbstractSequentialList<E>
     implements List<E>, Deque<E>, Cloneable, java.io.Serializable

private class Node<T> {
T data;
Node<T> next;//后继
Node<T> pre;//前驱
   Node(T t) {
       this.data = t;
   }
｝

Node<T> frist;  //头部
Node<T> last;   //尾部
int size;//链表长度
//底层数组
public LinkedList() {
frist = last = null;
}

@Override
public void add(T e) {
Node<T> n = new Node<T>(e);
   if (last == null) {
   frist = n;
       last = n;
   } else {
       last.next = n;//最后一个元素下一个为此次添加的元素
       n.pre = last;//添加元素的前驱指前一个元素
       last = n;//此时最后一个元素为刚添加进入的
        }
        size++;
    }

private Node<T> getNode(int index) {
 if (index >= size || index < 0) {
 throw new RuntimeException("数组越界");
 }
   Node temp = frist;
   for (int i = 0; i < index; i++) {
   temp = temp.next;
    }
    return temp;
}
@Override
public void add(int index, T e) {
Node<T> newNode = new Node<T>(e);
// 数组越界
   if (index < 0 || index > size) {
       throw new RuntimeException("数组越界");
   }
   // 末尾元素
   if (index == size) {
   last.next = newNode;
   newNode.pre = last;
   last = newNode;
   size++;
   return;
   }
   // 中间元素
   Node temp = getNode(index);
   temp.pre.next = newNode;
   newNode.pre = temp.pre;
   temp.pre = newNode;
   newNode.next = temp;
   size++;
}

private Node<T> getNode(int index) {
 if (index >= size || index < 0) {
 throw new RuntimeException("数组越界");
 }
   Node temp = frist;
   for (int i = 0; i < index; i++) {
   temp = temp.next;
    }
    return temp;
}

@Override
public T set(int index, T e) {
//数组越界
if (index > size || index < 0) {
throw new RuntimeException("数组越界");
   } else if (index == size) {
Node<T> newNode = new Node<>(e);
last.next = newNode;
newNode.pre = last;
last = newNode;
size++;
return null;
} else { //中间元素
Node<T> node = getNode(index);
T oldData = node.data;
node.data = e;
return oldData;
}
}

@Override
public T get(int index) {
if (index < size && index >= 0) {
return getNode(index).data;
    } else {
    throw new RuntimeException("数组越界");
}
}

@Override
public T remove(int index) {
if (index < 0 || index >= size) {
            throw new RuntimeException("数组越界");
   }

   if(index == 0){
   Node<T> node = frist;
    frist = frist.next;
    size--;
       return node.data;
   }else{
       Node<T> temp = getNode(index);
       temp.next.pre = temp.pre;
       //再将temp的前驱的后继指向temp的后继
       temp.pre.next = temp.next;
       size--;
       return temp.data;
  }
}

@Override
public boolean remove(T e) {
for (int i = 0; i < size; i++) {
if (get(i).equals(e)) {
remove(i);
          break;
       }
    }
    return true;
}

@Override
public int size() {
return size;
}

@Override
public boolean isEmpty() {
if (size == 0) {
return true;
    } else {
       return false;
}
}

@Override
public void forEach(Consumer<T> action) {
Node<T>currentNode = frist;
while (currentNode != null) {
action.accept(currentNode.data);
currentNode = currentNode.next;
       }
}

package com.tongcaipay.merchant.apply.study;


import java.util.function.Consumer;


public class LinkedList<T> implements List<T> {

    private class Node<T> {
        T data;
        Node<T> next;//后继
        Node<T> pre;//前驱

        Node(T t) {
            this.data = t;
        }
    }

    Node<T> frist;  //头部
    Node<T> last;   //尾部
    int size;//链表长度
    //底层数组

    public LinkedList() {
        frist = last = null;
    }


    @Override
    public void add(T e) {
        Node<T> n = new Node<T>(e);
        if (last == null) {
            frist = n;
            last = n;
        } else {
            last.next = n;//最后一个元素下一个为此次添加的元素
            n.pre = last;//添加元素的前驱指前一个元素
            last = n;//此时最后一个元素为刚添加进入的
        }
        size++;
    }

    private Node<T> getNode(int index) {

        if (index >= size || index < 0) {
            throw new RuntimeException("数组越界");
        }
        Node temp = frist;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }

        return temp;
    }

    @Override
    public void add(int index, T e) {
        Node<T> newNode = new Node<T>(e);
        // 数组越界
        if (index < 0 || index > size) {
            throw new RuntimeException("数组越界");
        }

        // 末尾元素
        if (index == size) {
            last.next = newNode;
            newNode.pre = last;
            last = newNode;
            size++;
            return;
        }

        // 中间元素
        Node temp = getNode(index);
        temp.pre.next = newNode;
        newNode.pre = temp.pre;
        temp.pre = newNode;
        newNode.next = temp;
        size++;
    }


    @Override
    public T set(int index, T e) {
        //数组越界
        if (index > size || index < 0) {
            throw new RuntimeException("数组越界");
        } else if (index == size) {
            Node<T> newNode = new Node<T>(e);
            last.next = newNode;
            newNode.pre = last;
            last = newNode;
            size++;
            return null;
        } else { //中间元素
            Node<T> node = getNode(index);
            T oldData = node.data;
            node.data = e;
            return oldData;
        }

    }

    @Override
    public T get(int index) {
        if (index < size && index >= 0) {
            return getNode(index).data;
        } else {
            throw new RuntimeException("数组越界");
        }
    }

    @Override
    public T remove(int index) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("数组越界");
        }

        if(index == 0){
            Node<T> node = frist;
            frist = frist.next;
            size--;
            return node.data;
        }else{
            Node<T> temp = getNode(index);
            temp.next.pre = temp.pre;
            //再将temp的前驱的后继指向temp的后继
            temp.pre.next = temp.next;
            size--;
            return temp.data;
        }
    }

    @Override
    public boolean remove(T e) {
        for (int i = 0; i < size; i++) {
            if (get(i).equals(e)) {
                remove(i);
                break;
            }
        }
        return true;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        if (size == 0) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public void forEach(Consumer<T> action) {
        Node<T>currentNode = frist;
        while (currentNode != null) {
            action.accept(currentNode.data);
            currentNode = currentNode.next;
        }

    }

    public static void main(String[] args) {
        List<String> list = new LinkedList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        //list.add(3,"1");
        list.remove(7);
        //list.set(5,"1");
        //System.out.println(list.size());
        //System.out.println(list.get(4));
        //System.out.println(list.remove(3));
        //System.out.println(list.isEmpty());
        //System.out.println(list.size());
        list.forEach(item -> {
            System.out.println(item);
        });
    }


}

private Object[] array;  //定义一个泛型的数组array

private int size;   //当前数组长度


public ArrayList() {
       array = new Object[10];  //默认情况下使用ArrayList会生成一个大小为10的Object类型的数组
}

public ArrayList(int capacity) {
       array = new Object[capacity];      //新建一个用户初始值大小的object数组。
}

public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add("1");
        list1.add("2");
        list1.add("3");
        list1.add("4");
        //list1.add(3,"1");
        list1.remove("2");
        //list1.set(2,"1");
        //System.out.println(list1.size());
        //System.out.println(list1.get(4));
        //System.out.println(list1.remove(3));
        //System.out.println(list1.isEmpty());
        //System.out.println(list1.size());
        list1.forEach(item -> {
            System.out.println(item);
        });

    }

@Override
public void add(T e) {
array[size++] = e;
}

@Override
public void add(int index, T e) {
if (index > 0 && index <= size) {
for (int i = size - 1; i >= size; i--) {
array[i + 1] = array[i];
    }
    array[index] = e;
    size++;
    }else{
    throw new RuntimeException("数组越界");
    }
}

@Override
public T set(int index, T e) {
if (index > size || index<0 ) {
throw new RuntimeException("数组越界");
    }else if(index == size){
    array[index] = e;
       size++;
    } else {
       array[index] = e;
    }
       return null;  
｝

@Override
public  T get(int index) {
if(index < size && index>=0) {
return (T) array[index];
    }else {
       throw new RuntimeException("数组越界");
}

@Override
public T remove(int index) {
if(index>=0 && index<size) {
Object m = array[index];   //获取删除元素的值
for (int i = index+1 ;i<=size-1;i++){
array[i-1] = array[i];    //将index后面所有的元素往前移一位。
    }
    size--;
    return (T) m;
   }else {
       throw new RuntimeException("数组越界");
   }
}

@Override
//删除元素
//只会删除第一个出现的元素。
public boolean remove(Object o) {
if (o == null){
// for循环遍历元素。找出待删除元素的index
 for (int index = 0;index < size;index++){
       if (array[index] == null) {
           remove(index);
           //此处导致只会删除第一个找到的相等元素
              return true;
          }
   }else{
    // for循环遍历元素。找出待删除元素的index
       for (int index = 0; index < size; index++) {
         if (e.equals(array[index])) {
              remove(index);
              //此处导致只会删除第一个找到的相等元素
              return true;
          }
       }
   }
   return false;
}

public int size() {
        return size;
    }

@Override
public boolean isEmpty() {
if(size == 0){
return true;
        }else{
            return false;
        }
    }
}

@Override
public void forEach(Consumer<T> action) {
for(int i = 0;i<size;i++){
    action.accept((T) array[i]);
    }
}

package com.tongcaipay.merchant.apply.study;
import java.util.Arrays;

//希尔排序算法
public class ShellSort {
    public static void sort(int[] arr) {
        // 缩小增量gap的范围
        for (int gap = arr.length / 2; gap > 0; gap = gap / 2) {
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
                while (j - gap >= 0 && temp < arr[j - gap]) {
                        arr[j] = arr[j - gap];
                        j = j - gap;
                    }
                    arr[j] = temp;
                }
            }
        }


    public static void main(String[] args) {
        int []arr = {10,10,4,8,9,6,5};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }


}