04.单链表及其简单题目

已于 2022-07-15 20:33:07 修改
阅读量408 收藏
点赞数
分类专栏： 算法笔记 文章标签： 链表 数据结构
于 2022-07-15 00:50:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/M_Love_U/article/details/125795758
版权

目录

单链表及其简单题目

一、单链表和双链表的定义

单链表：值，一条next指针

双链表：值，一条last指针，一条next指针

玩出无尽的花样！

二、单双链表的反转

经典题目

给定一个单链表的头head，完成链表的逆序调整给

定一个双链表的头head，完成链表的逆序调整

import java.util.ArrayList;
import java.util.List;

public class Code01_ReverseList {

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

		public Node(int data) {
			value = data;
		}
	}

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

		public DoubleNode(int data) {
			value = data;
		}
	}

	// 递归
	public static Node reverseLinkedList(Node head) {
		if (head == null || head.next == null) return head;
		Node res = reverseLinkedList(head.next);
		head.next.next = head;
		head.next = null;
		return res;
	}
	
	// 双指针
	public static Node reverseLinkedList1(Node head) {
		Node pre = null;
		Node next = null;
		while (head != null) {
			next = head.next;
			head.next = pre;
			pre = head;
			head = next;
		}
		return pre;
	}
	
	// 递归
	public static DoubleNode reverseDoubleList(DoubleNode head) {
		if (head == null || head.next == null) return head;
		DoubleNode res = reverseDoubleList(head.next);
		head.next.next = head;
		head.last = head.next;
		head.next = null;
		return res;
	}

	// 双指针
	public static DoubleNode reverseDoubleList1(DoubleNode head) {
		DoubleNode pre = null;
		DoubleNode next = null;
		while (head != null) {
			next = head.next;
			head.next = pre;
			head.last = next;
			pre = head;
			head = next;
		}
		return pre;
	}

	public static Node testReverseLinkedList(Node head) {
		if (head == null) {
			return null;
		}
		ArrayList<Node> list = new ArrayList<>();
		while (head != null) {
			list.add(head);
			head = head.next;
		}
		list.get(0).next = null;
		int N = list.size();
		for (int i = 1; i < N; i++) {
			list.get(i).next = list.get(i - 1);
		}
		return list.get(N - 1);
	}

	public static DoubleNode testReverseDoubleList(DoubleNode head) {
		if (head == null) {
			return null;
		}
		ArrayList<DoubleNode> list = new ArrayList<>();
		while (head != null) {
			list.add(head);
			head = head.next;
		}
		list.get(0).next = null;
		DoubleNode pre = list.get(0);
		int N = list.size();
		for (int i = 1; i < N; i++) {
			DoubleNode cur = list.get(i);
			cur.last = null;
			cur.next = pre;
			pre.last = cur;
			pre = cur;
		}
		return list.get(N - 1);
	}

	// for test
	public static Node generateRandomLinkedList(int len, int value) {
		int size = (int) (Math.random() * (len + 1));
		if (size == 0) {
			return null;
		}
		size--;
		Node head = new Node((int) (Math.random() * (value + 1)));
		Node pre = head;
		while (size != 0) {
			Node cur = new Node((int) (Math.random() * (value + 1)));
			pre.next = cur;
			pre = cur;
			size--;
		}
		return head;
	}

	// for test
	public static DoubleNode generateRandomDoubleList(int len, int value) {
		int size = (int) (Math.random() * (len + 1));
		if (size == 0) {
			return null;
		}
		size--;
		DoubleNode head = new DoubleNode((int) (Math.random() * (value + 1)));
		DoubleNode pre = head;
		while (size != 0) {
			DoubleNode cur = new DoubleNode((int) (Math.random() * (value + 1)));
			pre.next = cur;
			cur.last = pre;
			pre = cur;
			size--;
		}
		return head;
	}

	// for test
	public static List<Integer> getLinkedListOriginOrder(Node head) {
		List<Integer> ans = new ArrayList<>();
		while (head != null) {
			ans.add(head.value);
			head = head.next;
		}
		return ans;
	}

	// for test
	public static boolean checkLinkedListReverse(List<Integer> origin, Node head) {
		for (int i = origin.size() - 1; i >= 0; i--) {
			if (!origin.get(i).equals(head.value)) {
				return false;
			}
			head = head.next;
		}
		return true;
	}

	// for test
	public static List<Integer> getDoubleListOriginOrder(DoubleNode head) {
		List<Integer> ans = new ArrayList<>();
		while (head != null) {
			ans.add(head.value);
			head = head.next;
		}
		return ans;
	}

	// for test
	public static boolean checkDoubleListReverse(List<Integer> origin, DoubleNode head) {
		DoubleNode end = null;
		for (int i = origin.size() - 1; i >= 0; i--) {
			if (!origin.get(i).equals(head.value)) {
				return false;
			}
			end = head;
			head = head.next;
		}
		for (int i = 0; i < origin.size(); i++) {
			if (!origin.get(i).equals(end.value)) {
				return false;
			}
			end = end.last;
		}
		return true;
	}

	
	public static void f(Node head) {
		head = head.next;
	}
	
	// for test
	public static void main(String[] args) {
		int len = 50;
		int value = 100;
		int testTime = 100000;
		System.out.println("test begin!");
		for (int i = 0; i < testTime; i++) {
			Node node1 = generateRandomLinkedList(len, value);
			List<Integer> list1 = getLinkedListOriginOrder(node1);
			node1 = reverseLinkedList(node1);
			if (!checkLinkedListReverse(list1, node1)) {
				System.out.println("Oops1!");
			}

			Node node2 = generateRandomLinkedList(len, value);
			List<Integer> list2 = getLinkedListOriginOrder(node2);
			node2 = testReverseLinkedList(node2);
			if (!checkLinkedListReverse(list2, node2)) {
				System.out.println("Oops2!");
			}

			DoubleNode node3 = generateRandomDoubleList(len, value);
			List<Integer> list3 = getDoubleListOriginOrder(node3);
			node3 = reverseDoubleList(node3);
			if (!checkDoubleListReverse(list3, node3)) {
				System.out.println("Oops3!");
			}

			DoubleNode node4 = generateRandomDoubleList(len, value);
			List<Integer> list4 = getDoubleListOriginOrder(node4);
			node4 = reverseDoubleList(node4);
			if (!checkDoubleListReverse(list4, node4)) {
				System.out.println("Oops4!");
			}

		}
		System.out.println("test finish!");

	}

}

三、用单链表实现队列和栈

用单链表结构实现队列结构

用单链表结构实现栈结构

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

public class LinkedListToQueueAndStack {

   public static class Node<V> {
      public V value;
      public Node<V> next;

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

   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<V>(value);
         if (tail == null) {
            head = cur;
            tail = cur;
         } else {
            tail.next = cur;
            tail = cur;
         }
         size++;
      }

      // C/C++的同学需要做节点析构的工作
      public V poll() {
         V ans = null;
         if (head != null) {
            ans = head.value;
            head = head.next;
            size--;
         }
         if (head == null) {
            tail = null;
         }
         return ans;
      }

      // C/C++的同学需要做节点析构的工作
      public V peek() {
         V ans = null;
         if (head != null) {
            ans = head.value;
         }
         return ans;
      }

   }

   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;
      }

      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--;
         }
         return ans;
      }

      public V peek() {
         return head != null ? head.value : null;
      }

   }

   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();
   }

}

四、用双链表实现双端队列

用双链表结构实现双端队列

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

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> {
      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 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://leetcode.com/problems/reverse-nodes-in-k-group/

给定一个单链表的头节点head，和一个正数k

实现k个节点的小组内部逆序，如果最后一组不够k个就不调整例子:

调整前：1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8，

k = 3调整后：3 -> 2 -> 1 -> 6 -> 5 -> 4 -> 7 -> 8

// 测试链接：https://leetcode.com/problems/reverse-nodes-in-k-group/
public class ReverseNodesInKGroup {

   // 不要提交这个类
   public static class ListNode {
      public int val;
      public ListNode next;
   }

   public static ListNode reverseKGroup(ListNode head, int k) {
      ListNode start = head;
      ListNode end = getKGroupEnd(start, k);
      if (end == null) {
         return head;
      }
      // 第一组凑齐了！
      head = end;
      reverse(start, end);
      // 上一组的结尾节点
      ListNode lastEnd = start;
      while (lastEnd.next != null) {
         start = lastEnd.next;
         end = getKGroupEnd(start, k);
         if (end == null) {
            return head;
         }
         reverse(start, end);
         lastEnd.next = end;
         lastEnd = start;
      }
      return head;
   }

   public static ListNode getKGroupEnd(ListNode start, int k) {
      while (--k != 0 && start != null) {
         start = start.next;
      }
      return start;
   }

   public static void reverse(ListNode start, ListNode end) {
      end = end.next;
      ListNode pre = null;
      ListNode cur = start;
      ListNode next = null;
      while (cur != end) {
         next = cur.next;
         cur.next = pre;
         pre = cur;
         cur = next;
      }
      start.next = end;
   }

}

六、两个链表相加

测试链接：https://leetcode.com/problems/add-two-numbers/

给定两个链表的头节点head1和head2，

认为从左到右是某个数字从低位到高位，

返回相加之后的链表

例子 4 -> 3 -> 6 2 -> 5 -> 3

返回 6 -> 8 -> 9

解释 634 + 352 = 986

// 测试链接：https://leetcode.com/problems/add-two-numbers/
public class AddTwoNumbers {

    // 不要提交这个类
    public static class ListNode {
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }

        public ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }
    
    // 递归
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        return process(l1, l2, 0);
    }

    public ListNode process(ListNode l1, ListNode l2, int a) {
        if (l1 == null && l2 == null) return a == 0 ? null : new ListNode(a);
        if (l1 != null) {
            a += l1.val;
            l1 = l1.next;
        }
        if (l2 != null) {
            a += l2.val;
            l2 = l2.next;
        }
        return new ListNode(a % 10, process(l1, l2, a / 10));
    }

    // 非递归
    public static ListNode addTwoNumbers1(ListNode head1, ListNode head2) {
        int len1 = listLength(head1);
        int len2 = listLength(head2);
        ListNode l = len1 >= len2 ? head1 : head2;
        ListNode s = l == head1 ? head2 : head1;
        ListNode curL = l;
        ListNode curS = s;
        ListNode last = curL;
        int carry = 0;
        int curNum = 0;
        while (curS != null) {
            curNum = curL.val + curS.val + carry;
            curL.val = (curNum % 10);
            carry = curNum / 10;
            last = curL;
            curL = curL.next;
            curS = curS.next;
        }
        while (curL != null) {
            curNum = curL.val + carry;
            curL.val = (curNum % 10);
            carry = curNum / 10;
            last = curL;
            curL = curL.next;
        }
        if (carry != 0) {
            last.next = new ListNode(1);
        }
        return l;
    }

    // 求链表长度
    public static int listLength(ListNode head) {
        int len = 0;
        while (head != null) {
            len++;
            head = head.next;
        }
        return len;
    }

}

七、两个有序链表的合并

测试链接：https://leetcode.com/problems/merge-two-sorted-lists

给定两个有序链表的头节点head1和head2，

返回合并之后的大链表，要求依然有序

例子 1 -> 3 -> 3 -> 5 -> 7 2 -> 2 -> 3 -> 3-> 7

返回 1 -> 2 -> 2 -> 3 -> 3 -> 3 -> 3 -> 5 -> 7

// 测试链接：https://leetcode.com/problems/merge-two-sorted-lists
public class MergeTwoSortedLinkedList {

    // 不要提交这个类
    public static class ListNode {
        public int val;
        public ListNode next;
    }


    // 递归
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) return l2;
        if (l2 == null) return l1;
        ListNode res = l1.val < l2.val ? l1 : l2;
        res.next = mergeTwoLists(res.next, l1.val >= l2.val ? l1 : l2);
        return res;
    }

    // 非递归
    public static ListNode mergeTwoLists(ListNode head1, ListNode head2) {
        if (head1 == null || head2 == null) {
            return head1 == null ? head2 : head1;
        }
        ListNode head = head1.val <= head2.val ? head1 : head2;
        ListNode cur1 = head.next;
        ListNode cur2 = head == head1 ? head2 : head1;
        ListNode pre = head;
        while (cur1 != null && cur2 != null) {
            if (cur1.val <= cur2.val) {
                pre.next = cur1;
                cur1 = cur1.next;
            } else {
                pre.next = cur2;
                cur2 = cur2.next;
            }
            pre = pre.next;
        }
        pre.next = cur1 != null ? cur1 : cur2;
        return head;
    }

}

八、写在后面

欢迎关注，会经常记录一些算法学习中遇到的问题。

欢迎随时留言讨论，与君共勉，知无不答！

Java咩
关注
专栏目录
c语言输出单链表最大值与最小值,数据结构（C语言版）---顺序表与链表的比较...
weixin_39977547的博客
05-16 1569
1、存取方式1)顺序表：可以顺序存取，也可以随机存取。2)链表：只能从表头顺序存取。2、逻辑结构与物理结构1)顺序存储：逻辑上相邻，物理位置相邻。2)链式存储：逻辑上相邻，物理位置不一定相邻。3、查找、插入、删除1)按值查找：当表中数据无序时，顺序表和链表，时间复杂度为O(n)。当表中数据有序时，顺序表可采用折半查找，时间复杂度为O(log2n)。2)按序号查找：顺序表，时间复杂度为O(1)。链表...
链表内指定区间反转&&划分链表-
weixin_43288533的博客
12-08 668
1.链表内指定区间反转 - js 描述 将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。 例如： 给出的链表为 1→2→3→4→5→NULL, m=2,n=4m=2,n=4, 返回 1→4→3→2→5→NULL. 示例1 输入：{1,2,3,4,5},2,4 返回值：{1,4,3,2,5} 思路：链表的题思路简单编码麻烦，老是在弥缝子 1.根据题目给定的区间将链表切割成三段，并且将区间内的一段反转之后再次链接即可 代码实
单链表习题整理（一）
黑胡子大叔的博客
10-28 399
单链表归并 题目 已知两个链表A和B分别表示两个集合，元素递增排序。编制函数，求A和B的交集，并存放于A链表中 思想 归并实现，设置两个工作指针分别对应两个链表，分别遍历两个链表，当元素相同时才保留且保留一个，其他结点释放。当一个链表遍历完成后，释放另外一个链表。 代码段 void intercectLNode(LNode *&A,LNode *&B) { LNode *PA,*...
单链表 | 常见习题总结
BUZZ_Q的博客
09-20 378
1.输出倒数第k个节点 思路： 统计链表节点的个数length，让p从头节点遍历走length-k步，即得到倒数第k个节点的位置 代码如下： public int getLength(){ int count=0; for(Entry p=headEntry;p!=null;p=p.getNext()){ count++; } return count; }...
单链表常见习题总结
qq_45610772的博客
11-07 314
单链表常见习题总结2 10：删除所有关键值为key的节点 //10：删除所有关键值为key的节点 public void removeAllKey(int key) { if (this.head == null) { return; } ListNode prev = this.head; ListN...
NC23 划分链表（双指针）
weixin_46590256的博客
12-01 278
描述 给出一个长度为n的单链表和一个值，返回一个链表的头节点，要求新链表中小于x的节点全部在大于等于x的节点左侧，并且两部分之内的节点与原来的链表保持相对顺序不变。 例： 输入：{1,4,3,2,5,2},3 返回：{1,2,2,4,3,5} 要求：时间O(n),空间O(1) 解题思路 创建两个链表分别指向大于x和小于x class Solution { public: ListNode* partition(ListNode* head, int x) { if(!head||
给出一个长度为 n 的单链表和一个值 x ，单链表的每一个值为 listi ，请返回一个链表的头结点，要求新链表中小于 x 的节点全部在大于等于 x 的节点左侧，并且两个部分之内的节点之间与原来的链表
weixin_58879043的博客
03-17 928
import java.util.*; /* * public class ListNode { * int val; * ListNode next = null; * } */ public class Solution { /** * * @param head ListNode类 * @param x int整型 * @return ListNode类 */ public ListNode par...
C语言 单链表的简单操作
09-11
本文将深入探讨C语言中的单链表及其简单的操作，旨在帮助初学者理解并掌握这一概念。 单链表是一种线性数据结构，其中每个元素（称为节点）包含两部分：数据域和指针域。数据域存储实际的数据，而指针域存储指向下...
工程软件作业题目.doc
09-21
【工程软件作业题目.doc】 这份文档包含了多个关于数据结构和算法的实验题目，涉及了顺序表、单链表、双向循环链表、栈、队列、链栈、链队列、链表应用、稀疏矩阵压缩存储以及二叉树的创建与遍历等多个计算机科学中...
杭州电子科技大学数据结构(题目).pdf
最新发布
04-26
”进一步明确了这份资料的具体内容，即为数据结构课程的期末考试试题及其答案。 #### 二、是非题解析 1. **数据结构的定义**：数据结构可以被定义为一个三元组(D, S, P)，其中D表示数据对象，S表示这些数据对象...
数据结构题目及答案.doc
10-07
数据结构是计算机科学中的核心概念，它涉及如何有效...以上就是对数据结构相关问题的详细解答，涵盖了数组、队列、栈、链表、图、二叉树、哈夫曼树等重要概念及其操作。这些知识对于理解和解决实际的编程问题至关重要。
（每日一练c++）CC63 划分链表
m0_62396648的博客
05-15 332
描述 给出一个长度为 n的单链表和一个值 x，单链表的每一个值为 listi ，请返回一个链表的头结点，要求新链表中小于 x的节点全部在大于等于 x的节点左侧，并且两个部分之内的节点之间与原来的链表要保持相对顺序不变。 例如： 给出 1→4→3→2→5→2 1 \to 4 \to 3 \to 2 \to 5 \to 2 1→4→3→2→5→2 和 x=3 x = 3 x=3 返回 1→2→2→4→3→5 1 \to 2 \to 2 \to 4 \to 3 \to 5 1→2→2→4→3→...
【数据结构】单链表OJ
qq_61903414的博客
12-20 976
OJ链接：反转链表_牛客题霸_牛客网 (nowcoder.com)
链表专题
雪伦的专栏
07-23 1468
声明：部分试题、解决方案来自LeetCode，本文旨在学习1.数据结构普通的单链表及构造函数struct Node{ int val; Node* next; Node(int value,Node* n = NULL):val(value),next(n){}; };2.合并两个有序序列合并两个有序序列是合并K个有序序列的子问题Node* merge_two_sorted_
按照给定值划分链表
成功=坚持+努力+目标
09-23 182
描述：给出一个长度为 nn 的单链表和一个值 xx ，单链表的每一个值为 list[i]list[i]，请返回一个链表的头结点，要求新链表中小于 xx 的节点全部在大于等于 xx 的节点左侧，并且两个部分之内的节点之间与原来的链表要保持相对顺序不变。 例如： 给出 1→4→3→2→5→2 和 x=3 返回 1→2→2→4→3→5 复杂度要求： 时间 O(n) 空间 O(1) import java.util.*; /* * public class ListNode { * int val;
面向对象课程设计题目汇总及要求.pdf
10-01
1. **单链表（C级）**：实现单链表的基本操作，如插入、删除、遍历，理解链表数据结构及其操作。 2. **一元多项式求和（B级）**：设计一个类来表示多项式，支持加法运算，涉及对象的表示和运算方法的设计。 3. **...
c语言单链表求字符集合交,数据结构--C语言链表实现集合的（并，交，差）运算！...
weixin_42430341的博客
05-17 2024
数据结构--C语言链表实现集合的(并，交，差)运算！数据结构--C语言链表实现集合的(并，交，差)运算！老规矩，上效果图：要求：从程序完善性上考虑，集合元素输入时，要有检查元素重复的功能，每个集合中不允许有重复的元素。集合可以用数组也可以用链表存储。实现交、并、差运算时，分别把代码写成函数的形式，即实现交运算的函数，实现并运算的函数，实现差运算的函数，在主函数中分别调用三个函数。使用菜单形式对应各...
Leetcode 单链表题型总结
liaoshenglan的博客
09-07 311
Leetcode 单链表题型总结 自己刷题的一个小记录，难度从easy --> hard，持续更新中。若有更好的方法，欢迎评论区讨论呀。 876. 返回单链表的中间节点。如果有两个中间节点，返回第二个。 两种思路， 第一种是先遍历一遍，记录长度后，再遍历到一半。时间复杂度O(n) 第二种是用两个指针，一快一慢，快指针每次走两步，慢指针每次走一步，当快指针走到链表最后时，慢指针所指的就是中间节...
单链表 简单题（单链表基本操作）
菇凉小伙de博客
10-08 1326
题目描述： 有一个带头结点的单链表L=（a1,b1,a2,b2,......an,bn),设计一个算法将其拆分成两个带头结点的单链表L1和L2，其中L1=（a1,a2,a3...an),L2=(b1,b2,b3....bn),要求L1使用L的头结点。 解题思路： 利用原单链表L中的所有节点通过改变指针域重组成两个单链表L1和L2，由于L1中节点的相对顺序与L中的相同，所以采用尾插法建立单链表...
整形单链表
I will work my left life for my family
11-11 996
IntSLLNode.h#ifndef INT_SINGLY_LINKED_LIST_NODE #define INT_SINGLY_LINKED_LIST_NODE #include using namespace std; class IntSLLNode { public: // 无参，一个参，二个参都有构造函数。 IntSLLNode() { info =
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值