04 -链表相关知识

最新推荐文章于 2024-01-12 09:15:55 发布
最新推荐文章于 2024-01-12 09:15:55 发布
阅读量729 收藏
点赞数
分类专栏： 算法 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40865448/article/details/121299601
版权

关于链表

大多数链表都是检验coding能力的，通过熟练度不断提升。在面试中一二面会进行考察，基本必须AC，是很基础的考察项。

关于null

JVM虚拟机里面规定了一个地址为null,然后链表最后一个元素中其实也是存了一个地址，只不过该地址指向null所在的内存空间。所以最后一个元素指向null。（可以理解为启动前约定好，某一个地址就叫null）

单链表的反转及双链表的反转

  1. 链表的遍历
    首先获得头指针，
    循环
    Node cur = head;
while (cur != null){
	// 中间处理流程
	System.out.println(cur.value);
	//切记不要忘了，更新下一个节点。while循环中一定要更新节点
	cur = cur.next;
}
  2. 反转注意事项：
    定义一个反转方法后， 该方法一定要返回新的头指针，并在调用时进行接收。否则会被GC（引用为0即被GC）。
  3. 反转大体步骤
    3.1 先用next记录下一个节点的地址
    3.2 对当前节点的指针进行反转
    3.3.将pre和当前节点head，进行更新 --> 往前移动
    代码：
package class04;

public class LinkedList {
   public static class Node {
       public int value;
       public Node next;

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

   public static class DoubleNode {
       public int value;
       public DoubleNode last;
       public DoubleNode next;

       public DoubleNode(int value) {
           this.value = value;
       }
   }

   // 链表都是需要头节点来进行访问的
   public static Node reverseLinkedList(Node head) {
       Node pre = null;
       Node next = null;
       // 修改 Node 中Next指针指向Pre
       // 顺序： 首先保存next, 然后修改指针指向pre，然后将pre和head一同更新到下一个位置
       while (head != null) {
           next = head.next;
           head.next = pre;
           pre = head;
           head = next;
       }
       return pre;
   }

   public static DoubleNode reverseDoubleList(DoubleNode head) {
       DoubleNode pre = null;
       DoubleNode next = null;
       while (head != null) {
           // 1. 先把下一个节点位置 记住
           next = head.next;
           // 2. 修改指针 （此时可以随意修改指针）
           head.last = next;
           head.next = pre;
           // 3.更新pre 和 head
           pre = head;
           head = next;
       }
       return pre;
   }

   public static void printLinkedList(Node head) {
       while (head != null) {
           System.out.println(head.value);
           head = head.next;
       }
   }

   public static void printDoubleList(DoubleNode head) {
       System.out.println("Forward");
       DoubleNode pre = null; // 栈中声明的变量需要赋初值
       while (head != null) {
           System.out.println(head.value);
           pre = head;
           head = head.next;
       }
       System.out.println("Reverse");
       while (pre != null) {
           System.out.println(pre.value);
           pre = pre.last;
       }
   }

   public static void main(String[] args) {
       Node node1 = new Node(1);
       node1.next = new Node(2);
       node1.next.next = new Node(3);
       // 1 -> 2 -> 3

       System.out.println("Linked List original order:");
       printLinkedList(node1);
       System.out.println("Linked List reverse order:");
       node1 = reverseLinkedList(node1);
       printLinkedList(node1);


       DoubleNode head = new DoubleNode(1);
       head.next = new DoubleNode(2);
       head.next.next = new DoubleNode(3);
       head.next.last = head;
       head.next.next.last = head.next;
       // 1 -> 2 -> 3

       System.out.println("Double Linked List original order:");
       printDoubleList(head);
       System.out.println("Double Linked List reverse order:");
       head = reverseDoubleList(head);
       printDoubleList(head);
   }
}

单链表实现栈和队列

重点：

  1. 栈 ： 后进先出
  2. 队列： 先进先出
    那么，对于单链表而言，先出的必定使用head指向，所以根据谁先出，确定head位置。比如，栈，后进先出，那么Head指向后进的。队列，先进先出，那么Head指向先进的。
    所以，
    栈： 只需要head，头插法
    队列： 需要head和tail, 尾插法

PS: 无论是头插法还是尾插法，都要进行（2个）分支判断，1.为空（head==null）直接赋值 2.为不空(head!=null) 要对新增元素进行指针调整.
关键点： 就是用head来指向 出值 的元素对象。

特点：
插入，弹出，查看 ----> 时间复杂度 都为O（1）；

package class04;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class Code02_LinkedListToQueueAndStack {

	// 首先定义 单链表节点 使用泛型
	public static class Node<V> {
		public V value;
		public Node<V> next;

		public Node(V value) {
			this.value = value;
			this.next = null;
		}
	}

	// 队列需要 head 和 tail，并且为了随时可以返回size，还要一个属性为size
	// 使用封装，private
	// 总结： 单链表实现队列，头尾指针，尾插法
	public static class MyQueue<V> {
		private Node<V> head;
		private Node<V> tail;
		private int size;

		// 构造器
		public MyQueue() {
			head = null;
			tail = null;
			size = 0;
		}

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

		public int size() {
			return size;
		}

		// 入队： 插入元素时， 将元素转化为节点对象， 然后调整首尾指针
		public void offer(V value) {
			Node<V> cur = new Node<>(value);
			// 如果 队列 为空， 则将首尾指针一同指向节点
			if (head == null) {
				head = cur;
				tail = cur;
			} else {
				// 如果 队列中已经有节点了，依据 队列先入先出 的原则，head指针指向先入的元素，因为出队顺序依据head指针，
				// 先入先出，意味着 head指针 指向 最先进入的元素，后面的元素，通过尾插法插入
				tail.next = cur;
				tail = cur;
			}

			// 最后不要忘记 因为队列 新增了元素 ， 所以要 size++
			size++;
		}

		// 出队： 出队 意味着两件事情： 1. 返回队首中的首个元素 2.去除返回的元素
		public V poll() {
			// 首先定义 返回元素为null. 有两个作用，如果队列为空，直接返回；如果队列不空，会在if语句中进行赋值。
			// 泛型针对的是 引用数据类型
			V ans = null;
			if (head != null) {
				ans = head.value;
				head = head.next;
				size--;
			}
			// 要注意一个场景：队列中只有一个元素，此时出队，头指针为null,尾指针指向上一个元素
			// 存在问题，1. 头尾指针没有及时统一 2.最重要一点： 若tail依然指向出队元素，该对象无法被JV,释放，从而出现脏数据，导致内存泄漏
			// 所以要在每次出队之后进行检查，是否头指针变为了空
			if (head == null) {
				tail = null;
			}
			return ans;
		}

		// 返回队首元素的值，但是不移除该元素
		public V peek() {
			V ans = null;
			// 两种情况，
			// 1. 队列为空，不处理，【直接返回ans】
			// 2. 队列不空（head != null）, 对ans进行赋值，【返回ans】
			if (head != null) {
				ans = head.value;
			}
			return ans;
		}
	}

	// 单链表实现栈，头指针+头插法 因为后入先出，后进入的先出，head意味着先出
	public static class MyStack<V> {
		private Node<V> head;
		private int size;

		// 构造器： 空构造器，对属性进行初始化
		public MyStack() {
			head = null;
			size = 0;
		}

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

		public int size() {
			return size;
		}

		// 入队: 头插法
		// 这里可以注意到， 无论是头插法还是尾插法，都要进行（2个）分支判断，1.为空（head==null）直接赋值 2.为不空(head!=null) 要对新增元素进行指针调整
		public void push(V value) {
			Node<V> cur = new Node<>(value);
			if (head == null) {
				head = cur;
			} else {
				cur.next = head;
				head = cur;
			}
			size++;
		}

		// 出队
		public V pop(){
			V ans = null;
			if(head != null) {
				ans = head.value;
				head = head.next;
				// 一定要注意 对size-- 因为要调整size属性
				size--;
			}
			return ans;
		}

		public V peek(){
			V ans = null;
			if (head != null) {
				ans = head.value;
			}
			return ans;
		}

	}

	public static void testQueue() {
		MyQueue<Integer> myQueue = new MyQueue<>();
		Queue<Integer> test = new LinkedList<>();
		int testTime = 5000000;
		int maxValue = 200000000;
		System.out.println("测试开始！");
		for (int i = 0; i < testTime; i++) {
			if (myQueue.isEmpty() != test.isEmpty()) {
				System.out.println("Oops!");
			}
			if (myQueue.size() != test.size()) {
				System.out.println("Oops!");
			}
			double decide = Math.random();
			if (decide < 0.33) {
				int num = (int) (Math.random() * maxValue);
				myQueue.offer(num);
				test.offer(num);
			} else if (decide < 0.66) {
				if (!myQueue.isEmpty()) {
					int num1 = myQueue.poll();
					int num2 = test.poll();
					if (num1 != num2) {
						System.out.println("Oops!");
					}
				}
			} else {
				if (!myQueue.isEmpty()) {
					int num1 = myQueue.peek();
					int num2 = test.peek();
					if (num1 != num2) {
						System.out.println("Oops!");
					}
				}
			}
		}
		if (myQueue.size() != test.size()) {
			System.out.println("Oops!");
		}
		while (!myQueue.isEmpty()) {
			int num1 = myQueue.poll();
			int num2 = test.poll();
			if (num1 != num2) {
				System.out.println("Oops!");
			}
		}
		System.out.println("测试结束！");
	}

	public static void testStack() {
		MyStack<Integer> myStack = new MyStack<>();
		Stack<Integer> test = new Stack<>();
		int testTime = 5000000;
		int maxValue = 200000000;
		System.out.println("测试开始！");
		for (int i = 0; i < testTime; i++) {
			if (myStack.isEmpty() != test.isEmpty()) {
				System.out.println("Oops!");
			}
			if (myStack.size() != test.size()) {
				System.out.println("Oops!");
			}
			double decide = Math.random();
			if (decide < 0.33) {
				int num = (int) (Math.random() * maxValue);
				myStack.push(num);
				test.push(num);
			} else if (decide < 0.66) {
				if (!myStack.isEmpty()) {
					int num1 = myStack.pop();
					int num2 = test.pop();
					if (num1 != num2) {
						System.out.println("Oops!");
					}
				}
			} else {
				if (!myStack.isEmpty()) {
					int num1 = myStack.peek();
					int num2 = test.peek();
					if (num1 != num2) {
						System.out.println("Oops!");
					}
				}
			}
		}
		if (myStack.size() != test.size()) {
			System.out.println("Oops!");
		}
		while (!myStack.isEmpty()) {
			int num1 = myStack.pop();
			int num2 = test.pop();
			if (num1 != num2) {
				System.out.println("Oops!");
			}
		}
		System.out.println("测试结束！");
	}

	public static void main(String[] args) {
		testQueue();
		testStack();
	}

}

双链表实现双向队列

并且，单链表无法实现双向队列。
关键点： 1. 头尾指针。
2. 在插入或弹出节点时，注意将指针设为空，从而令JVM自动释放引用为0 的 对象。

先show我的错误代码： 错误点已经标记： 没有考虑完全。 在出队时 不同于单链表队列。 因为要通过访问指针，并更改为null，来将 节点 通过JVM内部机制进行回收。

package class04;

public class DoubleLinkedListToDeque {
    // 定义双链表节点
    public static class Node<V> {
        // 定义属性 （成员变量）
        public V value;
        public Node<V> last;
        public Node<V> next;

        // 定义构造器
        public Node(V v) {
            value = v;
            last = null;
            next = null;
        }
    }

    public static class MyDeque<V> {
        // 头尾指针，和size
        private Node<V> head;
        private Node<V> tail;
        private int size;

        // 构造器
        public MyDeque() {
            head = null;
            tail = null;
            size = 0;
        }

        // 开始定义方法

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

        public int size() {
            return size;
        }

        // 双向队列 pushHead pushTail pollHead pollTail
        // poll是队列数据结构实现类的方法，从队首获取元素，同时获取的这个元素将从原队列删除；
        // pop是栈结构的实现类的方法，表示返回栈顶的元素，同时该元素从栈中删除，当栈中没有元素时，调用该方法会发生异常
        public void pushHead(V value) {
            // 接收value 创建泛型 节点对象
            Node<V> cur = new Node<>(value);

            // 头插法
            if (head == null) {
                head = cur;
                tail = cur;
            } else {
                // 双链表的头插法
                // Step1: 调整双链表指针
                cur.next = head;
                head.last = cur;
                // Step2: 调整头节点head的位置
                head = cur;
                // 这里忽视了一个事情！！！ 我们操作的是 双链表， 有两个指针，next 和 last，全部要进行调整
                // 所以进行头插法的时候 要注意，是 进行单链表的头插法，还是双链表的头插法
            }
            size++;
        }

        public void pushTail(V value) {
            Node<V> cur = new Node<>(value);
            // 双链表的尾插法
            if (head == null) {
                head = cur;
                tail = cur;
            } else {
                // 1. 调整 双链表 指针
                tail.next = cur;
                cur.last = tail;
                // 2. 调整tail指针
                tail = cur;
            }
            size++;
        }

        public V pollHead() {
            V ans = null;
            if (head != null) {
                ans = head.value;
                head = head.next;
                // 错误标记！！！！
                // 若是只有一个节点时，会出现 空指针异常
                head.last = null;
                size--;
            }
            if (head == null) {
                tail = null;
            }
            return ans;
        }

        public V pollTail() {
            V ans = null;
            if (head != null) {
                ans = tail.value;
                tail = tail.last;
                // 错误标记！！！！
                // 若是只有一个节点时，会出现 空指针异常
                tail.next = null;
                size--;
            }
            if (tail == null) {
                head = null;
            }
            return ans;
        }

        public V peekHead() {
            V ans = null;
            if (head != null) {
                ans = head.value;
            }
            return ans;
        }

        public V peekTail() {
            V ans = null;
            if (tail != null) {
                ans = tail.value;
            }
            return ans;
        }
    }
}

正确代码：
其实在出队时，只要清晰考虑 队列长度为 0，1，>1的情况即可完成。不同于单链表，只需要考虑 0， >0。 因为单链表只需要通过头尾指针跳转就可令JVM删除脏数据，但是双链表需要通过访问移动后头尾指针所指元素的next,last来删除脏数据。这使得双链表删除时，poll方法，需要多考虑1的情况。
```java
package class04;

import java.util.Deque;
import java.util.LinkedList;

public class Code03_DoubleLinkedListToDeque {

	/* 注释部分为左神代码
	public static class Node<V> {
		public V value;
		public Node<V> last;
		public Node<V> next;

		public Node(V v) {
			value = v;
			last = null;
			next = null;
		}
	}

	public static class MyDeque<V> {
		private Node<V> head;
		private Node<V> tail;
		private int size;

		public MyDeque() {
			head = null;
			tail = null;
			size = 0;
		}

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

		public int size() {
			return size;
		}

		public void pushHead(V value) {
			Node<V> cur = new Node<>(value);
			if (head == null) {
				head = cur;
				tail = cur;
			} else {
				cur.next = head;
				head.last = cur;
				head = cur;
			}
			size++;
		}

		public void pushTail(V value) {
			Node<V> cur = new Node<>(value);
			if (head == null) {
				head = cur;
				tail = cur;
			} else {
				tail.next = cur;
				cur.last = tail;
				tail = cur;
			}
			size++;
		}

		public V pollHead() {
			V ans = null;
			if (head == null) {
				return ans;
			}
			size--;
			ans = head.value;
			if (head == tail) {
				head = null;
				tail = null;
			} else {
				head = head.next;
				head.last = null;
			}
			return ans;
		}

		public V pollTail() {
			V ans = null;
			if (head == null) {
				return ans;
			}
			size--;
			ans = tail.value;
			if (head == tail) {
				head = null;
				tail = null;
			} else {
				tail = tail.last;
				tail.next = null;
			}
			return ans;
		}

		public V peekHead() {
			V ans = null;
			if (head != null) {
				ans = head.value;
			}
			return ans;
		}

		public V peekTail() {
			V ans = null;
			if (tail != null) {
				ans = tail.value;
			}
			return ans;
		}

	}*/
	// 定义双链表节点
	public static class Node<V> {
		// 定义属性 （成员变量）
		public V value;
		public Node<V> last;
		public Node<V> next;

		// 定义构造器
		public Node(V v) {
			value = v;
			last = null;
			next = null;
		}
	}

	public static class MyDeque<V> {
		// 头尾指针，和size
		private Node<V> head;
		private Node<V> tail;
		private int size;

		// 构造器
		public MyDeque() {
			head = null;
			tail = null;
			size = 0;
		}

		// 开始定义方法

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

		public int size() {
			return size;
		}

		// 双向队列 pushHead pushTail pollHead pollTail
		// poll是队列数据结构实现类的方法，从队首获取元素，同时获取的这个元素将从原队列删除；
		// pop是栈结构的实现类的方法，表示返回栈顶的元素，同时该元素从栈中删除，当栈中没有元素时，调用该方法会发生异常
		public void pushHead(V value) {
			// 接收value 创建泛型 节点对象
			Node<V> cur = new Node<>(value);

			// 头插法
			if (head == null) {
				head = cur;
				tail = cur;
			} else {
				// 双链表的头插法
				// Step1: 调整双链表指针
				cur.next = head;
				head.last = cur;
				// Step2: 调整头节点head的位置
				head = cur;
				// 这里忽视了一个事情！！！ 我们操作的是 双链表， 有两个指针，next 和 last，全部要进行调整
				// 所以进行头插法的时候 要注意，是 进行单链表的头插法，还是双链表的头插法
			}
			size++;
		}

		public void pushTail(V value) {
			Node<V> cur = new Node<>(value);
			// 双链表的尾插法
			if (head == null) {
				head = cur;
				tail = cur;
			} else {
				// 1. 调整 双链表 指针
				tail.next = cur;
				cur.last = tail;
				// 2. 调整tail指针
				tail = cur;
			}
			size++;
		}

		/*public V pollHead() {
            V ans = null;
            if (head != null) {
                ans = head.value;
                head = head.next;
                // 错误标记！！！！
                // 若是只有一个节点时，会出现 空指针异常
                head.last = null;
                size--;
            }
            if (head == null) {
                tail = null;
            }
            return ans;
        }

        public V pollTail() {
            V ans = null;
            if (head != null) {
                ans = tail.value;
                tail = tail.last;
                // 错误标记！！！！
                // 若是只有一个节点时，会出现 空指针异常
                tail.next = null;
                size--;
            }
            if (tail == null) {
                head = null;
            }
            return ans;
        }*/
		public V pollHead(){
			V ans = null;
			if (head == null) {
				return ans;
			}
			ans = head.value;
			head = head.next;
			// 对只有一个元素 或 多个元素 进行 分支结构
			// 目的都是 JVM 释放 脏数据
			if(head == null) {
				tail = null;
			} else {
				head.last = null;
			}
			size--;
			return ans;
		}

		public V pollTail(){
			V ans = null;
			if (head == null) {
				return ans;
			}
			// 否则 代表队列一定不空，则
			ans = tail.value;
			tail = tail.last;
			if (tail == null) {
				head = null;
			} else {
				tail.next = null;
			}
			size--;
			return ans;
		}


		public V peekHead() {
			V ans = null;
			if (head != null) {
				ans = head.value;
			}
			return ans;
		}

		public V peekTail() {
			V ans = null;
			if (tail != null) {
				ans = tail.value;
			}
			return ans;
		}
	}

	public static void testDeque() {
		MyDeque<Integer> myDeque = new MyDeque<>();
		Deque<Integer> test = new LinkedList<>();
		int testTime = 5000000;
		int maxValue = 200000000;
		System.out.println("测试开始！");
		for (int i = 0; i < testTime; i++) {
			if (myDeque.isEmpty() != test.isEmpty()) {
				System.out.println("Oops!");
			}
			if (myDeque.size() != test.size()) {
				System.out.println("Oops!");
			}
			double decide = Math.random();
			if (decide < 0.33) {
				int num = (int) (Math.random() * maxValue);
				if (Math.random() < 0.5) {
					myDeque.pushHead(num);
					test.addFirst(num);
				} else {
					myDeque.pushTail(num);
					test.addLast(num);
				}
			} else if (decide < 0.66) {
				if (!myDeque.isEmpty()) {
					int num1 = 0;
					int num2 = 0;
					if (Math.random() < 0.5) {
						num1 = myDeque.pollHead();
						num2 = test.pollFirst();
					} else {
						num1 = myDeque.pollTail();
						num2 = test.pollLast();
					}
					if (num1 != num2) {
						System.out.println("Oops!");
					}
				}
			} else {
				if (!myDeque.isEmpty()) {
					int num1 = 0;
					int num2 = 0;
					if (Math.random() < 0.5) {
						num1 = myDeque.peekHead();
						num2 = test.peekFirst();
					} else {
						num1 = myDeque.peekTail();
						num2 = test.peekLast();
					}
					if (num1 != num2) {
						System.out.println("Oops!");
					}
				}
			}
		}
		if (myDeque.size() != test.size()) {
			System.out.println("Oops!");
		}
		while (!myDeque.isEmpty()) {
			int num1 = myDeque.pollHead();
			int num2 = test.pollFirst();
			if (num1 != num2) {
				System.out.println("Oops!");
			}
		}
		System.out.println("测试结束！");
	}

	public static void main(String[] args) {
		testDeque();
	}

}




## K个节点的组内逆序调整
![在这里插入图片描述](https://img-blog.csdnimg.cn/08b82f392c9e4c539deb713f4c4620ce.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAd2Fsa2trZXI2NjY=,size_20,color_FFFFFF,t_70,g_se,x_16)


## 链表的顺序合并


## AddTwoNumber
walkkker666
关注
专栏目录
C语言链表知识点
m0_74329015的博客
07-25 411
链表的优点是动态性，可以在运行时动态添加、删除和修改节点，而无需预先分配固定大小的内存空间。链表是一种动态数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。删除节点：删除节点需要注意处理节点间的指针关系，以确保链表的完整性。创建节点：使用函数动态分配内存来创建新节点，并将数据存储在节点中。节点结构：定义链表节点的结构（可以使用结构体）来保存数据和指针。插入节点：插入节点涉及到修改指针的指向，使其指向正确的位置。遍历链表：使用循环遍历链表中的所有节点，并访问节点的数据。
＜数据结构----队列(C语言版)＞
一些普普通通的学习笔记
05-05 1163
数据结构----队列
【数据结构】单链表
hhhkkksa的博客
10-30 645
单链表
JDK8：HashMap源码解析：newNode方法、Node类
老艮头的后知后觉
05-29 4662
一、概述 在Map中存储的每一个键值对都是以一个Map.Entry&lt;K,V&gt;的实现对象存储的，Map.Entry是一个接口，不能实例化，所以Map的不同实现类，存储键值对的方式也会有所不同，只要这个键值对的类实现了Map.Entry接口即可。 在HashMap中键值对的存储方式有两种： 其中一种是我们比较熟知的链表存储结构，也就是以HashMap.Node&lt;K,V&gt;类...
C语言单链表
MRLLLL123的博客
01-12 348
设有一条单链表保存了一个班级信息，其中包含：姓名、学号、密码、年龄、请编写一个登入函数，传入这条链表和学号，然后要求输入密码（输入三次错误则程序结束），如果密码正确则登入成功，登入后可以选择修改姓名或年龄或密码，然后进行保存或退出登入。例如: 密码为123456、abcdef,学生姓名为 张三 、李四，年龄为 20,23，学号为1234,1235。登入后可以选择修改姓名或年龄或密码，然后进行保存或退出登入。
00-链表预备知识_代码_.zip
03-14
在这个"00-链表预备知识_代码_.zip"压缩包中，包含了一系列关于链表的实现和相关概念的代码示例，让我们深入探讨这些知识点。 1. **链表类型**: - **单链表（Single Linked List）**: 包含`linkSet`和`orderList`...
C语言开发----链表HuffmanTree.rar
最新发布
04-10
学习这些内容可以帮助深入理解C语言的数据结构和算法，并提升在实际问题中应用这些知识的能力。对于想要进入IT行业的开发者来说，熟练掌握C语言和数据结构是必不可少的基础，而哈夫曼树则是数据压缩和通信编码领域的...
链表----链表构造
01-17
### 链表构造知识点详解 #### 一、链表基本概念 链表是一种常见的线性数据结构，它通过节点之间的连接来表示数据项。与数组不同，链表中的元素不必存储在连续的内存空间中。每个节点包含两部分：数据部分（用于...
算法设计-实验五-链表.docx
09-06
本资源专注于Python中链表的实现，通过实验五的描述，我们可以学习以下关键知识点： 1. **链表的基本概念**： - 节点结构：每个节点由数据部分和一个指向下个节点的指针组成。在Python中，这通常通过定义一个类来...
Java员工管理系统-链表
04-10
### Java员工管理系统-链表知识点解析 #### 一、项目背景与目标 在现代企业管理中，员工信息的有效管理和检索对于人力资源部门来说至关重要。基于此需求，我们开发了一款基于Java的员工管理系统，该系统利用链表和...
Node* p = new Node()；与new Node；
weixin_51447387的博客
11-07 4626
int main() { Node* p = new Node(); cout << p->data << endl;//0 p->data = 9; cout << p->data << endl;//9 Node* p2 = new Node; cout << p2->data << endl;//不确定 p2->data = 91; cout << p2->data
js的node对象(节点的使用)
全场梦游c的博客
03-16 3672
&lt;!DOCTYPE html&gt;&lt;html&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;&lt;/title&gt; &lt;script&gt; function copy1(){ var i1=document.getElementById("i1")
c++动态变量new node头文件_C/C++笔试题：主要考察C/C++语言基础概念算法及编程，附参考答案...
weixin_42309785的博客
02-03 1125
1.编写my_strcpy函数，实现与库函数strcpy类似的功能，不能使用任何库函数；答：char *strcpy(char *strDest, const char *strSrc){if ( strDest == NULL || strSrc == NULL)return NULL ;if ( strDest == strSrc)returnstrDest ;char *tempptr = ...
appendChild(newnode)
乌龟不背壳
12-21 585
appendChild(newnode) 在指定节点的最后一个子节点列表之后添加一个新的子节点 &lt;!DOCTYPE HTML&gt; &lt;html&gt; &lt;head&gt; &lt;meta http-equiv="Content-Type" content="text/html; charset=utf-8"&gt; &lt;title&gt;无标题文档&l
原生JS--解读Node（节点）
descire
01-18 5116
写在前面本来开开心心的看着ityped.js的源码，才看到几十行就发现怎么有两个方法没见过。然后翻看了一下MDN,发现自己的知识库要更新了。通过翻阅MDN和Stack Overflow，总结一些原生DOM操作的知识点，大致分为三个部分：Node解读、Element上的操作、DOM中的位置计算。Node的分类Node中有很多类，但是有几个你必须记住： | 类型 | node
ztree新增的new node默认选中可编辑状态
luckysyy的博客
06-29 1441
        var treeObj=$.fn.zTree.init($("#treeDemo"), setting, zNodes);        treeObj.expandAll(true);//展开全部        var nodes = treeObj.getNodes();        if(switchG == true){            doFindId(nodes...
单链表实现栈和队列
Harrison的学习博客
06-19 195
用单链表实现栈和队列
Java单链表和双链表的反转及实现队列、栈和双端队列
DreamsArchitects的博客
02-05 1616
算法与数据结构基础：介绍单链表和双链表结构、链表反转及实现队列、栈和双端队列
C++程序设计-链表操作详解
"C++程序设计相关知识，特别是关于链表的输出操作以及C++语言的特点" 在《输出链表-C++程序设计(谭浩强完整版)》中，讲解了如何在C++环境中处理链表数据结构并进行输出。这里我们主要关注的是`print`函数，它用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值