算法最简单之_链表

node类：

//节点类
public class Node {
protected Node next; //指针域
protected int data;//数据域

public Node( int data) {
this. data = data;
}

//显示此节点
public void display() {
System. out.print( data + " ");
}
}

（一）单链表

1）构造链表



2）链表头插入

// 插入一个头节点  
public void addFirstNode( int data) {  
     Node node = new Node(data);  
     node. next = first;  
     first = node;  
} 

3）链表头删除

只需要 first = first.next 即可

// 删除一个头结点,并返回头结点  
public Node deleteFirstNode() {  
     Node tempNode = first;  
     first = tempNode. next;  
     return tempNode;  
}  

4）链表任意位置添加

添加位置前后断开，分别指向对应的引用即可

// 在任意位置插入节点 在index的后面插入  
public void add(int index, int data) {  
    Node node = new Node(data);  
    Node current = first;  
    Node previous = first;  
     while ( pos != index) {  
        previous = current;  
        current = current. next;  
         pos++;  
    }  
    node. next = current;  
    previous. next = node;  
     pos = 0;  
}

5）任意位置删除

// 删除任意位置的节点
public Node deleteByPos( int index) {
Node current = first;
Node previous = first;
while ( pos != index) {
pos++;
previous = current;
current = current. next;
}
if(current == first) {
first = first. next;
} else {
pos = 0;
previous. next = current. next;
}
return current;
}

6）链表遍历

// 显示出所有的节点信息
public void displayAllNodes() {
Node current = first;
while (current != null) {
current.display();
current = current. next;
}
System.out.println();
}

7）根据位置和根据节点查找

// 根据位置查找节点信息
public Node findByPos( int index) {
Node current = first;
if ( pos != index) {
current = current. next;
pos++;
}
return current;
}

// 根据数据查找节点信息
public Node findByData( int data) {
Node current = first;
while (current. data != data) {
if (current. next == null)
return null;
current = current. next;
}
return current;
}

（一）双链表

1）它是这样的



2）双链表整体鸟览



3）双链表添加



4）双链表删除



5）双链表代码

/**
* 双向链表
* @author yl
*
*/
public class LinkNode {
private Object obj;
private LinkNode child;
private LinkNode parent;

public LinkNode(Object obj){
this.obj=obj;
}

//定义方法
public Object getObj(){
return obj;
}
public void setObj(Object obj){
this.obj=obj;
}
public LinkNode getChild(){
return child;
}
public void setChild(LinkNode child){
this.child=child;
}
public LinkNode getParent(){
return parent;
}
public void setParent(LinkNode parent){
this.parent=parent;
}
}
再来对这个链表进行测试：
package cn.链表;
/**
* 双向链表的测试
* @author Administrator
*
*/
public class LinkListTest {
private static LinkNode front=null;
private LinkNode last=front;
public static void main(String args[]){
LinkListTest list=new LinkListTest();
list.add("头结点");
for(int i=0;i<10;i++){
list.add("结点"+i);
}
//测试指定位置下取得结点
Object obj=list.getLinkNode(3).getObj();
//测试在指定位置插入元素
list.add(3, "新来的元素");
System.out.println("<><><><><><><>"+obj);
list.printLinkNode(front);
System.out.println("<><><><><><><><><><><><><><><><><><><><><");
// list.remove(3);
// list.printLinkNode(front);
list.upDate(3, "值被改变的元素");
list.printLinkNode(front);
System.out.println("<><><><><><><><><><><><><><><><><><><><><");
list.printLinkNode1(3);

}
/**
* 在链表的后面插入元素
* @param obj
*/
public void add(Object obj){
//根据给定的值创建结点
LinkNode node=new LinkNode(obj);
if(front==null){
//如果链表为空的时候
// front.setChild(node);
// node.setParent(front);
//第一个结点也即是最后一个结点
front=node;
last=front;
// System.out.println(front.getObj());
}
else{
//新插入的结点为最后一个结点
last.setChild(node);
node.setParent(last);
last=node;
}
}
/**
* 在指定位置插入元素
* @param index
* @param obj
*/
public void add(int index,Object obj){
//先创建结点
LinkNode node=new LinkNode(obj);
//判断传入的下标
if(index<0||index>size()){
throw new RuntimeException("下标越界：size："+size()+"index："+index);
}else{
//传入的下标符合要求
if(front==null){
//如果链表为空的时候
front=node;
last=front;
}else if(index==size()){
add(node);
}else{
//链表不为空,取得当前下标的结点
LinkNode nownode=getLinkNode(index);
//得到父结点
LinkNode fnode=nownode.getParent();
//重新定义新的引用关系
fnode.setChild(node);
node.setParent(fnode);

node.setChild(nownode);
nownode.setParent(node);
}
}
}
/**
* 根据下标，删除当前的结点
* @param index
*/
public void remove(int index){
if(index<0||index>size()){
throw new RuntimeException("下标越界：size："+size()+"index："+index);
}else{
//传入的下标符合要求
if(front==null){
//如果链表为空的时候
System.out.println("链表为空，不能删除元素啦！！！");
}
else{
//链表不为空,取得当前下标的结点
LinkNode nownode=getLinkNode(index);
//得到父结点
LinkNode fnode=nownode.getParent();
//得到父结点
LinkNode cnode=nownode.getChild();
//重新定义新的引用关系
fnode.setChild(cnode);
cnode.setParent(fnode);
}
}
}
/**
* 根据下标取得当前的结点
* @param index 下标值
* @return
*/
public LinkNode getLinkNode(int index){
//判断传入的下标
if(index<0||index>size()){
throw new RuntimeException("下标越界：size："+size()+"index："+index);
}else{
//先取得头结点
LinkNode node=front;
int i=0;
while(i<index){
i++;
node=node.getChild();
}
return node;
}
}
/**
* 在指定的位置，更新该结点，结点的值为obj
* @param index
* @param obj 更改的结点的值
*/
public void upDate(int index,Object obj){
if(index<0||index>size()){
throw new RuntimeException("下标越界：size："+size()+"index："+index);
}else{
//传入的下标符合要求
if(front==null){
//如果链表为空的时候
System.out.println("链表为空，不能更新元素啦！！！");
}
else{
//链表不为空,取得当前下标的结点
LinkNode nownode=getLinkNode(index);
//给结点重新赋值
nownode.setObj(obj);
}
}
}
/**
* 得到链表的长度
* @return
*/
public int size(){
if(front==null){
//链表为空
return 0;
}else{
//不为空
LinkNode node=front;
int count=0;
while(node!=null){
count++;
node=node.getChild();
}
return count;
}
}
/**
* 打印链表
* @param node 传入链表的头结点
*/
public void printLinkNode(LinkNode node){
if(front==null){
System.out.println("此链表为空！！！");
}else{
//先取得头结点
LinkNode n=front;
//遍历链表
while(n!=null){
Object obj=n.getObj();
System.out.println(obj);
n=n.getChild();
}
}
}
/**
* 根据指定的位置来前后遍历
* @param index
*/
public void printLinkNode1(int index){
if(index<0||index>size()){
throw new RuntimeException("下标越界：size："+size()+"index："+index);
}

LinkNode nownode=getLinkNode(index);
LinkNode cnode=nownode.getChild();
int i=index;
//往前遍历
while(nownode!=null&&i>=0){
Object obj=nownode.getObj();
System.out.println(obj);
i--;
nownode=nownode.getParent();
}
nownode=getLinkNode(index);
//往后遍历
while(nownode!=null&&i<size()){
Object obj=nownode.getObj();
System.out.println(obj);
i++;
nownode=nownode.getChild();
}
}
}

参考：
http://blog.csdn.net/tayanxunhua/article/details/11100097/ http://hiliangliang1130-126-com.iteye.com/blog/1144023 http://www.cnblogs.com/xilifeng/archive/2012/10/06/2713185.html http://blog.sina.com.cn/s/blog_7d44748b01013fsf.html