java 算法 单链表 栈 树 图

最新推荐文章于 2021-05-24 20:27:28 发布
最新推荐文章于 2021-05-24 20:27:28 发布
阅读量756 收藏 1
点赞数 1

 

package package1;

public interface LList<T> {
  /**
     * 判断线性表是否空
     * @return
     */
    boolean isEmpty();
   
    /**
     * 返回线性表长度
     * @return
     */
    int length();
   
    /**
     * 返回第i（i≥0）个元素
     * @param i
     * @return
     */
    T get(int i);
   
    /**
     * 设置第i个元素值为x
     * @param i
     * @param x
     */
    void set(int i, T x);
   
    /**
     * 插入x作为第i个元素
     * @param i
     * @param x
     */
    void insert(int i, T x);
   
    /**
     * 在线性表最后插入x元素
     * @param x
     */
    void append(T x);
   
    /**
     * 删除第i个元素并返回被删除对象
     * @param i
     * @return
     */
    T remove(int i);
   
    /**
     * 删除线性表所有元素
     */
    void removeAll();
   
    /**
     * 查找，返回首次出现的关键字为key元素
     * @param key
     * @return
     */
    T search(T key);
}

-------------------------------------------------

 

package package1;

public class Node<T> {
  /**
     * 数据域，保存数据元素
     */
    public T data;
   
    /**
     * 地址域，引用后继结点
     */
    public Node<T> next;

    /**
     * 构造结点，data指定数据元素，next指定后继结点
     *
     * @param data
     * @param next
     */
    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }

    /**
     * 构造节点
     */
    public Node() {
        this(null, null);
    }

    /**
     * 返回结点元素值对应的字符串
     */
    @Override
    public String toString() {
        return this.data.toString();
    }

    /**
     * 比较两个结点值是否相等，覆盖Object类的equals(obj)方法
     */
    @SuppressWarnings("unchecked")
    @Override
    public boolean equals(Object obj) {
        return obj == this || obj instanceof Node && this.data.equals(((Node<T>)obj).data);
    }
   
}

--------------------------------------------------------------------

 

package package1;

public class SinglyLinkedList<T> implements LList<T> {
 /**
     * 头指针，指向单链表的头结点
     */
    public Node<T> head;

    /**
     * 默认构造方法，构造空单链表
     */
    public SinglyLinkedList() {
        // 创建头结点，data和next值均为null
        this.head = new Node<T>();
    }

    /**
     * 由指定数组中的多个对象构造单链表。采用尾插入构造单链表
     * 若element==null，Java将抛出空对象异常；若element.length==0，构造空链表
     *
     * @param element
     */
    public SinglyLinkedList(T[] element) {
        // 创建空单链表，只有头结点
        this();
        // rear指向单链表最后一个结点
        Node<T> rear = this.head;
        for (int i = 0; i < element.length; i++) {
            rear.next = new Node<T>(element[i], null);
            rear = rear.next;
        }
    }

    /**
     * 判断单链表是否空，O(1)
     */
    @Override
    public boolean isEmpty() {
        return this.head.next == null;
    }

    /**
     * 返回单链表长度，O(n), 基于单链表遍历算法
     */
    @Override
    public int length() {
        int i = 0;
        // p从单链表第一个结点开始
        Node<T> p = this.head.next;
        // 若单链表未结束
        while (p != null) {
            i++;
            // p到达后继结点
            p = p.next;
        }
        return i;
    }

    /**
     * 返回第i（≥0）个元素，若i<0或大于表长则返回null，O(n)
     */
    @Override
    public T get(int i) {
        if (i >= 0) {
            Node<T> p = this.head.next;
            for (int j = 0; p != null && j < i; j++) {
                p = p.next;
            }

            // p指向第i个结点
            if (p != null) {
                return p.data;
            }
        }
        return null;
    }

    /**
     * 设置第i（≥0）个元素值为x。若i<0或大于表长则抛出序号越界异常；若x==null，不操作。O(n)
     */
    @Override
    public void set(int i, T x) {
        if (x == null)
            return;

        Node<T> p = this.head.next;
        for (int j = 0; p != null && j < i; j++) {
            p = p.next;
        }

        if (i >= 0 && p != null) {
            p.data = x;
        } else {
            throw new IndexOutOfBoundsException(i + "");
        }
    }

    /**
     * 插入第i（≥0）个元素值为x。若x==null，不插入。 若i<0，插入x作为第0个元素；若i大于表长，插入x作为最后一个元素。O(n)
     */
    @Override
    public void insert(int i, T x) {
        // 不能插入空对象
        if (x == null) {
            return;
        }

        // p指向头结点
        Node<T> p = this.head;
        // 寻找插入位置
        for (int j = 0; p.next != null && j < i; j++) {
            // 循环停止时，p指向第i-1结点或最后一个结点
            p = p.next;
        }
        // 插入x作为p结点的后继结点，包括头插入（i<=0）、中间/尾插入（i>0）
        p.next = new Node<T>(x, p.next);
    }

    /**
     * 在单链表最后添加x对象，O(n)
     */
    @Override
    public void append(T x) {
        insert(Integer.MAX_VALUE, x);
    }

    /**
     * 删除第i（≥0）个元素，返回被删除对象。若i<0或i大于表长，不删除，返回null。O(n)
     */
    @Override
    public T remove(int i) {
        if (i >= 0) {
            Node<T> p = this.head;
            for (int j = 0; p.next != null && j < i; j++) {
                p = p.next;
            }

            if (p != null) {
                // 获得原对象
                T old = p.next.data;
                // 删除p的后继结点
                p.next = p.next.next;
                return old;
            }
        }
        return null;
    }

    /**
     * 删除单链表所有元素 Java将自动收回各结点所占用的内存空间
     */
    @Override
    public void removeAll() {
        this.head.next = null;
    }

    /**
     * 顺序查找关键字为key元素，返回首次出现的元素，若查找不成功返回null
     * key可以只包含关键字数据项，由T类的equals()方法提供比较对象相等的依据
     */
    @Override
    public T search(T key) {
        if (key == null)
            return null;
        for (Node<T> p = this.head.next; p != null; p = p.next)
            if (p.data.equals(key))
                return p.data;
        return null;
    }

    /**
     * 返回单链表所有元素的描述字符串，形式为“(,)”，覆盖Object类的toString()方法，O(n)
     */
    @Override
    public String toString() {
        String str = "(";
        for (Node<T> p = this.head.next; p != null; p = p.next) {
            str += p.data.toString();
            if (p.next != null)
                str += ","; // 不是最后一个结点时后加分隔符
        }
        return str + ")"; // 空表返回()
    }

    /**
     * 比较两条单链表是否相等
     */
    @SuppressWarnings("unchecked")
    @Override
    public boolean equals(Object obj) {
        if (obj == this)
            return true;

        if (obj instanceof SinglyLinkedList) {
            SinglyLinkedList<T> list = (SinglyLinkedList<T>) obj;
            return equals(this.head.next, list.head.next);
        }
        return false;
    }

    /**
     * 比较两条单链表是否相等，递归方法
     *
     * @param p
     * @param q
     * @return
     */
    private boolean equals(Node<T> p, Node<T> q) {
        return p == null && q == null || p != null && q != null
                && p.data.equals(q.data) && equals(p.next, q.next);
    }
}

----------------------------------------------------------

package package1;


// 文档的分割与合并，  基于大文档
public class test {

 public static void main(String[] args) {
   SinglyLinkedList<String> lista = new SinglyLinkedList<String>();
         for (int i = 0; i <= 5; i++)
             lista.insert(i, new String((char) ('A' + i) + ""));
        
         System.out.println("本案例中链表的初始位置是0，即 元素是从第0个位置开始数的\n ");
        
         System.out.println("数组lista的所有元素值依次插入到单链表中，数据分别是：\n " + lista.toString());

        
         System.out.println("单链表的长度是length()="+ lista.length());
        
         System.out.println("返回第0个链表节点值lista.get(0):"+ lista.get(0) );
        
         System.out.println("返回最后一个链表节点值lista.get(5):"+ lista.get(5) );
              
       
        
        
         lista.set(0, new String((char) (lista.get(0).charAt(0) + 32) + ""));
         System.out.println("修改 链表的第0个数据值 数据后，新的链表元素值分别是：\n" + lista.toString());

        
         String x="x";
   lista.insert(2, x);
         System.out.println("单链表第二个位置插入x后，数据分别是:\n"+ lista.toString() );

        
         lista.remove(6);
         System.out.println("单链表 删除 第6个位置数据后，数据分别是:\n"+ lista.toString() );
       
        
         System.out.println("search链表元素值是：\n" + lista.search("x"));
 
 }

}

 

 

==============================================

顺序栈

package package1;

public class SeqStack
{
 private static final int MAXSIZE = 100;
 private int top;
 private String[] data;

 SeqStack()
 {
  Init_SeqStack(MAXSIZE);
 }

 private void Init_SeqStack(int size)
 {
  data = new String[size];
  top = -1;
 }

 public int Empty_SeqStack()
 {
  if (top == -1)
   return 1;
  else
   return 0;
 }

 public int Full_SeqStack()
 {
  if (top == MAXSIZE - 1)
   return 1;
  else
   return 0;
 }

 public int Push_SeqStack(String x)
 {
  if (Full_SeqStack() == 1)
   return 0;
  else
  {
   top++;
   data[top] = x;
   return 1;
  }
 }

 public String Pop_SeqStack()
 {
  if (Empty_SeqStack() == 1)
   return null;
  else
   return data[top--];
 }

 public String Top_SeqStack()
 {
  if (Empty_SeqStack() == 1)
   return null;
  else
   return data[top];
 }

}

 

 

 

 

 

 

 

 

===========下列转载的文章，谢谢合作！知识共享！

http://blog.csdn.net/yaoweijq/article/details/7183937  Java中栈的最大递归深度http://blog.chinaunix.net/uid-20384806-id-1954176.html 递归的本质：使用 栈 来实现，

 

 http://blog.csdn.net/jiutianhe/article/details/18605999

===========

 

二叉树        

 

 

 

 

递归  全排列：

123    213   231  321  312  132  

 

  

 

===========

 

二叉树     

 

案例一：   

package com.cxl.algorithm;

// 二叉树接口的ADT
public interface IBiTree
{

}

 

---------------------------

package com.cxl.algorithm;

// 二叉树的 链式  结点 的结构
public class LinkBiTNode
{
 public int data;
 public LinkBiTNode lchild;
 public LinkBiTNode rchild;

 public void LinkBiTNode(LinkBiTNode lchildval, LinkBiTNode rchildval)
 {
  lchild = lchildval;
  rchild = rchildval;
 }

 public LinkBiTNode(int elem, LinkBiTNode lchildval, LinkBiTNode rchildval)
 {
  data = elem;
  LinkBiTNode(lchildval,rchildval);
 }

 
 
}

---------------------------------

package com.cxl.algorithm;

public class LinkBiTree implements IBiTree
{
 private LinkBiTNode root; // 用于指示二叉树的根节点

 public LinkBiTNode getRoot()
 {
  return root;
 }

 public void setRoot(LinkBiTNode root)
 {
  this.root = root;
 }

 public void insert(int value)
 {
  LinkBiTNode newNode = new LinkBiTNode(value, null, null);

  if (root == null)
  {
   root = newNode;
  } else
  {
   LinkBiTNode currentNode = root;
   LinkBiTNode parentNode;
   while (true)
   {
    parentNode = currentNode;
    // 往右放
    if (newNode.data > currentNode.data)
    {
     currentNode = currentNode.rchild;
     if (currentNode == null)
     {
      parentNode.rchild = newNode;
      return;
     }
    } else
    {
     // 往左放
     currentNode = currentNode.lchild;
     if (currentNode == null)
     {
      parentNode.lchild = newNode;
      return;
     }

    }
   }

  }
 }

 LinkBiTree()
 {
  root = null;
 }
}
/*
 * public LinkBiTree initiate() { // 初始建立一颗带有头节点的二叉树；
 *
 * LinkBiTNode bt = new LinkBiTNode(null, null);
 *
 * LinkBiTree T = new LinkBiTree();
 *
 * T.root = bt;
 *
 * return T; }
 *
 * public LinkBiTree create(String x, LinkBiTree lbt, LinkBiTree rbt) { //
 * 初始建立一颗以X为根节点的二叉树； LinkBiTree T = new LinkBiTree(); LinkBiTNode bt = new
 * LinkBiTNode(x, null, null);
 *
 * T.root = bt; // T.bt.lchild = lbt; // T.bt.rchild = rbt; return T; }
 *
 * public LinkBiTree createBiTree(String x, LinkBiTree lbt, LinkBiTree rbt) { //
 * 初始建立一颗以X为根节点的二叉树； LinkBiTNode temp = null ; if(root == null) { temp = new
 * LinkBiTNode(x,null,null); root = temp ; } else { while(temp) { if( x <
 * root.data ) temp = root.lchild ; root = temp ; else temp = root.rchild ; root
 * = temp }
 *
 * }
 *
 *
 *
 * LinkBiTree T = new LinkBiTree(); LinkBiTNode bt = new LinkBiTNode(x, null,
 * null);
 *
 * T.root = bt; // T.bt.lchild = lbt; // T.bt.rchild = rbt; return T; }
 *
 * }
 */

--------------------------------

package com.cxl.algorithm;
public class test {

  public static void main(String[] args) {
  
   LinkBiTree tree = new LinkBiTree();
   tree.insert(10);
    tree.insert(40);
    tree.insert(20);
    tree.insert(3);
    tree.insert(49);
    tree.insert(13);
    tree.insert(123);
           
    System.out.println("root=" + tree.getRoot().data);

  
         System.out.println("================================ ");

 

 

===========

 

 上述案例代码更新：

package package1;

//二叉树的 链式  结点 的结构
public class LinkBiTNode
{

public int data;
public LinkBiTNode lchild;
public LinkBiTNode rchild;

public void LinkBiTNode(LinkBiTNode lchildval, LinkBiTNode rchildval)
{
lchild = lchildval;
rchild = rchildval;
}

public LinkBiTNode(int elem, LinkBiTNode lchildval, LinkBiTNode rchildval)
{
data = elem;
LinkBiTNode(lchildval,rchildval);
}

 

}

 

------------------------

 

package package1;

public class LinkBiTree implements IBiTree
{
 //LinkBiTNode p = null;

 private LinkBiTNode root; // 用于指示二叉树的根节点

 public LinkBiTNode getRoot()
 {
  return root;
 }

 public void setRoot(LinkBiTNode root)
 {
  this.root = root;
 }

 public void insertLTree(int value)
 {
  LinkBiTNode newNode = new LinkBiTNode(value, null, null);
  if (root == null)
   root = newNode;
  else
  {   
   LinkBiTNode parentNode = root;
   while (parentNode.lchild != null)//找到左叶子结点
   {    
     parentNode = parentNode.lchild;    
   }
   parentNode.lchild = newNode;
  }

 }

 public LinkBiTNode search(LinkBiTNode bt ,int x ) //返回指定元素值得对象内存空间
 {
     LinkBiTNode p = null;
  if( bt != null)
  {
   if( bt.data == x ) return bt ;
   if(bt.lchild != null) p = search(bt.lchild, x);
   if(p != null ) return p;
   
   if(bt.rchild != null) p = search(bt.rchild, x);
   if(p != null) return p;
  }
  
 
   return null;
 }
 
 
 public int countLeaf( LinkBiTNode bt )//统计二叉树的叶子结点个数
 {
  if(bt == null) return 0 ;
    
  if(bt.lchild ==null && bt.rchild ==null) return 1;
  return ( countLeaf(bt.lchild)+countLeaf(bt.rchild));
 }
 
 
 
 public void insert(int value)
 {
  LinkBiTNode newNode = new LinkBiTNode(value, null, null);

  if (root == null)
  {
   root = newNode;
  } else
  {
   LinkBiTNode currentNode = root;
   LinkBiTNode parentNode;
   while (true)
   {
    parentNode = currentNode;
    // 往右放
    if (newNode.data > currentNode.data)
    {
     currentNode = currentNode.rchild;
     if (currentNode == null)
     {
      parentNode.rchild = newNode;
      return;
     }
    } else
    {
     // 往左放
     currentNode = currentNode.lchild;
     if (currentNode == null)
     {
      parentNode.lchild = newNode;
      return;
     }

    }
   }

  }
 }

 LinkBiTree()
 {
  root = null;
 }

 public void PreOrder(LinkBiTNode bt)
 {
  if (bt == null)
   return;
  System.out.print(bt.data + "-");
  PreOrder(bt.lchild);
  PreOrder(bt.rchild);
 }

}

--------------------------------------

 

package package1;


// 文档的分割与合并，  基于大文档
public class test {

 public static void main(String[] args) {
  
  LinkBiTree tree = new LinkBiTree();
      tree.insert(10);
      tree.insert(40);
      tree.insert(20);
      tree.insert(3);
      tree.insert(49);
      tree.insert(13);
      tree.insert(123);
      tree.insertLTree(55);
             
      System.out.println("root=" + tree.getRoot().data);

    
           System.out.println("================================ ");
           tree.PreOrder(tree.getRoot() );
           System.out.println(tree.search(tree.getRoot(), 13));
           System.out.println("叶子结点个数是："+tree.countLeaf(tree.getRoot()));

 }

}

========================================================

package queue;

//自己定义的 队列

public class MyQueue
{

 
 private int [] data;//存储元素的  数组空间
 private int num;//用于存储队列的元素   当前总的个数
 private int front ; // 对头
 private int end ; // 对尾
 
 public MyQueue(){
    data = new int[10];
    num =0;
    front =0;
    end =-1;
   }

  /**
    * 带参数的构造方法
    */
   public MyQueue(int maxsize){
    data = new int[maxsize];
    num =0;
    front =0;
    end =-1;
   }

   // 添加队列元素
   public void insert(int value){

    data[++end] = value;
    num++;
   }
  
  
   public long remove(){

   num--;
    return data[front++];
   
   }
  
  
   //查看数据
   public long peek(){
   return  data[front];
   }

   //判断是否为空
   public boolean isEmpty(){
    return num == 0 ;
   }
  
  
   public boolean isFull(){
    return num == data.length ;
   }
  
  
  
}

------------------------------------------------------------

package queue;

public class TestMyQueue
{

 public static void main(String[] args)
 {
  MyQueue myQueue = new MyQueue();
    
  myQueue.insert(100);
  myQueue.insert(200);
  myQueue.insert(300);
  myQueue.insert(400);
  myQueue.insert(500);
  
  System.out.println("队列的头元素是："+myQueue.peek());
  System.out.print("队列中的每一个元素是：");
  while (!myQueue.isEmpty()) {
   System.out.print( myQueue.remove() + "  ");
   
  }
  System.out.println();

 }

}

 

 

队列的头元素是：100
队列中的每一个元素是：100  200  300  400  500 
==============================================================================

 

 

package queue;

//自己定义的  改进后 的   循环  队列

public class MyQueue
{

 private int MAXSIZE = 5;
 private int[] data;// 存储元素的 数组空间
 private int num;// 用于存储队列的元素 当前总的个数
 private int front; // 对头
 private int end; // 对尾

 public MyQueue()
 {
  data = new int[MAXSIZE];
  num = 0;
  front = 0;
  end = -1;
  System.out.println(
    "默认队列的信息是：队列的总容量是： " + MAXSIZE + "；\n已经存储的元素个数是： " + num + " ; \n队首指针是：" + front + ";\n队尾指针是：" + end);
 }

 /**
  * 带参数的构造方法
  */
 public MyQueue(int maxsize)
 {
  MAXSIZE = maxsize;
  data = new int[maxsize];
  num = 0;
  front = 0;
  end = -1;
  System.out.println("自己制定的队列的信息是：队列的总容量是： " + MAXSIZE + "；\n已经存储的元素个数是： " + num + " ; \n队首指针是：" + front
    + ";\n队尾指针是：" + end);

 }

 // 添加队列元素
 public void insert(int value)
 {

  //if (end == data.length - 1)
  //{
  // end = -1;
  //}
  if (num == MAXSIZE)
  {
   System.out.println("队列已满，无法再插入新元素了！");
  } else
  {
   end = (end + 1) % MAXSIZE;
   data[end] = value;
   num++;
   System.out.println("你往队列中插入了一个新元素：" + value + " ；队列存储的元素个数 是："+num +" ;front is "+ front +" ; end is :"+ end);

  }
 }

 public long remove()
 {

  if (num == 0)
  {
   System.out.print("队列  已空 ，无法再 删除 元素了！ 返回的 0 代表的是 空元素---");
   return 0;
  } else
  {
   num--;
   long i = data[front];

   front = (front + 1) % MAXSIZE;
   System.out.println("你从队列中 删除了队首 头元素：" + i + " ；队列存储的元素个数 是："+num +" ;front is "+ front +" ; end is :"+ end +"；");
   return i;
  }

 }

 // 查看数据
 public long peek()
 {
  System.out.print("队列首元素front指针是："+front+" ；你 现在 从队列中  查看  队首 头元素：");
  return data[front];
 }

 // 判断是否为空
 public boolean isEmpty()
 {
 // System.out.print("当前队列 包含的元素  是 空的 。");
  return num == 0;
 }

 public boolean isFull()
 {
  System.out.print("当前队列 包含的元素  是 满的 。");
  return num == data.length;
 }

}

------------------------------------------------

 

package queue;

public class TestMyQueue
{

 public static void main(String[] args)
 {
  MyQueue myQueue = new MyQueue();
    
  myQueue.insert(100);
  myQueue.insert(200);
  myQueue.insert(300);
  myQueue.insert(400);
  myQueue.insert(500);
  myQueue.insert(1500);
  
  System.out.println("队列的头元素是："+myQueue.peek());

  myQueue.remove();
  myQueue.remove();
  myQueue.remove();
  myQueue.insert(1500);
  myQueue.insert(1500);
  
  System.out.println("队列中的每一个元素是：");
  while (!myQueue.isEmpty()) {
   System.out.print( myQueue.remove() + "  ");
   
  }
  System.out.println();
  
  myQueue.remove();
  
  
 }

}

-----------------------------------------

 

默认队列的信息是：队列的总容量是： 5；
已经存储的元素个数是： 0 ;
队首指针是：0;
队尾指针是：-1
你往队列中插入了一个新元素：100 ；队列存储的元素个数 是：1 ;front is 0 ; end is :0
你往队列中插入了一个新元素：200 ；队列存储的元素个数 是：2 ;front is 0 ; end is :1
你往队列中插入了一个新元素：300 ；队列存储的元素个数 是：3 ;front is 0 ; end is :2
你往队列中插入了一个新元素：400 ；队列存储的元素个数 是：4 ;front is 0 ; end is :3
你往队列中插入了一个新元素：500 ；队列存储的元素个数 是：5 ;front is 0 ; end is :4
队列已满，无法再插入新元素了！
队列首元素front指针是：0 ；你 现在 从队列中  查看  队首 头元素：队列的头元素是：100
你从队列中 删除了队首 头元素：100 ；队列存储的元素个数 是：4 ;front is 1 ; end is :4；
你从队列中 删除了队首 头元素：200 ；队列存储的元素个数 是：3 ;front is 2 ; end is :4；
你从队列中 删除了队首 头元素：300 ；队列存储的元素个数 是：2 ;front is 3 ; end is :4；
你往队列中插入了一个新元素：1500 ；队列存储的元素个数 是：3 ;front is 3 ; end is :0
你往队列中插入了一个新元素：1500 ；队列存储的元素个数 是：4 ;front is 3 ; end is :1
队列中的每一个元素是：
你从队列中 删除了队首 头元素：400 ；队列存储的元素个数 是：3 ;front is 4 ; end is :1；
400  你从队列中 删除了队首 头元素：500 ；队列存储的元素个数 是：2 ;front is 0 ; end is :1；
500  你从队列中 删除了队首 头元素：1500 ；队列存储的元素个数 是：1 ;front is 1 ; end is :1；
1500  你从队列中 删除了队首 头元素：1500 ；队列存储的元素个数 是：0 ;front is 2 ; end is :1；
1500 
队列  已空 ，无法再 删除 元素了！ 返回的 0 代表的是 空元素---

 

====================

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

MAGANG255
关注
java基于链表实现树结构(算法源码)
01-15
/* * 基于链表实现树结构 */ package dsa; public class TreeLinkedList implements Tree { private Object element;//树根节点 private TreeLinkedList parent, firstChild, nextSibling;//父亲、长子及最大的弟弟 //（单节点树）构造方法 public TreeLinkedList() { this(null, null, null, null); } //构造方法 public TreeLinkedList(Object e, TreeLinkedList p, TreeLinkedList c, TreeLinkedList s) { element = e; parent = p; firstChild = c; nextSibling = s; } /*---------- Tree接口中各方法的实现 ----------*/ //返回当前节点中存放的对象 public Object getElem() { return element; } //将对象obj存入当前节点，并返回此前的内容 public Object setElem(Object obj) { Object bak = element; element = obj; return bak; } //返回当前节点的父节点；对于根节点，返回null public TreeLinkedList getParent() { return parent; } //返回当前节点的长子；若没有孩子，则返回null public TreeLinkedList getFirstChild() { return firstChild; } //返回当前节点的最大弟弟；若没有弟弟，则返回null public TreeLinkedList getNextSibling() { return nextSibling; } //返回当前节点后代元素的数目，即以当前节点为根的子树的规模 public int getSize() { int size = 1;//当前节点也是自己的后代 TreeLinkedList subtree = firstChild;//从长子开始 while (null != subtree) {//依次 size += subtree.getSize();//累加 subtree = subtree.getNextSibling();//所有孩子的后代数目 } return size;//即可得到当前节点的后代总数 } //返回当前节点的高度 public int getHeight() { int height = -1; TreeLinkedList subtree = firstChild;//从长子开始 while (null != subtree) {//依次 height = Math.max(height, subtree.getHeight());//在所有孩子中取最大高度 subtree = subtree.getNextSibling(); } return height+1;//即可得到当前节点的高度 } //返回当前节点的深度 public int getDepth() { int depth = 0; TreeLinkedList p = parent;//从父亲开始 while (null != p) {//依次 depth++; p = p.getParent();//访问各个真祖先 } return depth;//真祖先的数目，即为当前节点的深度 } }
java单链表算法_Java单链表
weixin_39656174的博客
03-01 91
/*** This class implements a SinglyLinked List. This is done* using SinglyLinkedList class and a LinkForLinkedList Class.** A linked list is similar to an array, it hold values.* However, links in a l...
java 数据结构单链表之算法
weixin_45519487的博客
05-31 270
1. 链表的介绍 链表时有序的列表，但是它在内存中的存储如下： 1. 链表是以节点的方式来储存的，是链式存储。 2 . 每个节点包括 data域、 next域：指向下一个节点。 3 . 链表的每个节点不一定是连续存储的，如上图所示。 4 链表分为带头节点的链表 和不带头节点的链表。 带头节点的单链表的逻辑结构示意图如下： ...
Java中链表相关算法
孤独风中一条狼
01-21 960
如下为链接节点，后续都用此表示链接节点 class ListNode{ int value; ListNode next; public ListNode(int value,ListNode next){ } } 1、链表的反转方法 /*** * 循环方法实现链表反转 * @param
Java实现顺序表、链表、栈、队列、二叉树、图
记录学习点滴
02-05 677
文章目录1 顺序表2 链表3 栈4 队列5 二叉树6 图 1 顺序表 import java.util.Scanner; //此示例顺序表下标从 1 开始，不是 0 class DATA { String key; String name; int age; } class SLType { static final int MAXLENGTH = 100; ...
Java实现单链表以及单链表的操作.zip
09-02
单链表是一种简单但灵活的数据结构，常用于实现各种抽象数据类型，如队列、栈和映射。本教程将深入探讨如何使用Java语言来实现单链表及其相关操作。 首先，我们来理解单链表的基本概念。单链表由一系列节点组成，每...
java 实现单链表逆转详解及实例代码
08-31
单链表逆转是数据结构与算法中的一个常见问题，它要求改变链表中节点的顺序，使得原本的链表头成为尾，原本的尾成为头。在这个Java实现中，我们有两个方法来完成这个任务：一个使用递归，另一个使用循环。 1. **...
Java基于链表实现栈的方法详解
08-19
Java基于链表实现栈的方法详解 在计算机科学中，栈是一种常用的数据结构，常用于实现递归算法、函数调用、表达式求值等场景。Java中有多种方式实现栈，其中使用链表实现栈是一种常见的方法。下面将详细介绍Java基于...
Java实现单链表的基本操作
01-06
在编程领域，数据结构是构建复杂算法的基础，而链表作为一种基本的数据结构，常常被用于解决各种问题。本文将深入探讨如何使用Java语言实现单链表的基本操作，包括创建链表、插入节点、删除节点以及遍历链表等关键...
整理收集Java算法编程文档
05-09
Java算法编程文档是Java开发者在面试和笔试过程中必备的学习资源，涵盖了从基础到高级的各种算法和数据结构。这些文档能够帮助开发者提升问题解决能力，更好地理解计算机科学的基础，并且在实际工作中解决复杂的问题...
常见链表相关算法-java语言实现
sinat_27143551的博客
11-12 1046
本文将介绍： 单链表反转 求中间节点 删除倒数第K个节点 合并两个有序链表 检测环，并找到入口点 两个单链表相交的起始节点 奇偶链表 回文链表 Node定义： public static class Node { private int data; private Node next; public Node(int data, Nod...
单向单链表的java实现
心里打结，为了过得舒服点，只好拼命的开结
09-19 111
单向表 package datamemory.link; //单链表 public class ObjectLink { private int size;// 链表长度 private ObjectNode head;// 头节点 public void add(Object obj) { Object...
单链表（Java）
Cenhelm的博客
03-10 242
单链表 顺序表有两个主要缺点：插入和删除效率低下，时间复杂度都是O(n)；数组一旦创建，大小不可改变 链表方式：逻辑相邻，物理不相邻 单链表是用一个指向后继元素的指针将具有线性关系的各个节点链接起来，最后一个节点的后继指针为空指针 数据域 节点保存的数据元素（data） 指针域 指向后继节点的指针（next） data next 带头节点的单链表 头节点本身不包含有效...
Java实现单链表
tanxinji的博客
05-24 3035
实现一个可以用任意对象为结点的单链表。嘻嘻，埋伏笔了。因为我是用内部类来实现结点的操作（Java-内部类），和用上一篇文章的Student类来作为本链表的结点的测试案例，另外还有一个如何删除对象结点，哈哈，也是上一篇的，为了防止可能看不懂，记得去看看上一篇的文章哦（Java继承原来就是这样）。创建的任意类对象的实例可以成为单链表的结点，这里也用到的就是一点点泛型的知识。另外提一下，如何解决我的那篇多态的文章的向下转型带来的不安全性就是可以用泛型解决的啦（Java多态到底教了我干啥?）。 一开始以为单链表只
java 链表类_Java实现的单链表类
weixin_33968957的博客
02-21 311
//单链表类，写明方法public class SinglyLinkedList{public class Node{public T data;public Nodenext;public Node(T data,Nodenext){this.data=data;this.next=next;}public Node(){this(null,null);}}public Nodehead;pub...
java实现单链表类的定义_通过Java实现单链表来透彻理解抽象数据类型的定义和应用...
weixin_39650784的博客
02-27 270
Java实现单链表本文将数据结构知识中重要知识点：数据元素，结点，数据类型，抽象数据类型，抽象数据类型的实现、以及对新定义的数据结构的应用等知识通过下述java代码的形式串联起来，以从宏观上对数据结构有一个透彻的理解和认识。我们要使用单链表这个数据结构来解决问题的前提是首先得创建一个单链表数据结构。创建单链表数据结构，就得自定义个单链表的抽象数据类型，抽象数据类型只是对数据结构定义一组逻辑操作，没...
Java基础 - 线性表之链式存储结构-单链表
ApatheCrazyFan的博客
11-05 529
链式存储结构的线性表（简称为链表）将采用一组地址任意的存储单元存放线性表中的数据元素。链式存储结构的线性表不会按线性的逻辑顺序来保存数据元素，它需要在每个数据元素中保存一个引用下一个数据元素的引用（或者叫做指针）。
数据结构之层序遍历二叉树
wrc_nb的博客
05-17 406
#include &lt;iostream&gt;using namespace std;struct BitNode { char data; BitNode *lchild; BitNode *rchild;};struct LinkNode { BitNode *data; LinkNode *next;};struct LinkQueue{ LinkNode *front; LinkNod...
【数据结构】——求二叉树某结点在先序、中序、后序遍历中的访问次序
qq_41932198的博客
06-19 3094
题目要求 设二叉树采用二叉链表存储结构，结点数据域为字符类型。编写程序，用先序递归遍历法建立二叉树的二叉链表存储结构。然后输入一个字符，输出该字符在先、中、后序遍历中的访问次序（访问次序从1开始）以及先、中、后序遍历结果。若输入的字符不在二叉树中，输出相应提示信息。要求程序可以反复输入字符并输出访问次序及遍历结果，直到输入某个特殊字符时结束程序。注意：输入单个字符时需对其后的换行符进行处理。 数据结构设计 用结构体建立二叉树的二叉链表结构。其中，data表示数据域，lc...
单链表退出栈的Java实现与测试
在本资源中，我们将探讨如何使用Java语言实现一个特殊的堆栈结构——SingleLinkedDropOutStack（单链表退出堆栈）。该堆栈的特殊之处在于其固定容量限制，当堆栈达到其最大容量时，添加新的元素会触发最底部的元素被...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值