单链表实现

package com.wyl.linklist;

public class MyLinkList {

    private Node head;  //链表的起始节点
    private int size = 0; //记录链表的长度
    /**
     * 定义内部节点类
     * @author wyl
     *
     */
    class Node {

        private String name;  //节点的内容
        private Node next; //指向节点的直接后继

        public Node(){

        }
        public Node(String name){
            this(name, null);
        }

        public Node(String name, Node next) {
            this.name = name;
            this.next = next;
        }
    }

    /**
     * 初始化链表,创建头结点
     */
    public MyLinkList(){
        head = new Node();  //头结点为空节点
        head.next = null;
    }
    /**
     * 给链表中增加节点
     * @param data
     */
    public void addNode(String data){
        /* 1、获取表头
         * 2、通过表头找到最后一个元素
         * 3、将新增的节点放到最后一个节点的后面
         * */
        Node p = head;
        while(p.next != null){
            p = p.next; //移动指针,永远指向链表尾部
        }
        p.next = new Node(data);
        size++ ;
    }
    /*删除节点*/
    public void delNode(String data){
        /* 1、获取表头
         * 2、通过表头找到最后一个元素
         * 3、将新增的节点放到最后一个节点的后面
         * */
        if(head.next == null){
            return;
        }
        Node p = head;
        while(p.next != null){
            if(p.next.name.equals(data)){
                p.next = p.next.next;
                size--;
                break;
            }else{
                p = p.next;
            }
        }
    }

    /*查找数据是否在链表中*/
    public boolean contains(String data){
        Node p = head;
        while(p.next != null){
            if(p.next.name.equals(data)){
                return true;
            }else{
                p = p.next;
            }
        }
        return false;
    }

    /*在指值的后面插入值*/
    public void insertNode(String param, String data){
        Node p = head;
        while(p.next != null){
            if(p.next.name.equals(param)){
                Node temp = p.next.next;
                Node newNode = new Node(data, temp);
                p.next.next = newNode;
                return;
            }else{
                p = p.next;
            }
        }
    }

    /*链表遍历*/
    public void iterator(){
        Node p = head;
        if(p.next == null){
            System.out.println("空链表");
        }
        p = p.next;
        while(p.next != null){
            System.out.print(p.name + "==>>");
            p = p.next;
        }
        System.out.print(p.name);
    }

    /*链表长度*/
    public int size(){
        return size;
    }

    public static void main(String[] args) {
        MyLinkList myLinkList = new MyLinkList();
        myLinkList.addNode("组长");
        myLinkList.addNode("部门经理");
        myLinkList.addNode("主管副总");
        myLinkList.addNode("总经理");
        myLinkList.iterator();
        System.out.println();

        myLinkList.delNode("部门经理");
        myLinkList.iterator();
        System.out.println();
        myLinkList.insertNode("主管副总", "经理");
        myLinkList.iterator();
    }
}
时间: 2024-10-20 15:15:24

单链表实现的相关文章

单链表逆置

重写单链表逆置,熟能生巧- #include <iostream> #include <cstdlib> using namespace std; typedef struct List{ int num; struct List *next; }ListNode,*pListNode; void display(ListNode *pHead) { while(pHead) { cout<<pHead->num<<"--"; pH

02 单链表

线性表之链式存储---单链表 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 // 数据结构 6 typedef struct node 7 { 8 int data; 9 struct node *next; 10 }linkList; 11 12 // 创建单链表,并初始化 13 linkList *linkList_init(void) 14 { 15 linkList *l

(单链表)单链表的整体逆序和局部逆序

题目一:将单链表翻转. 思路:有三种方式. 一:用数组存储单链表的值,然后重新逆序赋值,效率较低. 二:利用三个指针,在原来的基础上进行逆序.这种方法比较实用,效率也高. 三:从第2个节点到第N个节点,依次逐节点插入到第1个节点(head节点)之后,最后将第一个节点挪到新表的表尾.需要新建一个链表,这种方法和第二种差不多. 这里我就写出第二种方法,比较实用. 代码(方法二): struct ListNode { int val; ListNode *next; ListNode(int x) :

[c语言]单链表的实现

一.基础知识:链表(线性表的链式存储结构) (1)特点:逻辑关系相邻,物理位置不一定相邻. (2)分类: a.不带头节点 b.带头节点 (3)单链表的存储结构: typedef struct SListNode {  DataType data;  struct SListNode* next; }SListNode; 二.代码实现(因避开使用二级指针,所以代码中使用了c++中的引用):此处构造的为不带头节点的链表 (1)sList.h   #pragma once typedef int Da

单链表基本操作

//头文件 #pragma once #include <stdio.h> #include <assert.h> #include <malloc.h> #include <stdlib.h> typedef int DateType; typedef struct LinkNode {  DateType _data;  struct  LinkNode* _next; } LinkNode; void PrintList(LinkNode* pHead

C++单链表的创建与操作

链表是一种动态数据结构,他的特点是用一组任意的存储单元(可以是连续的,也可以是不连续的)存放数据元素.链表中每一个元素成为“结点”,每一个结点都是由数据域和指针域组成的,每个结点中的指针域指向下一个结点.Head是“头指针”,表示链表的开始,用来指向第一个结点,而最后一个指针的指针域为NULL(空地址),表示链表的结束.可以看出链表结构必须利用指针才能实现,即一个结点中必须包含一个指针变量,用来存放下一个结点的地址.结点中只有一个next指针的链表称为单链表,这是最简单的链表结构. 首先定义一个

每日一题3:判断单链表是否相交

由于单链表的特殊性,如果某一链表与另一链表相交,那么从相交的节点开始,以后两个链表的每个节点都相同,因此判断两个链表是否相交,只需判断每条链表的最后一个节点是否相同即可! #include "stdafx.h" #include <iostream> using namespace std; struct list_node { int data; list_node* next; }; list_node* CreateList(int datas[],int n) {

数据结构上机测试2-1:单链表操作A (顺序建表+关键字删除)

数据结构上机测试2-1:单链表操作A Time Limit: 1000MS Memory limit: 4096K 题目描述 输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,将单链表中的值为m的结点全部删除.分别输出建立的初始单链表和完成删除后的单链表. 输入 第一行输入数据个数n: 第二行依次输入n个整数: 第三行输入欲删除数据m. 输出 第一行输出原始单链表的长度: 第二行依次输出原始单链表的数据: 第三行输出完成删除后的单链表长度: 第四行依次输出完成删除后的

大话数据结构---单链表

单链表在存储结构上与顺序存储的区别:不用开辟连续的存储空间,存储位置任意,只需要让数据的前驱知道它的位置就可以,而使用单链表示只需要知道单链表的第一个元素就能找到其他所有的元素,为了方便 一般会设置一个头指针指向第一个元素. 单链表的数据读取:通过头指针一个一个往后遍历 单链表的插入: 删除: 自定义单链表的简单实现: package com.neuedu.entity; /* * 项目名称:JavaSqList * @author:wzc * @date 创建时间:2017年9月2日 上午9:

数据结构(三)之单链表反向查找

一.反向查找单链表 1.简单查找 先遍历获取单链表单长度n,然后通过计算得到倒数第k个元素的下标为n-k,然后查找下标为n-k的元素. 2.优化查找 先找到下标为k的元素为记录点p1,然后设置新的记录点p2的下标从0开始,同时遍历两个记录点,直到p1的值为null,p2是倒数第k个元素. 单链表结点: package cn.edu.scau.mk; /** * * @author MK * @param <T> */ public class Node<T> { private T