不带头结点的非循环单链表

最新推荐文章于 2022-10-17 16:52:47 发布
最新推荐文章于 2022-10-17 16:52:47 发布
阅读量172 收藏 1
点赞数
分类专栏： 算法和数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41552331/article/details/102887576
版权

目录

链表结构

在这里插入图片描述

操作

头插

在这里插入图片描述

尾插

在这里插入图片描述

任意位置插入

在这里插入图片描述

删除一个节点

在这里插入图片描述

删除所有值为key的节点

在这里插入图片描述

反转链表

在这里插入图片描述

/**
 * @author :Administrator.
 * @date :2019/11/2 0002
 * @time:17:17
 */
/*
以节点为单位存储，不支持随机访问
所有：1.任意位置插入删除时间复杂度为O(1) 2.没有增容问题，插入一个开辟一个空间。
不带头结点的非循环单链表
 */
class ListNode {//节点类
    public int val;
    public ListNode next;

    public ListNode(int val) {
        this.next=null;
        this.val=val;

    }
}
class SignalList {//单链表类
    public ListNode head;

    public SignalList() {
        this.head = null;
    }

    /*
    头插法
     */
    public void addFirst(int val) {
        ListNode node = new ListNode(val);
        //判断头节点是否为空，也就head==null;
        if (this.head == null) {
            this.head = node;
        } else {
            node.next = this.head;
            this.head = node;
        }
    }

    /*
    尾插法
     */
    public void addLast(int val) {
        ListNode node = new ListNode(val);
        ListNode cur = this.head;
        if (this.head == null) {
            this.head = node;
        } else {
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }

    /*
    求链表的长度
     */
    public int getLength() {
        ListNode cur = this.head;
        int count = 0;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

    /*
    任意位置插入,第一个数据节点为0号下标
     */
    先要找到index-1的位置
    private ListNode searchIndex(int index) {
        ListNode pre = this.head;
        int count = 0;
        while (count < index - 1) {
            count++;
            pre = pre.next;
        }
        return pre;
    }

    public boolean addIndex(int index, int val) {
        ListNode cur = this.head;
        //先要找到index-1的位置
        //判断index是否合法index<0||index>getLength()
        if (index < 0 || index > getLength()) {
            System.out.println("index不合法");
            return false;
        }
        //如果index=0;头插法
        if (index == 0) {
            addFirst(val);
            return true;
        } else {
            ListNode pre = searchIndex(index);
            ListNode node = new ListNode(val);
            node.next = pre.next;
            pre.next = node;
        }
        return true;
    }

    /*
    查找是否包含关键字key是否在单链表当中
     */
    public boolean contains(int val) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.val == val) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    /*
    删除第一次出现关键字为key的节点    
     */
    private ListNode searchprev(int val) {
        ListNode prev = this.head;
        while (prev != null) {
            if (prev.next.val == val) {
                return prev;
            }
            prev = prev.next;
        }
        return null;//没找到返回空
    }

    public void remove(int val) {
        //判断单链表是否为空
        if (this.head == null) {
            System.out.println("单链表为空");
            return;
        }//判断删除的是不是头节点
        if (this.head.val == val) {
            this.head = this.head.next;
        }
        //找到val的前驱
        ListNode prev = searchprev(val);
        ListNode del = prev.next;
        prev.next = del.next;
    }

    /*
    删除所有值为key的节点
     */
    public void removeAllKey(int val) {

        ListNode pre = this.head;
        ListNode cur = pre.next;

        while (cur != null) {
            if (pre.next.val == val) {
                pre.next = cur.next;
                cur = cur.next;
            } else {
                pre = pre.next;
                cur = cur.next;
            }
            //判断删除的是不是头节点
            if (this.head.val == val) {
                this.head = this.head.next;
            }
        }
    }

    /*
    打印链表
     */
    public void display() {
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    /*
    打印反转后的链表
     */
    public void display2(ListNode newHead) {
        ListNode cur = newHead;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    /*
    反转链表
     */
    public ListNode reverseList() {
        ListNode cur = this.head;
        ListNode newHead = null;
        ListNode pre = null;
        while (cur != null) {
            ListNode curNext = cur.next;
            if (curNext == null) {
                newHead = cur;
            }
            cur.next = pre;
            pre = cur;
            cur = curNext;
        }
        return newHead;
    }

    /*
    返回链表的中间结点
     */
    public ListNode middleNode() {
        ListNode fast = this.head;
        ListNode slow = this.head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

    /*
     输入一个链表，输出该链表中倒数第k个结点。
     */
    public ListNode findKthToTail(int k) {
        //定义快慢引用，先让fast走k-1步，然后让它俩一起走，直到fast.next==null时，slow就是倒数第K个节点
        ListNode fast = this.head;
        ListNode slow = this.head;

        //先判断K是否合法
        if (k <= 0) {
            System.out.println("k不合法");
            return null;
        }
        while (k - 1 > 0) {
            if (fast.next != null) {
                fast = fast.next;
                k--;
            } else {
                return null;
            }
        }
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }

    /*
    将两个有序链表合并为一个新的有序链表并返回
     */
    public ListNode mergeTwoLists(ListNode headA, ListNode headB) {
        //定义一个虚拟节点
        ListNode node = new ListNode(-1);
        ListNode temp = node;
        while (headA != null && headB != null) {
            if (headA.val < headB.val) {
                temp.next = headA;
                headA = headA.next;
                temp = temp.next;
            } else {
                temp.next = headB;
                headB = headB.next;
                temp = temp.next;
            }
        }
            if (headB != null) {
                temp.next = headB;
            }
            if (headA != null) {
                temp.next = headA;
            }
        return node.next;
    }
    /*
    以给定值x为基准将链表分割成两部分
     */
    public ListNode partition(int x) {
       ListNode cur=this.head;
       ListNode beforeStart=null;
       ListNode beforeEnd=null;
       ListNode afterStart=null;
       ListNode afterEnd=null;
       while(cur!=null) {
           if(cur.val<x) {
               //判断是不是第一次插入
               if(beforeStart==null) {
                   beforeStart=cur;
                   beforeEnd=beforeStart;
               }else {
                   beforeEnd.next=cur;
                   beforeEnd=beforeEnd.next;
               }
           }else {
               //判断是不是第一次插入
               if (afterStart == null) {
                   afterStart = cur;
                   afterEnd = afterStart;
               } else {
                   afterEnd.next = cur;
                   afterEnd = afterEnd.next;
               }
           }
           cur=cur.next;
       }
       if(beforeStart==null) {
           return afterStart;
       }
       beforeEnd.next=afterStart;
       if(afterStart!=null) {
           afterEnd.next = null;
       }
       return beforeStart;
    }
    /*
    删除该链表中重复的结点
     */
    public ListNode deleteDuplication() {
        ListNode cur=this.head;
        //定义一个虚拟节点
        ListNode node=new ListNode(-1);
        ListNode temp=node;
        while(cur!=null) {
            if(cur.next!=null&&cur.val==cur.next.val) {
                while(cur.next!=null&&cur.val==cur.next.val) {
                    cur=cur.next;
                }
                cur=cur.next;
            }
            else{
                temp.next=cur;
                cur=cur.next;
                temp=temp.next;
            }
        }
        temp.next=null;
        return node.next;

    }
    /*
    判断回文
     */
    public boolean chkPalindrome() {
        ListNode fast = this.head;
        ListNode slow = this.head;

        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        //反转
        ListNode p = slow.next;
        while (p != null) {
            ListNode pNext = p.next;
            //反转
            p.next = slow;

            slow = p;
            p = pNext;
        }
        //slow往前    head 往后  .data不一样 返回false
        //直到相遇
        while (slow != head) {
            if (slow.val != head.val) {
                return false;
            }
            if (slow == head.next) {
                return true;
            }
            slow = slow.next;
            head = head.next;
        }
        return true;
    }
    /*
    找到两个单链表相交的起始节点
     */
    public static ListNode  getIntersectionNode(ListNode headA,ListNode headB){
        if (headA == null||headB==null) {

            return null;
        }
        ListNode pL=headA;
        ListNode pS=headB;
        int lenA=0;
        //两个链表的长度
        int lenB=0;
        ListNode cur1=headA;
        //定义一个临时变量代替head,防止它求长度时跑到链表尾部
        ListNode cur2=headB;
        while(cur1!=null) {
            lenA++;
            cur1=cur1.next;
        }
        while(cur2!=null) {
            lenB++;
            cur2=cur2.next;
        }
        int len=lenA-lenB;
        if(len<0){
            pL=headB;
            pS=headA;
            len=lenB-lenA;
        }
        while(len>0) {
            pL= pL.next;
            len--;

        }
        while(pL!=pS&&pL!=null) {
            pL= pL.next;
            pS=pS.next;
        }
        if(pL==pS&&pS!=null) {
            return  pL;
        }
        return null;

    }
    /*
    判断一个链表是否有环
     */
    public boolean hasCycle() {
        if (head == null || head.next == null) {
        	return false;
    	}
	    ListNode slow = head;
	    ListNode fast = head.next;
	    while (slow != fast) {
	        if (fast == null || fast.next == null) {
	            return false;
	        }
	        slow = slow.next;
	        fast = fast.next.next;
	    }
	    return true;

    }
    /*
    返回链表开始入环的第一个节点
     */
    public ListNode detectCycle() {
        ListNode fast=this.head;
        ListNode slow=this.head;
        while(true) {
            if(fast==null||fast.next==null) {
                return null;
            }
            fast=fast.next.next;
            slow=slow.next;
            if(fast==slow) {
                break;
            }
        }
        fast=head;
        while(fast!=slow) {
            fast=fast.next;
            slow=slow.next;
        }
        return  fast;

}
public class Test {
    public  static void main(String[] args) {
        SignalList list1=new SignalList();
        SignalList list=new SignalList();
        list1.addLast(421);
        list1.addLast(305);
        list1.addLast(13);
        list1.addLast(425);
        list1.addLast(222);
        list1.addLast(609);
        list1.addLast(100);
        list1.addLast(131);
        list1.addLast(579);
        list1.addLast(579);
        list1.addLast(131);
        list1.addLast(100);
        list1.addLast(609);
        list1.addLast(222);
        list1.addLast(425);
        list1.addLast(13);
        list1.addLast(305);
        list1.addLast(421);




        list1.display();
        System.out.println(list1.chkPalindrome());

//        list.addFirst(2);
//        list.addFirst(4);
//        list.addFirst(35);
//        list.addFirst(21);
//        list.display();



//         ListNode head=list1.reverseList();
//         list1.display2(head);
//        ListNode cur=list1.middleNode();
//        ListNode r=list1.findKthToTail(1);
//        System.out.println(r.val);
//
//        System.out.println(cur.val);
//        list1.removeAllKey(2);
//        list1.display();
//
//        list1.display();

//        System.out.println(list1.addIndex(2,3));
//        list1.display();
//        System.out.println(list1.contains(1));
//        list1.remove(1);
//        list1.display();
//        //System.out.println(list1.getLength());
//        list.addLast(1);
//        list.addLast(1);
//        list.display();
    }
}
猫不爱学习
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---不带头结点的单项非循环链表
weixin_43219708的博客
03-03 315
如果对元素进行大量的任意位置添加或删除，在顺序表里就要移动很多的元素，（底层空间是连续的）效率很低，所以可以利用链表这个结构 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的链接次序实现的 找到第一个节点，就可以通过链式结构找到下一个节点 链表： 1.单链表（从前往后）、双链表（） 2.带头（把第一个节点保存起来、不带头（） 3.循环、非循环 ...
不带表头结点的非循环单向链表
FunkyFrog821951259的博客
11-06 427
#include #include struct node { int num; struct node *next; }; typedef struct node Node; typedef struct node * Link; void create_link(Link *head) { *head = NULL; } void insert_node_head(Link *h
不带头结点的单链表简单实现
nb_zsy的博客
09-23 171
/*不带头结点的单链表实现*/ #include <stdio.h> #include <stdlib.h> typedef struct ElemType { int id; char name[10]; }ElemType; typedef struct Node { ElemType data; struct Node* next; }ListNode,*LinkList; /*初始化该链表*/ int InitList(LinkList* L) { if (L
不带头非循环单链表的实现
qq_43508801的博客
05-14 283
1. 什么是链表 用一组地址任意的存储单元存放线性表中的数据元素，即逻辑上连续，物理上不一定连续。 在顺序表的链式存储结构中，每个存储的节点不仅包含数据元素本身(称之为数据域)，而且还包括此节点的后继节点的地址信息(称之为指针域)。一般地，每个节点可以有一个或多个这样的指针域，如果某个节点中的某个指针域不再需要指向任何节点，则它的值为null。 2. 什么是单链表 在每个节点中除了包含数据域 (d...
数据结构-基本算法-不带头结点的循环链表
05-21
数据结构-基本算法-不带头结点的循环链表(学生时代源码，调试可运行)
不带头结点的循环单链表表示队列.c
04-16
利用 KMP 算法求子串在主串中出现的次数.c
小白算法积累——单链表15#2个带头结点单链表+提取公共元素+二表合一
01-20
在解决问题的过程中，我们需要初始化这三个指针，`pa` 指向A链表的第二个节点（因为题目要求带头结点），`pb` 指向B链表的第二个节点，而`pc` 初始指向链表A的头结点。 接下来，我们使用一个`while`循环来遍历两个...
Java实现带头结点的单链表
08-25
Java实现带头结点的单链表 Java实现带头结点的单链表是一种链式数据结构，链表的特点是以节点方式存储，是链式结构。每个节点包含data域，next域：指向下一个节点。链表的各个节点不一定是连续存储。链表分为带头...
c代码-单链表创建——不带头结点
07-14
"不带头结点"的单链表指的是链表的第一个节点没有一个特殊的头节点来标识链表的起始位置，而是直接由数据节点开始。这种方式在某些特定情况下可能会简化代码，但也可能导致一些额外的处理。 单链表的基本操作包括...
尾插法建立不带头结点的单链表(C语言).zip
最新发布
04-17
本资源"尾插法建立不带头结点的单链表(C语言)"就是一个关于如何在C语言中创建这种链表的示例。 在C语言中，单链表的节点通常定义为一个结构体，包含两个部分：一个是存储数据的域，另一个是存储指向下一个节点的...
实参形参与指针5——无头结点循环链表与带头结点循环链表
weixin_42224065的博客
10-17 1776
虽然C语言的指针偏向底层，不利于上手和大型项目开发（某些），但是用C去实现链表基本操作是有利于我们的代码功底的。而且在实现的过程中，实现远比理解要复杂困难的多，尤其是循环链表，当你实现过就会发现，为啥你的大学老师总是劝你要带头结点了。
【数据结构】不带头结点非循环的单链表
Suk_god的博客
11-25 1001
文章目录走进链表概念&结构特点链表的分类不带头结点、非循环的单链表结构增删查改打印等基础操作申请结点头插&尾插头删&尾删查找打印输出任意位置插入任意位置删除最重要的一项操作优缺点源码分享 走进链表 概念&结构 链表是一种物理存储结构上非连续，非顺序的存储结构。数据元素的逻辑顺序是通过链表中的指针指向来实现的。 特点 1.物理存储单元不连续 2.依靠指针强前后元素关联起来 3.随用随开辟 链表的分类 1.单向、双向链表 2.带头或者不带头 3.循环或者非循环
不带头结点的单循环链表
weixin_43854256的博客
05-19 2288
创建头文件nlist.h #pragma once //不带头节点的链表,主要应用在循环链表中,其缺点,操作复杂(会出现二级指针), //优点:灵活(头指针指向哪个节点哪个节点就是第一个节点) //不带头节点的单链循环链表,尾节点的next指向第一个节点 typedef struct NNode { int data;//数据 struct NNode *next;//下一个节点的地址 }NNode,*PNList; //初始化函数,将头指针置NULL,会出现二级指针 void InitList(P
数据结构之不带头结点的单链表
热门推荐
qq_43411563的博客
04-20 1万+
我们都知道不管是单链表、双向链表还是循环链表，都带有头结点，这个头结点相当于一个起始的位置。我们在设计带头结点的单链表的时候，我们会在主函数中设计一个头结点，并把它的指针域置为空，这样我们就可以进行增删查改这些操作了。那我们今天这篇博客就来说一下不带头结点的单链表。 一、不带头结点的单链表的定义 我们先来回忆一下带头结点的单链表是什么样子。如下图所示：红色的区域就是头结点，它有一个头指针指向它。 ...
不带头结点的单链表操作
qq_40819191的博客
06-22 1556
不带头结点的单链表操作，包括插入、遍历、统计结点数等，要求写出数据结构算法思想及C语言实现函数 本文为博主原创文章，未经博主允许不得转载。 版权为陈博超所有，第一次于2021年06月22日发表于BLOG上 本BLOG上原创文章未经本人许可，不得用于商业用途。转载请经允许后注明出处，否则保留追究法律责任的权利。 * 算法如下： //不带头结点的单链表操作 #include<stdio.h> #include<malloc.h> typedef int DataType; ty
不带头结点的单链表
m0_63852285的博客
11-18 3680
建立结构体 和带头结点但单链表一样，按需建立即可。我以建立一个储存学生信息的链表举例。 typedef struct node { char name[20]; int number; struct node *next; }Node,*LinkList; 单链表的建立 因为不带头结点，无需初始化，最后返回head 尾插法 如果是第一个结点，则需让head指向这个结点，再利用另一指针r保存head，并用r进行之后的节点插入。除第一个结点外其他结点的插入与带头结点的单链表一致。 Li
线性表学习归纳总结五：不带头结点的循环链表
蜗牛漫步。。。我要一步一步往上爬。。。
06-10 2132
循环链表与单链表的区别在于，最后一个结点的指针域。 不带头结点循环链表最后一个结点的指针域指向链表的第一个结点，带头结点的话，最后一个结点的指针域指向头结点。 而单链表中，最后一个结点的指针域为null。 基本运算中的区别在于：链表扫描时候的终点条件；以及在插入和删除操作时候， 需要注意是否需要修改最后一个结点的指针域。 获得循环链表的最后一个结点的存储地址 n
Java实现不带头结点的单向循环链表（解决约瑟夫环问题）
360°顺滑
10-18 2037
文章目录一、什么是单向循环链表？二、约瑟夫环问题三、约瑟夫环问题的解决 一、什么是单向循环链表？ 如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。 二、约瑟夫环问题 设有n个人围坐在一张圆桌周围，先从某个人开始从1报数，数到m的人出列（即离开座位，不参与以后的报数），然后从出列的下一个人开始重新从1报数，...
写一个带头结点的循环单链表
02-12
带头结点的循环单链表是指在循环单链表的开头添加了一个虚拟的头结点，头结点不存储任何数据，只是为了方便链表的操作。 下面是带头结点的循环单链表的实现代码： ``` class Node: def __init__(self, data): ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值