搞懂数据结构-链表（更新版）

最新推荐文章于 2020-11-17 19:01:07 发布
最新推荐文章于 2020-11-17 19:01:07 发布
阅读量149 收藏
点赞数
分类专栏： # 数据结构 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47902348/article/details/106738135
版权

搞懂数据结构-链表

1.背景

动态数组的申请数组大小有个明显的缺点，可能会造成内存空间的大量浪费。那能不能需要用多少就申请多少内存大小呢？链表可以做到这一点。

2.单向链表

2.1单向链表的设计

在这里插入图片描述
代码：

public class LinkedList<E> {
    //存储元素的大小
    private int size;
    //指向第一个元素的节点
    private Node<E> first;

    //因为节点类只在本类中使用，所以定义为内部类
    private static class Node<E>{
        E element;
        Node<E> next;
        //构造方法
        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }
}
2.1.1设计思路

在这里插入图片描述

链表的接口设计和动态数组大同小异，所以在这里抽取一个公共接口出来。如果不写接口，而是写父类，让继承的话，就会存在方法的差异。所以更好的方法是，定义一个接口，然后再定义个抽象类，抽象类中放公共方法，而子类中不同的方法重写接口中的就行。没有必要在父类中写不是公共方法的代码。

抽象类存在的好处，如果子类直接去实现接口，那么接口里面的方法全部都得实现，而抽象类不需要

理解：

  • 先抽象出一个抽象类，里面存放公共方法，然后再向上再抽象出一个接口，存放所有方法，包括不公共的方法
  • 或者先抽象出接口，然后子类都去实现接口，发现子类有公共代码，将公共代码抽取出来成抽象成一个类B。让这个类B去实现接口，而子类去实现这个类B。但是只要是实现了接口就必须重写接口中所有方法，而类B的功能只是存放公共方法，所有这时候将类B变成抽象类就可以解决这个问题

抽象类不对外公开，只提供公共代码的作用。所有在使用过程中一般

List<Integer> list = new LinkedList<>();
2.1.2接口设计
public interface List<E> {

    public static final  int ELEMENT_NOT_FIND = -1;
    //元素大小
    int size();
    //判断是否为空
    boolean isEmpty();
    //添加元素到指定位置
    void add(int index,E element);
    //添加元素的末尾
    void add(E element);
    //删除指定元素
    E remove(int index);
    //清空元素
    void clear();
    //修改元素
    E set(int index, E element);
    //判断是否含有
    boolean contain(E element);
    //查找元素
    E get(int index);

}
2.1.3抽象类

类似于动态数组设计中一样，我们将一些通用的方法写在一个抽象类中，那么新类继承抽象类就可以直接使用了，并且让抽象类实现接口，并实现一些通用方法

public abstract class AbstractList<E> implements List<E> {
    protected int size;
    // 下标越界抛出的异常
    protected void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
    }
    // 检查下标越界(不可访问或删除size位置)
    protected void rangeCheck(int index){
        if(index < 0 || index >= size){
            outOfBounds(index);
        }
    }
    // 检查add()的下标越界(可以在size位置添加元素)
    protected void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }

    @Override
    public boolean contain(E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void add(E element) {
        add(size,element);
    }
}

2.2单向链表的增删改查

public class SingledList<E> extends AbstractList<E> {
    
    private Node<E> first;
    
    private static class Node<E>{
        E element;
        Node<E> next;
        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }
}
查
//找到索引对应的值
@Override
public E get(int index) {
    return node(index).element;
}

//找到索引对应的node
public Node<E> node(int index){
    rangeCheck(index);
    Node node = first;
    for (int i = 0; i < index; i++){
        node = node.next;
    }
    return node;
}

@Override
public int indexOf(E element) {
    if (element == null){
        Node<E> node = first;
        for (int i = 0; i < size; i++){
            if (node.element == null) return i;
            node = node.next;
        }
    }else {
        Node<E> node = first;
        for (int i = 0; i < size; i++){
            if (node.element.equals(element)) return i;
            node = node.next;
        }
    }
    return ELEMENT_NOT_FOUND;
}
改
//修改
@Override
public E set(int index, E element) {
    //查找节点,node做了索引边界检测，所以这里不需要再做
    Node<E> node = node(index);
    E old = node.element;
    //修改element
    node.element = element;
    return old;
}
增
//添加元素
@Override
public void add(int index, E element) {
    rangeCheckForAdd(index);
    if (index == 0){
        //first指向新Node,新Node原来的first指向的node,也就是first
        first = new Node<>(element,first);
    }else {
        //需要找到前面的元素
        Node<E> pre = node(index - 1);
        //pre指向新Node,新Node指向pre.next
        pre.next = new Node<>(element,pre.next);
    }
    size++;
}
删
//删除
@Override
public E remove(int index) {
    rangeCheck(index);
    Node<E> node = first;
    if (index == 0){
        first = first.next;
    }else {
        //要删除节点的前一个
        Node<E> pre = node(index - 1);
        //要删除的节点
        node = pre.next;
        //前一个节点指向要删除的后一个节点
        pre.next = node.next;

    }
    size--;
    //返回被删除节点的元素值
    return node.element;
}

清空元素

在这里插入图片描述

只需要将size设置为0，fisrt指向null，后面的 Node没有被指向，在 Java 中会自动被垃圾回收。

@Override
public void clear() {
    size = 0;
    first = null;
}
完整代码
public class SingledList<E> extends AbstractList<E> {

    private Node<E> first;

    private static class Node<E>{
        E element;
        Node<E> next;
        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }
    //添加元素
    @Override
    public void add(int index, E element) {
        if (index == 0){
            //first指向新Node,新Node原来的first指向的node,也就是first
            first = new Node<>(element,first);
        }else {
            //需要找到前面的元素
            Node<E> pre = node(index - 1);
            //pre指向新Node,新Node指向pre.next
            pre = new Node<>(element,pre.next);
        }
        size++;
    }

    //删除
    @Override
    public E remove(int index) {
        Node<E> node = first;
        if (index == 0){
            first = first.next;
        }else {
            //要删除节点的前一个
            Node<E> pre = node(index - 1);
            //要删除的节点
            node = pre.next;
            //前一个节点指向要删除的后一个节点
            pre.next = node.next;

        }
        size--;
        //返回被删除节点的元素值
        return node.element;
    }

    @Override
    public void clear() {
        size = 0;
        first = null;
    }

    //修改
    @Override
    public E set(int index, E element) {
        Node<E> node = node(index);
        E old = node.element;
        node.element = element;
        return old;
    }

    //找到索引对应的值
    @Override
    public E get(int index) {
        return node(index).element;
    }

    //找到索引对应的node
    public Node<E> node(int index){
        rangeCheck(index);
        Node node = first;
        for (int i = 0; i < index; i++){
            node = node.next;
        }
        return node;
    }
        @Override
    public int indexOf(E element) {
        if (element == null){
            Node<E> node = first;
            for (int i = 0; i < size; i++){
                if (node.element == null) return i;
                node = node.next;
            }
        }else {
            Node<E> node = first;
            for (int i = 0; i < size; i++){
                if (node.element.equals(element)) return i;
                node = node.next;
            }
        }
        return ELEMENT_NOT_FOUND;
    }
}
小结：

可以注意到，增和删在头节点这里的处理和其他位置的处理略有不同。因为头节点只是一个指针，并不是一个节点，没有next属性。

2.3 虚拟头节点

为了统一增和删的逻辑操作，增加一个虚拟头节点来实现。(解题的时候可以添加虚拟头节点这个来简化代码)

在这里插入图片描述

发生变化的地方

1.构造方法

//构造初始虚拟节点
public SingledList() {
    this.first = new Node<E>(null, null);
}

2.查找节点方法

//找到索引对应的node
public Node<E> node(int index){
    rangeCheck(index);
    //以前是first,现在是first.next
    //因为现在first是虚拟节点，里面有next属性
    Node node = first.next;
    for (int i = 0; i < index; i++){
        node = node.next;
    }
    return node;
}

3.增方法

//添加元素
@Override
public void add(int index, E element) {
    rangeCheckForAdd(index);
    //需要找到前面的元素,如果index为0，index-1会出现负数，所以需要判断
    Node<E> pre = index == 0 ? first:node(index - 1);
    //pre指向新Node,新Node指向pre.next
    pre = new Node<>(element,pre.next);
    size++;
}

4.删方法

//删除
@Override
public E remove(int index) {
    rangeCheck(index);
    //要删除节点的前一个
    Node<E> pre = index == 0 ? first:node(index - 1);
    //要删除的节点
    Node<E> node = pre.next;
    //前一个节点指向要删除的后一个节点
    pre.next = node.next;
    size--;
    //返回被删除节点的元素值
    return node.element;
}

3.双向链表

3.1双向链表的设计

在单向链表中，要访问尾节点，每次都要从头节点开始。为了提升性能，双向链表可以进行优化。

双向链表的接口和抽象都和单向链表一样，只是在增删改查中不一样。

在这里插入图片描述
代码

public class DoubleLinkedList<E> extends AbstractList<E> {
    //头尾节点
    private Node<E> first;
    private Node<E> last;

    private static class Node<E>{
        E element;
        Node<E> prev;
        Node<E> next;

        public Node(E element, Node<E> prev, Node<E> next) {
            this.element = element;
            this.prev = prev;
            this.next = next;
        }
    }

3.2双向链表的增删改查

查
//根据索引获取元素
@Override
public E get(int index) {
    return node(index).element;
}

//根据索引找到节点
public Node<E> node(int index){
    rangeCheck(index);
    if (index < (size >> 1)){
        Node<E> node = first;
        for (int i = 0; i < index ; i++){
            node = node.next;
        }
        return node;
    }else {
        Node<E> node = last;
        for (int i = size -1; i > index ; i++){
            node = node.next;
        }
        return node;
    }
}
改
//修改元素
@Override
public E set(int index, E element) {
    E old = node(index).element;
    node(index).element = element;
    return old;
}
增
/**
 * 添加元素：
 * 尾节点添加，特殊情况是添加第一个
 * 中间添加，特殊情况是头节点
 * @param index
 * @param element
 */
@Override
public void add(int index, E element) {
    rangeCheckForAdd(index);
    if (index == size){
        Node<E> oldLast = last;
        last = new Node<>(element,oldLast,null);
        if (oldLast == null){
            //第一个节点，头尾指针指向同一个
            first = last;
        }else {
            oldLast.next = last;
        }
    }else {
        Node<E> next = node(index);
        Node<E> prev = next.prev;
        Node<E> node = new Node<>(element,prev,next);
        next.prev = node;
        //index = 0,头节点添加不一样
        if (prev == null){
            first = node;
        }else {
            prev.next = node;
        }
    }
    size++;
}
删
//清空链表
@Override
public void clear() {
    size = 0;
    first = null;
    last = null;
}
//删除元素
@Override
public E remove(int index) {
    rangeCheck(index);
    Node<E> node = node(index);
    Node<E> prev = node.prev;
    Node<E> next = node.next;
    //头部
    if (prev == null){
        first = next;
    }else {
        prev.next = next;
    }
    //尾部
    if (next == null){
        last = prev;
    }else {
        next.prev = prev;
    }
    size--;
    return node.element;
}

4.单向环形链表

在这里插入图片描述

和单向链表对比，操作不同的地方在于增和删除的头部处理

增

//添加元素
@Override
public void add(int index, E element) {
    rangeCheckForAdd(index);
    if (index == 0){
        Node<E> newFirst = new Node<>(element, first);
        // 拿到最后一个节点, 上面先不要直接改first, 否则下面找节点会出现问题
        Node<E> last = (size == 0) ? newFirst : node(size - 1);
        last.next = newFirst;
        first = newFirst;
    }else {
        //需要找到前面的元素
        Node<E> pre = node(index - 1);
        //pre指向新Node,新Node指向pre.next
        pre.next = new Node<>(element,pre.next);
    }
    size++;
}

删

//删除
@Override
public E remove(int index) {
    rangeCheck(index);
    Node<E> node = first;
    if (index == 0){
    	if (size == 1){
            first = null;
    	}else{
    		Node<E> last = node(size - 1);
			first = first.next;
			last.next = first;
    	}
    }else {
        //要删除节点的前一个
        Node<E> pre = node(index - 1);
        //要删除的节点
        node = pre.next;
        //前一个节点指向要删除的后一个节点
        pre.next = node.next;
    }
    size--;
    //返回被删除节点的元素值
    return node.element;
}

5.双向循环链表

在这里插入图片描述
和双向向链表对比，操作不同的地方在于增和删除的头部操作

增

@Override
public void add(int index, E element) {
    rangeCheckForAdd(index);
    if (index == size){
        Node<E> oldLast = last;
        last = new Node<>(element,oldLast,first);
        if (oldLast == null){
            //第一个节点，头尾指针指向同一个
            first = last;
            first.next = first;
			first.prev = first;
        }else {
            oldLast.next = last;
            first.prev = last;
        }
    }else {
        Node<E> next = node(index);
        Node<E> prev = next.prev;
        Node<E> node = new Node<>(element,prev,next);
        next.prev = node;
        prev.next = node;
        //index = 0,头节点添加不一样
        if (next == first){
            first = node;
        }
    }
    size++;
}

删

//删除元素
@Override
public E remove(Node<E> node) {
    if (size == 1) {
        first = null;
        last = null;
    } else {
        Node<E> pre = node.pre;
        Node<E> next = node.next;
        pre.next = next;
        next.pre = pre;

        if (node == first) { // index == 0
            first = next;
        }

        if (node == last) { // index == size - 1
            last = pre;
        }
    }
    size--;
    return node.element;
}

6.静态链表

  • 可以通过数组来模拟链表，称为静态链表
  • 数组的每个元素存放 2 个数据：值、下个元素的索引
  • 数组 0 位置存放的是头结点信息

如果一个元素只能存放1个数据

  • 那就使用 2 个数组，1 个数组存放索引关系，1 个数组存放值

练习

1.删除链表中的节点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。

分析：我们之前的思路是找到要删除节点的前一个节点，但是太麻烦，可以采取用节点覆盖的方法

注意：这里没有尾节点，有尾节点这个方法就不能用了

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        //用被删除的节点的下一个节点进行覆盖
        node.val = node.next.val;
        node.node = node.next.next;
    }
}

2.删除链表中等于给定值 val 的所有节点。

分析：注意删除的头结点是不一样的。所以加了一个虚头节点

代码：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //新加一个虚头节点，让头节点和其他节点的操作统一起来
        ListNode header = new ListNode(-1);
        header.next = head;
        ListNode cur = header;
        while (cur.next != null){
            if (cur.next.val == val){
                cur.next = cur.next.next;
            }else{
                cur = cur.next;
            }
        }
        return header.next;
    }
}

3.删除排序链表中重复元素

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

分析：根据有序，相邻判断是否相等就行

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode header = new ListNode(10000);
        header.next = head;
        ListNode cur = header;
        while (cur.next != null){
            if (cur.val == cur.next.val){
                cur.next = cur.next.next;
            }else{
                cur = cur.next;
            }
        }
        return header.next;
    }
}

4.反转一个链表

反转一个单链表。

例子：

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NUL
递归方法

在这里插入图片描述

假设方法实现了，那么调用方法会变成怎么样呢（这个思考很关键，利用递归，必须得先知道递归的函数的作用）
在这里插入图片描述
调用下一个，这里执行成功后，开始归的代码
在这里插入图片描述
代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        //边界条件
        if (head==null || head.next==null) return head;
        // 这个是递
        ListNode newHead = reverseList(head.next);
        // 拿到4，也就是head.next
        // 让4，指向下一个节点就是head,这里是归
        //下面的归操作，就是newHead-1-2-3-4,已经得到了
        //然后连接5得到newHead-1-2-3-4-5的过程
        head.next.next = head;
        // 5的next应该指向空
        head.next = null;
        return newHead;
    }
}

递归总结：

  1. 理解递归函数的作用
  2. 写出递归中的递：也就是调用下一个
  3. 写出递归中的归：也就是调用下一个成功后，怎么操作让上一个成立
  4. 写出边界条件，避免死循环。
头插法
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        // 头插法
        ListNode newHead = null;
        while (head != null){
            //保存下一个节点，防止找不到
            ListNode temp = head.next;
			//插入
            head.next = newHead;
            newHead = head;
			//原来的head指向下一个节点
            head = temp;
        }
        return newHead;
    }
}

5 .判断链表是否有环

快慢指针解决

代码

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) return false;
        ListNode slow = head;
        ListNode fast = head.next;
        //fast为空的话，fast.next就会空指针，所有需要两个都不为空
        while(fast != null && fast.next != null){
            if (slow.val == fast.val) return true;
            slow = slow.next;
            fast = fast.next.next;
        }
        return false;
    }
}

6.循环链表解决约瑟夫问题

public static void josephus(){
    //循环链表
	CircleLinkedList<Integer> list = new CircleLinkedList<>();
	for(int i = 1; i <= 8; i++){
		list.add(i);
	}
    //指向头节点
	list.reset(); // current->1
	while(!list.isEmpty()){
        //这里定义走的步数
		list.next();
		list.next();
        //删除节点
		System.out.println(list.remove());
	}
}

注：仅用于学习交流

xlshi1996
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序建链表（数据结构）
Move on
01-22 1921
顺序建立链表（数据结构）   顺序建链表是在最后一个结点之后插入新结点。   最后一个结点——尾结点。   指针变量 tail 保存尾结点地址——尾指针。   插入结点后尾指针 tail 的值要随之修改，指向新的尾结点。 (1)建立只包含头结点的空链表，头指针、尾指针均指向头结点。 head=(struct node *)malloc(sizeof(struct node)); ...
和别人不一样的链表 比别人酷 比别人好懂 关键还有特效~~
DongGu‘s Programming
05-22 184
不说别的 你们先看看效果~~ 其实也没什么，就是输出时加了几个easyx的函数，变了颜色和背景，让本来学数据结构就烦有了一点点乐趣，ok，回归正题 ，链表，如何去写，我想这要回归到内存的认识，自己去操作内存，所以这个时候，烦人的指针出现了，通过指针来实现链表就可以快速的增删，并且在增删以后就可以把不要的节点的内存给释放，这就是一个我们难以接受的~ 那好，现在我用一种不一样的链表带给大家，当然这种写法是一个老师教给了我，并且对我来说易于接受，所以在这里就分享给大家 用面向对象的模式写链表，别被这个名词
数据结构13：无序表抽象数据类型（链表）（一）
xddwz的博客
08-29 813
一、什么是无序表 在前面基本数据结构的讨论中，采用python list实现了多种线性数据结构，主要包括栈、队列、双端队列，可以发现列表list是一种简单强大的数据集结构，提供了丰富的操作接口。 什么是列表呢？ 列表其实是一种数据项按照相对位置存放的数据集。 特别的，被称为“无序表（unordered list）”，其中的数据项只按照存放位置来索引，如第一个、第二个等（这里假设表中不存在重复的数据项）。 例如一个考试分数的集合“54，26，93，17，77，31”，如果用无序表来表示的话，就是[54
【数据结构】抽象数据类型间的区别和联系（列表，线性表，链表，数组）
风舞雪凌月的博客
03-17 2187
【数据结构】抽象数据类型间的区别和联系（列表，线性表，链表，数组）备注一、抽象数据类型ADT二、线性结构三、数组（一维）四、链表（linked list）五、列表（list）六、线性表（linear list） 备注 2020/3/17 星期二 听说大家已经都开始学习数据结构了，但是很多人都被各各种数据结构相关的名称搞的晕头转向，我专门查了大量资料来和大家一起聊聊各种数据结构的关系。 一、抽象数据...
C算法-链表升级版
weixin_45554139的博客
11-03 84
之前写过一篇简单的链表，现在更新些常用的手段。 1、快慢指针找中点，那么slow是间点 struct ListNode*fast, *slow; fast = slow = head; while(fast != NULL && fast.next != NULL) { slow= slow.next; fast = fast.next.next; } 2、链表反转，需要一个指针NULL作为尾巴，每遍历一个节点，就把这个节点作为下一个的新尾巴； struct Li
C语言数据结构之双链表---链表&数据分离（从零写一个双链）
假如技术娶了生活...
08-01 512
双链程序
C语言数据结构-链表版学生管理系统
最新发布
10-02
《C语言数据结构-链表版学生管理系统》 在计算机科学中，数据结构是组织、存储和处理数据的重要工具，而链表作为一种基础且灵活的数据结构，被广泛应用于各种复杂算法和系统设计中。本项目《C语言数据结构-链表版...
数据结构-链表相关功能和算法
06-11
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着不可或缺的角色。相比于数组，链表在处理动态数据集合时提供了更大的灵活性。在这个"数据结构-链表相关功能和算法"的主题中，我们将深入探讨链表的...
用数据结构-链表实现通讯录管理系统
04-12
本项目以"用数据结构-链表实现通讯录管理系统"为主题，通过C语言实现了这一功能，旨在帮助用户管理他们的联系人信息。下面我们将深入探讨这个系统所涉及的主要知识点。 首先，我们来了解**链表**这一数据结构。链表...
数据结构单双链表c++版
07-14
在这个"数据结构单双链表C++版"的压缩包中，我们主要关注的是两种基本的数据结构——单链表和双链表，它们在C++编程环境下被实现。这两种链表都是线性数据结构的实例，是数组的延伸，特别适用于处理动态变化大小的...
数据结构(C语言版)---静态链表
09-21
静态链表是一种特殊的链式数据结构，它与常规动态链表有所不同，主要在于存储方式和内存分配。 静态链表，顾名思义，与动态链表相对，其链表节点是在编译时静态分配的，而不是在运行时动态分配。这种设计减少了动态...
线性表概述及单链表的Java实现
帅气陈吃苹果
04-27 276
一、线性表概述 线性表是指一组数据元素之间具有线性关系的元素序列，它表现为：除第一个元素没有直接前驱元素、最后一个元素没有直接后继元素外，其余所有元素都有且仅有一个直接前驱元素和直接后继元素。 根据存储结构的不同，线性表可以分为顺序存储和链式存储。 1、顺序存储 顺序存储结构是指用一段地址连续的存储单元依次存储线性表的数据元素。 数组就是采用顺序存储结构来存储的，数组元素的保存和读取操作的时间复杂...
搞懂数据结构-树结构
xlshi1996的博客
06-01 2169
搞懂树结构 1.什么是树结构 树结构是一种非常重要的非线性结构，反应了数据元素之间的层次关系和分支关系。 树的表示方法 树型表示法 文氏图表示方法 凹入图表示法 广义表表示法 （A(B1(C1,D1,E1),B2(C2),B3) 2.树的分类 根据树中节点的各子树从左到右是否有次序，能否交换分为 有序树 无序数 3.二叉树 二叉树并非是树的特殊情形，它和度数为2的有序树是两种不同的数据结构。 3.1二叉树的基本形态 空二叉树 只有一个根节点 根节点只有左子树 根节点只有右子树 根
栈的出栈顺序规律
xlshi1996的博客
08-28 1251
栈的出栈顺序规律 任何出栈的元素后面出栈的元素必须满足一下两点： 在原序列中相对位置比它小的，必须是逆序 在原序列中相对位置比它大的，顺序没有要求 ** 注：仅用于学习交流**
搞懂数据结构-二叉树
xlshi1996的博客
06-15 420
搞懂数据结构-二叉树 使用树形结构可以大大提高效率 树形结构是算法面试的重点 1.树的基本概念 2.二叉树 2.1二叉树的特点 2.2二叉树的性质 2.3 二叉树的分类 真二叉树 所有的节点的度要么为0，要么为2，没有度为1。 满二叉树 所有的节点的度要么为0，要么为2；但是所有的叶子节点都在最后一层 可以看出满二叉树是真二叉树的特例，所以满二叉树一定是真二叉树，真二叉树不一定是满二叉树 完全二叉树 对节点从上至下、左至右开始编号，其所有编号都能与相同高度的满二叉树中的编号对应
左神算法整理笔记01
xlshi1996的博客
11-17 273
1.左神算法基础篇
搞懂单链表
xlshi1996的博客
05-27 227
线性表的链式存储 1.学习目标 单链表的定义和基本操作 循环链表的定义和基本操作 双链表的定义和基本操作 链表的经典算法题 链表的实际应用场景 2.链表的简介 线性表根据存储结构可以分为顺序存储和链式存储两大类。顺序存储具有查询快的优点，但是在插入和删除元素功能上，会造成大量元素移动。为了改善这一缺点，引入了链式存储的线性表。本文从单链表，循环链表，双链表递进来讲述链表及其相关操作。 2.1单链表 上图是链式存储线性表的逻辑结构，分为两部分，其中data是数据域，存放数据元素的值；next是指针域，存
搞懂Collection集合-List集合
xlshi1996的博客
05-28 220
搞懂Collection集合-List集合 学习目标 掌握集合提出的背景 掌握集合的特点 掌握集合的分类 掌握集合中的List集合的操作 掌握集合的List集合使用场景 1.集合提出的背景 常用的数据结构有：数组，链表，队列，栈，树和散列表等等。在实际程序上除了内置的数组外，Java把其他的数据结构封装起来做成API，这些API被称为集合类。所以，Java中的容器主要分为数组和集合类。 2.集合的特点 集合的长度可变，数组的长度固定 集合只能存储引用类型（只能存储对象，类似int类型会自动装箱成Int
数据结构-链表按序号查找算法解析
"查找运算-tsinghua严版教材讲义 数据结构 计算机系 第一章绪论 算法和算法分析" 本资源主要涵盖了数据结构中的查找运算，特别是针对链表的按序号查找操作。在数据结构中，查找运算是一项基础且重要的操作，它涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值