[数据结构与算法] 1 单向链表 实现栈 ， 双端链表实现队列，双向链表

1.

package List;

import android.content.ContentUris;
import android.content.Context;

/**  参考：https://www.cnblogs.com/ysocean/p/7928988.html
 * Created by zengjx on 2019/1/25.
 */

public class SingleLinkedList {
    private int size = 0;//链表长度
    private Node head = null;//单项链表头
    public SingleLinkedList() {
        size = 0;
        head = null;
    }
    class Node {
        private Object data;
        private Node next;
        public Node(Object obj) {
            this.data = obj;
        }
    }
    //链表头添加元素
    //1.如果链表为空 head直接指向新节点
    //2.链表不为空:  新节点的next 指向head
    public Object addItemToHead(Object object) {
        Node NewHeadNode = new Node(object);
        if (size == 0) {
            head = NewHeadNode;
        } else {
            NewHeadNode.next = head;
            head = NewHeadNode;
        }
        size++;
        return NewHeadNode;
    }
    //获取链表节点
    public Object getSingleLinkedList(int index) {
        Node temp = head;
        if (index <= size) {
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
            return temp.data;
        }
        return null;
    }
    public int getSize() {
        return size;
    }
    //链表未尾添加元素
    //1.链表为空 ：head-->newNode   size++
    //2.链表不为空:遍历到最后一个节点 temp.next-> newNode
    public boolean addNodeToListTail(Object object) {
        Node NewNode = new Node(object);
        if (size == 0) {
            head=NewNode;
            size++;
        } else {
            Node CurrentNode = head;
            for (int i = 0; i < size - 1; i++) {
                CurrentNode = CurrentNode.next;
            }
            CurrentNode.next = NewNode;
            NewNode.next = null;
            size++;
        }
        return true;
    }
    //删除指定的元素，删除成功返回true
    public boolean DeleteByValue(Object value) {
        boolean bRet = false;
        if (size == 0) {
            return false;
        } else if (size > 1) {
            Node CurentNode = head.next;
            Node  PreNode=head;
               while(CurentNode.next!=null) {
                if (value.equals(CurentNode.data)) {
                    size--;
                    PreNode.next=CurentNode.next;
                    return true;
                }else{
                    CurentNode=CurentNode.next;
                    PreNode=PreNode.next;
                }

            }
        } else if (size == 1) {
            if (head.data.equals(value)) {
                head = null;
                size = 0;
                return true;
            } else {
                return false;
            }
        }
        return bRet;
    }
    public String PrintSingleList() {
        if (size > 0) {
            StringBuffer stringBuffer = new StringBuffer();
            for (int i = 0; i < size; i++) {
                Object object = getSingleLinkedList(i);
                if (object != null) {
                    stringBuffer.append("第" + i + "项:" + object + "\n");
                }
            }
            return stringBuffer.toString();
        }
        return   null;
    }
    /*****
     * 判断链表是否为空，为空返回false   不为空返回 true
     * @return
     */
    public    boolean  isEmpty(){
        return   (size==0);
    }
    //用单向链表实现栈：对应 栈操作push() ---- 链表头插入addHead()
    // 链表头删除。
    public    void   push(Object object){
         addItemToHead(object);
    }
    //栈删除一个元素
    public   Object  pop(){
      return    objDeleteFromHead();
    }
    /***
     * 链表头删除一个元素删除成功返回true,删除失败返回false
     * @return
     */
    public    boolean   DeleteFromHead(){
        if(size==0){
        return   false;
        }else if(size==1){
        size=0;
        head=null;
        }else if(size>1){
        head=head.next;
        size--;
        return    true;
        }
        return  false;
        }
    /***
     * 链表头删除一个元素删除成功返回删除的对象,删除失败返回null
     * @return
     */
    public    Object   objDeleteFromHead(){
        if(size==0){
            return   null;
        }else if(size==1){
            size=0;
            Object object=head.data;
            head=null;
            return  object;
        }else if(size>1){
            Object  object=head.data;
            head=head.next;
            size--;
            return   object ;
        }
        return  null;
    }
}

2.调用：

package com.example.zengjx.myjavabase;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import org.w3c.dom.Node;

import List.SingleLinkedList;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    private Button  btn_1,btn_2;
    private TextView  textShow;
   final  private String  TAG="MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
    }
    public    void   initView(){
        btn_1=(Button)findViewById(R.id.btn_1);
        btn_1.setOnClickListener(this);
        btn_2=(Button)findViewById(R.id.btn_2);
        btn_2.setOnClickListener(this);
        textShow=(TextView)findViewById(R.id.tv_Log);
    }
    @Override
    public void onClick(View view) {
            switch (view.getId()){
            case R.id.btn_1:
                setBtn_1();
            break;
            case  R.id.btn_2:
                setBtn_2();
            break;
            }
    }
    public   void   setBtn_1(){
        SingleLinkedList   singleLinkedList  =new SingleLinkedList();
        //头插入
       // for(int i=0;i<10;i++){
      //      singleLinkedList.addItemToHead(i*2);
      //  }
        //后插入
        for(int i=0;i<10;i++){
            singleLinkedList.addNodeToListTail(i);
        }
        int size=singleLinkedList.getSize();
       if(size>0){
           String  str=  singleLinkedList.PrintSingleList();
           StringBuffer  sb=new StringBuffer();
           sb.append("原链表");
           sb.append(str);
           //删除链表
           boolean  ret=   singleLinkedList.DeleteByValue(6);
           if(ret==true){
               sb.append("删除成功后"+"\n");
               String  str2=  singleLinkedList.PrintSingleList();
               sb.append(str2);
           }else{
               sb.append(str+"删除失败"+"\n");
               String  str2=  singleLinkedList.PrintSingleList();
               sb.append(str2);
           }
           textShow.setText(sb);
       }
    }
    public void setBtn_2() {
          SingleLinkedList   singleList =new SingleLinkedList();
          //入栈
        singleList.push("111111");
        singleList.push("222222");
        singleList.push("300000");
        //显示
        String  str=singleList.PrintSingleList();
        Log.d(TAG,"入栈"+str);
        //出栈
        int size=singleList.getSize();
        for(int i=0;i<size;i++){
        Object   object=singleList.pop();
            Log.d(TAG,"i="+i+"---删除"+object+"\n");
            String  pstr=singleList.PrintSingleList();
            if(pstr!=null){
                Log.d(TAG,"第"+i+"出栈"+pstr+"\n");
                if(singleList.isEmpty()){
                    Log.d(TAG,"链表为空\n");
                }
            }else{
                if(singleList.isEmpty()){
                    Log.d(TAG,"链表为空\n");
                }

            }
        }
    }
}

 双端链表：

package List;

/**
 * Created by zengjx on 2019/1/26.
 */

public class DoublePointList {
    private   Node Head;
    private   Node Tail;
    private   int Size;
   public   DoublePointList(){
        Head=null;
       Tail=null;
       Size=0;

    }
    private   class   Node{
        private  Object  data;
        private  Node next;
        public Node(Object  data){
          this.data=data;
          next=null;
        }
    }
    //链表头新增节点
    //1.链表为空  head,tail---->NewNode
    //链表不为空  NewNode.Next---->Head, Head--->NewNode
    public void addHead(Object data){
       Node    NewNode =new Node(data);
       if(Size==0){
       Head=NewNode;
       Tail=NewNode;
       }else {
        NewNode.next=Head;
        Head=NewNode;
       }
       Size++;
    }
    public String PrintSingleList() {
        if (Size > 0) {
            StringBuffer stringBuffer = new StringBuffer();
            for (int i = 0; i < Size; i++) {
                Object object = getSingleLinkedList(i);
                if (object != null) {
                    stringBuffer.append("第" + i + "项:" + object + "\n");
                }
            }
            return stringBuffer.toString();
        }
        return   null;
    }
    //获取链表节点
    public Object getSingleLinkedList(int index) {
        Node temp = Head;
        if (index <= Size) {
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
            return temp.data;
        }
        return null;
    }
    public    int getSize(){
        return   Size;
    }
    //获取链表尾
    public   Object  getTail(){
      if(Size==0){
          return  null;
      }else{
          return  Tail.data;
      }
    }
    //链表尾新增节点
    public void addTail(Object data)
    {
       Node   NewNode= new Node(data);
       if(Size==0){
           Head=NewNode;
           Tail=NewNode;
       }else{
           Tail.next=NewNode;//当前尾部指向新节点
           Tail=NewNode;//尾指向新节点
       }
       Size++;
    }
   //链表是否为空
   public    boolean   isEmpty(){
        return  (Size==0);
   }
    //删除头部节点，成功返回true，失败返回false
    public boolean deleteHead(){
      if(Size==0){
          return   false;
      }else if(Size==1){
          Head=null;
          Tail=null;
          Size=0;
      }
     return true;
    }
    /**
     * 删除链表尾部
     *
     * @return
     */
    public  boolean  deleteTail(){
      if(Size==0){
          return   false;

      }  else if(Size==1){
          Head=null;
          Tail=null;
          Size=0;
      }else if(Size>1){
          Node  TempNode=Head;
          for(int i=0;i<Size-2;i++){
              TempNode=TempNode.next;
          }
          Tail=TempNode;
          Tail.next=null;
          Size--;
      }else{
          return   false;
      }
      return   true;
    }
    /**
     * 删除链表尾部   返回被删除的对象
     *
     * @return
     */
    public  Object  deleteItemTail(){
        Object data=null;
        if(Size==0){
            return   null;
        }  else if(Size==1){
            Head=null;
            Tail=null;
            Size=0;
        }else if(Size>1){
            Node  TempNode=Head;
            for(int i=0;i<Size-2;i++){
                TempNode=TempNode.next;
            }
            data=Tail.data;
            Tail=TempNode;
            Tail.next=null;
            Size--;
        }else{
            return   null;
        }
        return data ;
    }
    //双端链表实现队列
    public    void   push(Object   data){
       addHead(data);
    }
    public    Object  pop(){
        return  deleteItemTail();
    }

}

测试用例：

//队列
public  void listTest(){
    DoublePointList  list=  new DoublePointList();
    //添加
        list.push("num "+1);
        list.push("num "+2);
        list.push("num "+3);
        String  str= list.PrintSingleList();
        Log.i(TAG,"队 1 列"+str);
        Log.i(TAG,"队列表尾"+list.getTail());
        list.pop();//1
        list.pop();//2
        str= list.PrintSingleList();//3
        Log.i(TAG,"队 2  列"+str);
        Log.i(TAG,"队列表尾"+list.getTail());//3
        list.pop();//空
        Log.i(TAG,"队   列是否为空"+list.isEmpty());
        list.push("num "+456);
        list.push("num "+678);
        list.push("num "+789);
          str= list.PrintSingleList();
        Log.i(TAG,"队 1 列"+str);
        Log.i(TAG,"队列表尾"+list.getTail());
}