JAVA带表头的双向链表插入,删除,查找操作

1.建立双向链表的结点Node2.建立类Linkedlist,成员head是指向表头的引用,在linkedlist中定义链表的操作方法。ps:插入删除操作要判断pos,如果在表尾,要特判防止出现空引用。
public class Node {//建立双向链表的结点
    public Node left;
    public Node right;
    public int data;
    public Node(){
        this.left=null;
        this.right=null;
        this.data=0;
    }
    public Node(int data) {
        this.data=data;
    }

}

public class Linkedlist {
    public Node head;//指向表头地址的引用
    public int length;
    public Linkedlist(){//建立头结点
        length=0;
        head=new Node();
        head.data=0;
        head.left=null;
        head.right=null;
    }
    public boolean Insert(int pos,Node node) {//在下标为pos-1和pos的结点之间插入node结点
        int count=0;
        Node preNode=head;
        while(preNode!=null&&count<pos-1) {
            ++count;
            preNode=preNode.right;
        }
        if(preNode==null||count!=pos-1){
            return false;
        }
        if(preNode.right==null) {
            preNode.right=node;
            node.left=preNode;
            node.right=null;
            ++length;
            return true;
        }
            Node nextNode=preNode.right;
            node.right=nextNode;
            node.left=preNode;
            preNode.right=node;
            nextNode.left=node;
        ++length;
        return true;
    }
    public boolean Delete(int pos) {//删除指定位置的结点
        if(pos<0||pos>=length) {
            return false;
        }
        int count=0;
        Node curNode=head;
        while(count!=pos&&curNode!=null) {
            ++count;
            curNode=curNode.right;
        }
        if(count!=pos||curNode==null) {
            return false;
        }
        if(curNode.right==null) {
            curNode.left.right=null;
            curNode=null;
        }
        if(curNode.right!=null) {//前
            curNode.left.right=curNode.right;
            curNode.right.left=curNode.left;
        }
        --length;
        return true;
    }
    public int Size() {//返回链表元素个数
        return length;
    }
    public boolean isEmpty() {
        if(length==0) {
            return true;
        }
        return false;
    }
    public boolean Traverse() {//输出链表
        Node preNode=head;
        while(preNode.right!=null) {
            preNode=preNode.right;
            System.out.print(preNode.data+" ");
        }
        return true;
    }
    public int getData(int pos) {//取得指定位置结点元素
        Node preNode=head;
        int count=0;
        while(count!=pos) {
            preNode=preNode.right;
            ++count;
        }
        return preNode.data;
    }
    public boolean Delete(Node node) {//删除node结点
        Node curNode=head;
        while(curNode!=node&&curNode!=null) {
            curNode=curNode.right;
        }
        if(curNode!=node) {
            return false;
        }
        if(curNode.right!=null) {
            curNode.left.right=curNode.right;
            curNode.right.left=curNode.left;
            --length;
            return true;
        }
        if(curNode.right==null) {
            curNode.left.right=null;
            --length;
            return true;
        }
        return false;
    }
}
public class Main {
    public static void main(String[] args) {
        Linkedlist link=new Linkedlist();
        //System.out.println(link.head==null);
        Node node1=new Node(1);
        Node node2=new Node(3);
        Node node3=new Node(5);
        Node node4=new Node(9);
        Node node5=new Node(2);
        boolean f=link.Insert(1,node1);
        f=link.Insert(2, node2);
        f=link.Insert(3, node3);
        f=link.Insert(4, node4);
        f=link.Insert(5, node5);
        //System.out.println(link.head.data);
        //System.out.println(link.head.right.data);
        //System.out.println(f);
        //Node node=node1;
        link.Delete(2);
        link.Delete(node5);
        boolean g=link.Delete(node3);
       // System.out.println("g="+g);
       //while(node!=null) {
       // System.out.println(node.data);
       // node=node.right;
       // }
       System.out.println("size="+link.Size());
       System.out.println("isempty? "+link.isEmpty());
       link.Traverse();
       System.out.println();
       System.out.println("data2="+link.getData(2));

    }
}

 
时间: 2024-10-15 09:32:05

JAVA带表头的双向链表插入,删除,查找操作的相关文章

单链表 初始化 创建 头插法 尾插法 插入 删除 查找 合并 长度

#include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR -1 #define TRUE 1 #define FALSE -1 #define NULL 0 #define OVERFLOW -2 #define ElemType int #define Status int typedef int ElemType typedef int Status #define LEN sizeof(LNode) #

顺序表 初始化 插入 删除 查找 合并 交换 判断为空 求长度

#include <stdio.h> #include <stdlib.h> #define OK 1 #define TRUE 1 #define ERROR -1 #define FALSE -1 #define OVERFLOW -2 #define ElemType int #define Status int typedef int ElemType typedef int Status #define LEN sizeof(SqList) #define MLC (Li

ios 字符串的插入删除查找与替换,删除空格

NSString *str1 = @"This is a example.";  NSMutableString *mstr = [[NSMutableString alloc] init]; //创建可变字符串  NSRange substr; //子字符串的范围mstr = [NSMutableString stringWithString:str1];  //插入字符  [mstr insertString:@"very easy " atIndex:10];

[PHP] 数据结构-链表创建-插入-删除-查找的PHP实现

链表获取元素1.声明结点p指向链表第一个结点,j初始化1开始2.j<i,p指向下一结点,因为此时p是指向的p的next,因此不需要等于3.如果到末尾了,p还为null,就是没有查找到 插入元素1.插入元素和查找类似,找到位置后2.生成新的结点s, s->next=p->next p->next=s; 删除元素1.删除元素,找到位置后2.绕过一下,q=p->next p->next=q->next; <?php class Node{ public $data

链表 创建 插入 删除 查找 合并

最近学习了一下单链表的操作,将代码保存如下,供以后查看. 链表创建: 1.先建立一个不含数据的头指针*head,头指针的链接域为NULL. 2.声明一个用于暂存新申请空间的指针*pc,一个用于保存创建的链表的指针*r,令*r指向*head. 3.在循环中,为指针*pc申请空间,并给数据域赋值,head->next = pc, pc->next = NULL, head = pc. #define _CRT_SECURE_NO_DEPRECATE /*取消scanf,printf不安全之类的错误

带表头链表结点的删除

#include <stdio.h> #include <stdlib.h> #define N 9 typedef struct node { int data; struct node *next; }ElemSN; ElemSN *Createlink(int a[],int n){ int i; ElemSN *h,*p; h=p=(ElemSN*)malloc(sizeof(ElemSN)); h->next=NULL; for(i=0;i<N;i++){ p

java实现数据结构-线性表-顺序表,实现插入,查找,删除,合并功能

package 顺序表; import java.util.ArrayList; import java.util.Scanner; public class OrderList { /** * @param args * @author 刘雁冰 * @2015-1-31 21:00 */ /* * (以下所谓"位置"不是从0开始的数组下标表示法,而是从1开始的表示法.) * (如12,13,14,15,16数据中,位置2上的数据即是13) * * 利用JAVA实现数据结构-线性表-顺

Java实现二叉排序树的插入、查找、删除

import java.util.Random; /** * 二叉排序树(又称二叉查找树) * (1)可以是一颗空树 * (2)若左子树不空,则左子树上所有的结点的值均小于她的根节点的值 * (3)若右子树不空,则右子树上所有的结点的值均大于她的根节点的值 * (4)左.右子树也分别为二叉排序树 * * * 性能分析: * 查找性能: * 含有n个结点的二叉排序树的平均查找长度和树的形态有关, * (最坏情况)当先后插入的关键字有序时,构成的二叉排序树蜕变为单枝树.查找性能为O(n) * (最好

java递归方法建立搜索二叉树,具备查找关键字,插入新节点功能

二叉排序树的定义: 二叉排序树满足以下三个性质(BST性质): <1>若它的左子树非空,则左子树上所有节点的值均小于根节点的值 <2>若它的右子树非空,则右子树上所有节点的值均大于根节点的值 <3>左,右子树本身又各是一棵二叉排序树 根据二叉排序树的BST性质,可以说二叉排序树每个节点上的值(或称关键字)都是唯一的,并且二叉排序树以中序遍历输出的结果必然是一个有序的递增序列. 如下图所示: 用递归方法建立二叉排序树,减少了繁复的比较程序,效率较高.只需要知道每个节点的值