数据结构（数组与链表）

1.数组，优点：查找方便，缺点：增删不方便
  链表，优点：增删方便，缺点：查找不方便
2.数组：一般长度是有限的，为了方便能使用，可以通过新建一个数组，来增加数组的长度，步骤：创建新数组（长度比原数组多一）；将元素复制进新数组；添加新元素；新数组指向原数组。自己定义增删改查遍历等功能，数组自带长度属性。

public class List<E> {
	//定义一个新数组
		Object[] src=new Object[0];
		/**
		 * 添加元素
		 * @param s 要添加的元素
		 */
		public void add(E s){
			//定义一个新数组
			Object[] nsrc=new Object[src.length+1];
			//复制数据
			for(int i=0;i<src.length;i++){
				nsrc[i]=src[i];
			}
			//添加新元素
			nsrc[src.length]=s;
			//原数组指向新数组
			src=nsrc;
		}
		/**
		 * 查找
		 * @param index 所查元素的下标
		 * @return 所查元素
		 */
		public E get(int index){
			E s=(E)src[index];
			return s;
		}
		/**
		 * 数组的长度
		 * @return 返回数组的长度
		 */
		public int size(){
			return src.length;
		}
		/**
		 * 按照下标删除
		 * @param index 删除元素的下标
		 */
		public void delete(int i){
			//定义一个新数组
			if(src.length==0){
				System.out.println("sssssssssssss");
			}
			Object[] que1=new Object[src.length-1];
			//把下标为index之前的元素复制到新数组中
				que1[i]=src[i];
			//原数组指向新数组
			src=que1;
		}
}

利用数组可实现相关的重绘
3.链表:节点需自己定义，包括指针和数值（在节点类中定义）
        链表需要考虑的问题：添加时，如果链表为空；添加时链表中只有一个节点；添加位置错误；删除时，链表为空；删除时，链表中只有一个节点；如果要删除头结点；输入位置错误。关于链表的定义如下：

/**
 * 链表
 * @author zll
 *
 */
public class List {
    //定义一个头指针
	private JNode head=null;
	//记录链表中的数据个数
	private int nCount =0;
	/**
	 * 默认在最后插入
	 * @param 所插入的节点
	 */
	public void add(JNode node){
		add(nCount,node);
	}
	/**
	 * 在pos处插入节点
	 * @param pos 插入节点的位置
	 * @param node 插入的节点
	 */
	public void add(int pos,JNode node){
		//如果输入错误
		if(pos<0||pos>nCount){
			System.out.println("输入错误，请重新输入");
			return ;
		}
		//如果链表为空
		if(nCount==0){
			head=node;
			nCount++;
			return ;
			}
		JNode temp=head;
		//temp表示pos前一个位置的节点
		for(int i=0;i<pos-1;i++){
			temp=temp.Next;
			}
		node.Next=temp.Next;
	    temp.Next=node;
	    nCount++;
        }
	/**
	 * 链表长度
	 * @return 链表长度
	 */
	public int size(){
		return nCount;
	}
	/**
	 * 得到数据
	 * @param i 得到第i个数据
	 * @return   返回数据
	 */
	public JNode get(int i){
		if(nCount==0){
			System.out.println("链表中没有数据，请先输入数据");
			return null;
		}
		if(i<0||i>nCount){
			System.out.println("输入错误");
			return null;
		}
		//如果只有一个数据
		if(nCount==1){
			JNode temp=head;
			temp.nValue=head.nValue;
			temp.Next=null;
			return temp;
			
		}
		else{
        JNode fence=head;
		for(int j=0;j<i;j++){
			fence=fence.Next;
			}
		JNode temp=new JNode();
		temp.nValue=fence.nValue;
		temp.Next=null;
		System.out.println("temp.nValue"+temp.nValue);
	    return temp;
		}
	}
/**
 * 默认移除最后一个
 */
	public void removed(){
	remove(nCount-1);
}
	/**
 *  移除特定位置的元素
 * @param i 移除元素的位置
 * @return 返回移除元素
 */
public JNode remove(int nPos){
	//如果输入的数字过大或过小
	if(nPos<0||nPos>nCount-1){
			System.out.println("输入错误，请重新输入");
			return null;
	}
	//如果链表中没有元素
	if(nCount==0){
		System.out.println("链表中没有元素，请输入元素");
		return null;
	}
	//如果链表中只有一个元素
	if(nCount ==1){
		head=null;
		JNode node=head;
		nCount=0;
		return node;
	}
	//如果要删除头结点
	if(nPos==0){
		JNode temp=head.Next;
		head.Next=null;
		JNode tmp=head;
		head=temp;
		return tmp;
	}
	//其他情况
	JNode temp=head;
	for(int i=0;i<nPos-1;i++){
		temp=temp.Next;
	}
	JNode tmp=temp.Next;
	temp.Next=temp.Next.Next;
	return tmp;
 }
}

关于节点的定义：

public class JNode {
public JNode Next;
public int nValue;
}

4.链表进化---二叉树
  每个节点有两个next:左指针，右指针
  插入时，进行判断小于父亲节点，往左走，大于往右走；到达叶节点时，插入。

public class TreeNode {
public TreeNode leftchild;
public TreeNode rightchild;
public int nValue;
}

/**
 * 创造树的相关方法
 * @author zll
 *
 */
public class CreatTree {
	private int y=0;
public  TreeNode root;
/**
 * 添加nValue
 * @param nValue 添加的数
 */
public void add(int nValue){
	//新建一个树节点，使其值为nValue
	TreeNode temp=new TreeNode();
	temp.nValue=nValue;
	//如果树为空,新增加的树节点为根
	if(root==null){
		root=temp;
		return ;
	}
	//如果不为空，则从根节点往下寻找加入点
	add(root,temp);
}
/**
 * 新增节点
 * @param head  从head开始往下遍历
 * @param temp  新增节点
 */
public void add(TreeNode head,TreeNode temp){
	//如果数值小于head节点，就放在左孩子上
	if(temp.nValue<head.nValue){
		//如有左孩子，继续遍历
		if(head.leftchild!=null)
			add(head.leftchild,temp);
		  //如果没有左孩子，加在左孩子上
		else
			head.leftchild=temp;
	}
	//如果数值大于head节点，就放在右孩子上
	if(temp.nValue>=head.nValue)  {
		  //如果有右孩子，继续遍历
		if(head.rightchild!=null)
			add(head.rightchild,temp);
		  //如果没有右孩子，加在右孩子上
		else
			head.rightchild=temp;
	}
}
//先序遍历
	public void xian(TreeNode head1){
		if(head1!=null){
			System.out.println(head1.nValue);
			xian(head1.leftchild);
	
			xian(head1.rightchild);
		}
	return;
	}
}