算法学习Day-1

最新推荐文章于 2024-08-13 14:56:59 发布

瑾*墨

最新推荐文章于 2024-08-13 14:56:59 发布

阅读量205

点赞数

分类专栏：算法学习文章标签：算法

本文链接：https://blog.csdn.net/L161190485/article/details/81611745

版权

算法学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

算法学习Day-1

数据结构之链表

单向链表：
单向链表是最简单、最基础的链表，它的一个结点（node）分两部分:
存储结点的数据（data）信息
存储指向下一结点的地址（next）信息
最后一个结点（链尾）指向一个空地址（null）。
单向链表示意图如下图所示：

这里写图片描述

单向链表一般只在链表表头（链头）结点的位置插入元素，这样每次新加入的元素都会在链头位置，而最先加入的元素会在链尾位置。
删除操作时，如果在链头位置删除，只需要把头结点指向其下一个结点即可；如果是在中间位置删除，只需要将其前一个结点指向其下一个结点即可。

单向链表的插入分3种情况：

1.表头前插入一个新结点，链表开始处；
2.表尾后插入一个新结点，链表结束处；
3.中间插入一个新结点，随机位置。

代码如下：

package LinkedListSummary;

import java.util.List;
import java.util.Scanner;
import java.util.Stack;

public class LinkedListOnePoint {
    //头结点
    private Node head = null;
    //链表长度
    private int length = 0;

    /*初始定义节点的结构，一个节点包含了
     *data 数据存储域
     *next 下一个节点位置信息
     */

    private class Node {
        private int data;
        private Node next;

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

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

        public void setData(int data) {
            this.data = data;
        }

        public void setNext(Node next) {
            this.next = next;
        }

        public Node getNext() {
            return next;
        }

        public int getData() {
            return data;
        }

        @Override
        public String toString() {
            return "Node [data=" + data + "]";
        }
    }

    /*
     *判断链表的长度
     */

    public int getLength(Node headNode) {
        int length = 0;
        Node currentNode = headNode;
        while (currentNode != null) {
            length++;
            currentNode = currentNode.getNext();
        }
        return length;
    }

    /*
    判断链表是否为空
    正则表达式判断 如果length=0 return true；
                  如果length！=0 return false;
     */

    public boolean IsEmpty() {
        return length == 0 ? true : false;
    }

    /*
    插入结点：
    1.表头前插入一个新结点，链表开始处；
    2.表尾后插入一个新结点，链表结束处；
    3.中间插入一个新结点，随机位置。
     */

    //表头插入

    public void InsertInList(int data) {
        Node newNode = new Node(data);
        if (length == 0) {
            head = newNode;
        } else {
            newNode.next = head;
            head = newNode;
        }
        length++;
    }

//  public Node InsertInList(Node headNode,Node nodeToInsert,int position){
//      //若链表为空，直接插入
//      if(headNode==null){
//          return nodeToInsert;
//      }
//      int length= getLength(headNode);
//      //越界判断
//      if(position>length-1||position<1){
//          System.out.println("越界"+(length+1));
//          return headNode;
//      }
//      //在开头插入
//      if(position==1){
//          nodeToInsert.setNext(headNode);
//          return nodeToInsert;
//      }
//      //在链表中间或结尾插入
//      else{
//          Node previousNode=headNode;
//          int count=1;
//          while (count<position-1){
//              previousNode=previousNode.getNext();
//              count++;
//          }
//          Node currenNode=previousNode.getNext();
//          nodeToInsert.setNext(currenNode);
//          previousNode.setNext(nodeToInsert);
//      }
//      return headNode;
//  }

    /*
     *删除结点，也是结点出栈
     * 同样分为三种情况：
     * 表头
     * 表尾
     * 随机位置（中间）
     *
     * 进阶：删除指定位置结点
     */

    public Object DeleteHeadNode() {
        if (length == 0) {
            return null;
        }
        Object obj = head.data;
        if (head.next == null) {
            head = null;
        } else {
            head = head.next;
        }
        length--;
        return obj;
    }

    /*
     *删除指定结点
     */

    public boolean DeteleNode(int obj) {
        if (length == 0) {
            System.out.println("链表为空");
            return false;
        }
        Node prviousNode = null;
        Node currentNode = head;
        while (currentNode.data != obj) {
            if (currentNode.next == null) {
                System.out.println("未找到该结点");
                return false;
            }
            prviousNode = currentNode;
            currentNode = currentNode.next;
        }
        if (currentNode == head) {
            this.DeleteHeadNode();
        } else {
            prviousNode.next = currentNode.next;
            length--;
        }
        return true;
    }


    Node DeleteNode(Node headNode, int position) {

        int length = getLength(headNode);
        if (position > length || position < 1) {
            System.out.println("越界" + length);
            return headNode;
        }

        //删除表头结点

        if (position == 1) {
            Node currentNdoe = headNode.getNext();
            headNode = null;
            return currentNdoe;
        }

        //删除中间结点或表尾结点

        else {
            Node previousNode = headNode;
            int count = 1;
            while (count < position) {
                previousNode = previousNode.getNext();
                count++;
            }
            Node currenNode = previousNode.getNext();
            previousNode.setNext(currenNode.getNext());
            currenNode = null;
        }
        return headNode;
    }


    /*
     *查找，判断链表中是否包含某个元素
     */

    public boolean Contain(int data) {
        if (length == 0) {
            return false;
        }
        Node n = head;
        while (n != null) {
            if (n.data == data) {
                return true;
            } else {
                n = n.next;
            }
        }
        return false;
    }


    /*
     *打印链表
     * 正向使用栈positive
     * 反向使用递归
     */


    public void display() {
        if (length == 0) {
            System.out.println("链表为空！");
        }
        Node n = head;
        while (n != null) {
            System.out.print("<" + n.data);
            n = n.next;
        }
        System.out.println();
    }


    public void PrintListoSitiveElement(Node node) {
        if (node == null) {
            System.out.println("链表为空");
        }
        Stack<Integer> sta = new Stack<Integer>();
        while (node != null) {
            //将链表存入栈中
            sta.push((Integer) node.data);
            node = node.next;
        }
        while (!sta.empty()) {
            //出栈
            System.out.print(sta.pop() + "<");
        }
        System.out.println();
    }

    //反向打印

    public void PrintListReverseElement(Node node) {
        if (node == null) {
            System.out.println("链表为空");
        } else {
            if (node.next != null) {
                PrintListReverseElement(node.next);
            }
            System.out.print(node.data + "<");
        }
    }


    /*
     *测试
     */

    public static void main(String[] args) {
        LinkedListOnePoint list = new LinkedListOnePoint();

        //输出链表长度
        System.out.println(list.length);
        //输出链表是否为空
        System.out.println(list.IsEmpty());
        list.display();

        list.InsertInList(0);
        list.InsertInList(2);
        list.InsertInList(5);
        list.InsertInList(6);
        list.InsertInList(7);
        list.InsertInList(9);
        list.InsertInList(23);

        list.PrintListReverseElement(list.head);
        System.out.println();
        list.PrintListoSitiveElement(list.head);

        //输出链表长度
        System.out.println("输出链表长度\t" + list.length);
        //输出链表是否为空
        System.out.println("输出链表是否为空\t" + list.IsEmpty());
        System.out.println("输出所有元素：");
        list.display();
        Scanner scanner = new Scanner(System.in);
        System.out.println("删除：");
        int position = scanner.nextInt();
        System.out.println("删除值为" + position + "的结点");
        list.DeteleNode(position);
        list.display();
//      list.DeleteNode(,4);
//      list.display();
    }


}