数据结构-单链表

1.数组和链表的比较

     数组作为数据存储结构有一定的缺陷,在无序数组中,搜索性能差,在有序数组中,插入效率又很低,而且这两种数组的删除效率都很低,并且数组在创建后,其大小是固定了,设置的过大会造成内存的浪费,过小又不能满足数据量的存储。

 如果要去掉C,那么就要把D以后的数据全部往前移动一位才可以

      数据结构一链 表。我们知道数组是一种通用的数据结构,能用来实现栈、队列等很多数据结构。而链表也是一种使用广泛的通用数据结构,它也可以用来作为实现栈、队列等数据结构的基础,基本上除非需要频繁的通过下标来随机访问各个数据,否则很多使用数组的地方都可以用链表来代替。

      但是需要说明的是,链表是不能解决数据存储的所有问题,它也有它的优点和缺点。

链表(Linked List)

      链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并 不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(地 址)。

      链表结构可以克服数组需要预先知道数据长度的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。同时查询起来也会变得较为困难。

      链表是一种数据结构,和数组同级。比如,Java 中我们使用的ArrayList,其实现原理是数组。而LinkedList的实现原理就是链表了。

如,我们要查询A节点,只能从头节点开始查询,从F->E->D->C->B->A

F是头节点;A是尾节点;中间的是中间节点;前面的节点成为前驱节点;后面的节点称为后继节点;

单向链表(Single-Linked List)

      单向链表是最简单、最基础的链表,它的一个结点(node)分两部分,第一部分存储结点的数据信息(data) ,第二部分存储指向下一结点的地址(next)信息。最后一个结点(链尾)指向一个空地址ntull)。单向链表一般只在链表表头(链头)结点的位置插入元素,这样每次新加入的元素都会在链头位置,而最先加入的元素会在链尾位置。删除操作时,如果在链头位置删除,只需要把头结点指向其下一个结点即可;如果是在中间位置删除,只需要将其前一个结点指向其下一个节点就可以了。

2.java代码是实现链表的插入,遍历,查询,删除(删除头节点和指定内容的节点),判空等方法

package com.cym.datastructure.linked_list;

/**
 * 单向链表
 */
public class SingleLinkedList {
    //定义头节点
    private Node headNode;
    //定义链表的长度;
    private int size;

    /**
     * 定义内部类实现链表的节点元素
     */
    private class Node {
        //节点存放的数据
        Object data;
        //节点指向下一个节点(存放下一个节点的地址)
        Node next;

        //构造函数,创建节点的时候同时把数据存在节点中
        public Node(Object data) {
            this.data = data;
        }
    }

    /**
     * @param object 添加的元素
     */
    public void addNode(Object object) {
        Node newNode = new Node(object);
        //判断该节点是否是头节点
        if (isEmpty()) {
            //把新加入的元素节点作为头节点
            headNode = newNode;
        } else {
            //如果链表中已经存在了节点,就把新加入的节点指向原有的的头节点(就是把头节点的地址存在新加入节点的newNode.next中)
            newNode.next = headNode;
            //新加入的节点就作为该链表的新的头节点(因为链表的加入是从头节点开始插入的)
            headNode = newNode;
        }
        //链表的长度增加
        size++;
    }

    /**
     * 判断链表是否为null
     *
     */
    public boolean isEmpty() {
        return (size == 0);
    }

    /**
     * 遍历该链表
     */
    public void traverseSingleLinkedLists() {
        if (!isEmpty()) {
            //让节点指向头节点开始遍历
            Node node = headNode;
            //如果链表中只有一个节点则直接输出该节点的内容
            if (size == 1) {
                System.out.println("[" + node.data + "]");
                return;
            }
            //定义一个表示链表大小的临时变量
            int tempSize = size;
            //如果size>1的就开始遍历该链表
            while (tempSize > 0) {
                //判断该节点是否是头节点
                if (node.equals(headNode)) {
                    System.out.print("[" + node.data + "-->");
                } else if (node.next == null) {//判断是否是尾节点
                    System.out.print(node.data + "]");
                } else {//中间节点
                    System.out.print(node.data + "-->");
                }
                //指向下一个节点
                node = node.next;
                tempSize--;
            }
        } else { //如果size==0表示该链表中没有节点
            System.out.println("[]");
        }
    }

    /**
     * 删除头节点
     * @return 返回删除头节点的内容
     */
    public Object popHeadNode(){
        if (isEmpty()){
            return null;
        }else {//链表不为空的时候
            //获得头节点存放的数据
            Object obj = headNode.data;
            //使头节点的下一个节点成为头节点()
           headNode = headNode.next;
            size--;
            return obj;
        }
    }

    /**
     * 查询指定的内容
     * @param object 待查询的内容
     * @return
     */
    public Object findNode(Object object){
        //判断链表是不为null
        if (!isEmpty()){
            //指定当前节点为头节点
            Node currentNode = headNode;
            //定义链表的临时大小变量
            int tempSize = size;
            while (tempSize >0){
                //判断查询的值是否和当前节点的值一样
                if (object.equals(currentNode.data)){
                    //返回当前节点的地址的码
                    return currentNode;
                }
                //当前节点指向下一个节点
                currentNode = currentNode.next;
                tempSize--;
            }
        }
        return null;
    }


    public boolean deleteNodeByDate(Object obj) {
        if (isEmpty()){return false;}
        //定义当前节点为头节点
        Node currentNode = headNode;
        //定义前驱结点为头节点
        Node precursorNode = headNode;
        //判断要删除的值是否和当前节点的存放的值一样,如果不同则继续循环下去
        while (obj != currentNode.data){
            //当节点是尾节点的时候返回false
            if (currentNode.next == null){
                return false;
            }else {
                //让前驱结点等于当前节点
                precursorNode = currentNode;
                //当前节点指向下一个节点
                currentNode = currentNode.next;
            }
        }
        //判断,如果删除的节点是头节点的时候
        if (currentNode == headNode){
            //让头节点指向当前节点(头节点)的下一个节点
            headNode = currentNode.next;
            //链表大小减1
            size--;
        }else {//当删除的节点不是头节点而是中间节点的时候
            /*
             *   让前驱节点的下一个节点指向当前节点的下一个节点  如 a-->b-->c-->d 删除的时候b节点
             *   前驱节点b和当前节点是c,然后b的下一个节点原来是c的但被删除了,所以指向当前节点c的下一个节点d
             */
            precursorNode.next = currentNode.next;
            size--;
        }
        return true;
    }

    public static void main(String[] args) {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addNode("A");
        singleLinkedList.addNode("B");
        singleLinkedList.addNode("C");
        singleLinkedList.addNode("D");
//        singleLinkedList.traverseSingleLinkedLists();
//        System.out.println(singleLinkedList.popHeadNode());
//        singleLinkedList.traverseSingleLinkedLists();
//        System.out.println(singleLinkedList.findNode("A"));
        System.out.println(singleLinkedList.deleteNodeByDate("B"));
        singleLinkedList.traverseSingleLinkedLists();
    }
}

输出:

true
[D-->C-->A]

 

 

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
下面是使用C语言实现的链表原地逆转的代码: ```c #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; }; void reverseList(struct Node** head) { struct Node* prev = NULL; struct Node* current = *head; struct Node* next = NULL; while (current != NULL) { next = current->next; current->next = prev; prev = current; current = next; } *head = prev; } void printList(struct Node* head) { while (head != NULL) { printf("%d ", head->data); head = head->next; } printf("\n"); } void push(struct Node** headRef, int newData) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = newData; newNode->next = *headRef; *headRef = newNode; } int main() { struct Node* head = NULL; push(&head, 3); push(&head, 2); push(&head, 1); printf("Original list: "); printList(head); reverseList(&head); printf("Reversed list: "); printList(head); return 0; } ``` 在上述代码中,我们首先定义了一个 `Node` 结构体来表示链表中的每个节点,包括节点的值和指向下一个节点的指针。然后我们定义了 `reverseList` 函数来实现原地逆转链表的功能。该函数接受一个指向指针的指针 `head`,这是因为我们需要通过指针来修改链表的头节点,所以我们传递指向指针的指针。在函数内部,我们使用三个指针 `prev`、`current` 和 `next` 来依次遍历链表,并将每个节点的指针指向前一个节点,从而实现原地逆转链表的目的。 最后,我们定义了一个 `push` 函数来添加新节点到链表的头部,并定义了 `printList` 函数来打印链表中所有节点的值。在 `main` 函数中,我们创建了一个包含三个节点的链表,并调用 `reverseList` 函数来原地逆转该链表,最后打印出原始和逆转后的链表

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值