数据结构学习第二天＜反转链表＞＜链表删除节点＞＜栈和队列＞＜两个栈实现队列＞＜两个队列实现栈＞＜递归求最大值＞＜哈希表＞

已于 2022-06-09 09:57:31 修改
阅读量152 收藏
点赞数
文章标签： 数据结构 学习
于 2022-06-09 09:57:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/syd2820/article/details/125197757
版权

反转链表

package Demo02;
​
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) {
        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) {
        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!");
​
    }
​
}

链表删除节点

单向链表删除头结点后，head指向第二个时，即便头结点没有断连（只有1指向2，没有2指向1，2顺着能找到3，4...但找不到1），内存也会释放，C++不行（必须调用释放函数），双向链表则不会（2有指向1，能找到1）

package Demo02;
​
public class Code02_DeleteGivenValue {
    public static class Node {
        public int value;
        public Node next;
​
        public Node(int data) {
            this.value = data;
        }
    }
​
    public static Node removeValue(Node head, int num) {
        while (head != null) {
            if (head.value != num) {
                break;
            }
            head = head.next;
        }
        // head来到 第一个不需要删的位置
        Node pre = head;
        Node cur = head;
        //
        while (cur != null) {
            if (cur.value == num) {
                pre.next = cur.next;
            } else {
                pre = cur;
            }
            cur = cur.next;
        }
        return head;
    }
}

栈和队列

栈：先进后出

队列：先进先出

双向链表实现

package Demo02;
​
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
​
public class Code03_DoubleEndsQueueToStackAndQueue {
    public static class Node<T> {
        public T value;
        public Node<T> last;
        public Node<T> next;
​
        public Node(T data) {
            value = data;
        }
    }
​
    public static class DoubleEndsQueue<T> {
        public Node<T> head;
        public Node<T> tail;
​
        public void addFromHead(T value) {//头部加节点
            Node<T> cur = new Node<T>(value);
            if (head == null) {
                head = cur;
                tail = cur;
            } else {
                cur.next = head;
                head.last = cur;
                head = cur;
            }
        }
​
        public void addFromBottom(T value) {//尾部加节点
            Node<T> cur = new Node<T>(value);
            if (head == null) {
                head = cur;
                tail = cur;
            } else {
                cur.last = tail;
                tail.next = cur;
                tail = cur;
            }
        }
​
        public T popFromHead() {//头部弹出节点
            if (head == null) {
                return null;
            }
            Node<T> cur = head;
            if (head == tail) {
                head = null;
                tail = null;
            } else {
                head = head.next;
                cur.next = null;
                head.last = null;
            }
            return cur.value;
        }
​
        public T popFromBottom() {//尾部弹出节点
            if (head == null) {
                return null;
            }
            Node<T> cur = tail;
            if (head == tail) {
                head = null;
                tail = null;
            } else {
                tail = tail.last;
                tail.next = null;
                cur.last = null;
            }
            return cur.value;
        }
​
        public boolean isEmpty() {
            return head == null;
        }
​
    }
​
    public static class MyStack<T> {//栈
        private DoubleEndsQueue<T> queue;
​
        public MyStack() {
            queue = new DoubleEndsQueue<T>();
        }
​
        public void push(T value) {
            queue.addFromHead(value);
        }//头部压入
​
        public T pop() {
            return queue.popFromHead();
        }//头部弹出
​
        public boolean isEmpty() {
            return queue.isEmpty();
        }
​
    }
​
    public static class MyQueue<T> {//队列
        private DoubleEndsQueue<T> queue;
​
        public MyQueue() {
            queue = new DoubleEndsQueue<T>();
        }
​
        public void push(T value) {
            queue.addFromHead(value);
        }//头部压入
​
        public T poll() {
            return queue.popFromBottom();
        }//尾部弹出
​
        public boolean isEmpty() {
            return queue.isEmpty();
        }
​
    }
​
    public static boolean isEqual(Integer o1, Integer o2) {
        if (o1 == null && o2 != null) {
            return false;
        }
        if (o1 != null && o2 == null) {
            return false;
        }
        if (o1 == null && o2 == null) {
            return true;
        }
        return o1.equals(o2);
    }
​
    public static void main(String[] args) {
        int oneTestDataNum = 100;
        int value = 10000;
        int testTimes = 100000;
        for (int i = 0; i < testTimes; i++) {
            MyStack<Integer> myStack = new MyStack<>();
            MyQueue<Integer> myQueue = new MyQueue<>();
            Stack<Integer> stack = new Stack<>();
            Queue<Integer> queue = new LinkedList<>();
            for (int j = 0; j < oneTestDataNum; j++) {
                int nums = (int) (Math.random() * value);
                if (stack.isEmpty()) {
                    myStack.push(nums);
                    stack.push(nums);
                } else {
                    if (Math.random() < 0.5) {
                        myStack.push(nums);
                        stack.push(nums);
                    } else {
                        if (!isEqual(myStack.pop(), stack.pop())) {
                            System.out.println("oops!");
                        }
                    }
                }
                int numq = (int) (Math.random() * value);
                if (stack.isEmpty()) {
                    myQueue.push(numq);
                    queue.offer(numq);
                } else {
                    if (Math.random() < 0.5) {
                        myQueue.push(numq);
                        queue.offer(numq);
                    } else {
                        if (!isEqual(myQueue.poll(), queue.poll())) {
                            System.out.println("oops!");
                        }
                    }
                }
            }
        }
        System.out.println("finish!");
    }
}

数组实现（固定大小）

栈容易实现

package Demo02;
​
public class Code04_RingArray {
    public static class MyQueue {
        private int[] arr;
        private int pushi;
        private int polli;
        private int size;
        private final int limit;
​
        public MyQueue(int limit) {
            arr = new int[limit];
            pushi = 0;
            polli = 0;
            size = 0;
            this.limit = limit;
        }
​
        public void push(int value) {
            if (size == limit) {
                throw new RuntimeException("栈满了，不能再加了");
            }
            size++;
            arr[pushi] = value;
            pushi = nextIndex(pushi);
        }
​
        public int pop() {
            if (size == 0) {
                throw new RuntimeException("栈空了，不能再拿了");
            }
            size--;
            int ans = arr[polli];
            polli = nextIndex(polli);
            return ans;
        }
​
        public boolean isEmpty() {
            return size == 0;
        }
​
        // 如果现在的下标是i，返回下一个位置
        private int nextIndex(int i) {
            return i < limit - 1 ? i + 1 : 0;
        }
​
    }
​
}

在实现基本功能基础上再实现返回栈中最小元素

pop push getMin时间复杂度都是O（1）

package Demo02;
​
import java.util.Stack;
​
public class Code05_GetMinStack {
    public static class MyStack1 {
        private Stack<Integer> stackData;
        private Stack<Integer> stackMin;
​
        public MyStack1() {
            this.stackData = new Stack<Integer>();
            this.stackMin = new Stack<Integer>();
        }
​
        public void push(int newNum) {
            if (this.stackMin.isEmpty()) {
                this.stackMin.push(newNum);
            } else if (newNum <= this.getmin()) {//当前数小于等于最小栈栈顶，压入，否则不压入
                this.stackMin.push(newNum);
            }
            this.stackData.push(newNum);
        }
​
        public int pop() {
            if (this.stackData.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            int value = this.stackData.pop();
            if (value == this.getmin()) {
                this.stackMin.pop();
            }
            return value;
        }
​
        public int getmin() {
            if (this.stackMin.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            return this.stackMin.peek();
        }
    }
​
    public static class MyStack2 {
        private Stack<Integer> stackData;
        private Stack<Integer> stackMin;
​
        public MyStack2() {
            this.stackData = new Stack<Integer>();
            this.stackMin = new Stack<Integer>();
        }
​
        public void push(int newNum) {
            if (this.stackMin.isEmpty()) {
                this.stackMin.push(newNum);
            } else if (newNum < this.getmin()) {//当前的数小于最小栈的栈顶
                this.stackMin.push(newNum);//最小栈压入当前数
            } else {
                int newMin = this.stackMin.peek();//否则最小栈重复压入栈顶
                this.stackMin.push(newMin);
            }
            this.stackData.push(newNum);//Data栈正常压入
        }
​
        public int pop() {
            if (this.stackData.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            this.stackMin.pop();//弹出最小数
            return this.stackData.pop();//同步弹出Data栈顶
        }
​
        public int getmin() {
            if (this.stackMin.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            return this.stackMin.peek();
        }
    }
​
    public static void main(String[] args) {
        MyStack1 stack1 = new MyStack1();
        stack1.push(3);
        System.out.println(stack1.getmin());
        stack1.push(4);
        System.out.println(stack1.getmin());
        stack1.push(1);
        System.out.println(stack1.getmin());
        System.out.println(stack1.pop());
        System.out.println(stack1.getmin());
​
        System.out.println("=============");
​
        MyStack1 stack2 = new MyStack1();
        stack2.push(3);
        System.out.println(stack2.getmin());
        stack2.push(4);
        System.out.println(stack2.getmin());
        stack2.push(1);
        System.out.println(stack2.getmin());
        System.out.println(stack2.pop());
        System.out.println(stack2.getmin());
    }
}

两个栈实现队列

package Demo02;
​
import java.util.Stack;
​
public class Code06_TwoStacksImplementQueue {
    public static class TwoStacksQueue {
        public Stack<Integer> stackPush;
        public Stack<Integer> stackPop;
​
        public TwoStacksQueue() {
            stackPush = new Stack<Integer>();
            stackPop = new Stack<Integer>();
        }
​
        // push栈向pop栈倒入数据
        private void pushToPop() {
            if (stackPop.empty()) {//原则1 必须POP栈为空的时候
                while (!stackPush.empty()) {//原则2 Push栈一定要倒空才能停
                    stackPop.push(stackPush.pop());//一个进一个出
                }
            }
        }
​
        public void add(int pushInt) {
            stackPush.push(pushInt);
            pushToPop();//先看看能不能导，不妨碍
        }
​
        public int poll() {
            if (stackPop.empty() && stackPush.empty()) {
                throw new RuntimeException("Queue is empty!");
            }
            pushToPop();//先看看能不能导，不妨碍
            return stackPop.pop();
        }
​
        public int peek() {
            if (stackPop.empty() && stackPush.empty()) {
                throw new RuntimeException("Queue is empty!");
            }
            pushToPop();//先看看能不能导，不妨碍
            return stackPop.peek();
        }
    }
​
    public static void main(String[] args) {
        TwoStacksQueue test = new TwoStacksQueue();
        test.add(1);
        test.add(2);
        test.add(3);
        System.out.println(test.peek());
        System.out.println(test.poll());
        System.out.println(test.peek());
        System.out.println(test.poll());
        System.out.println(test.peek());
        System.out.println(test.poll());
    }
}

两个队列实现栈

package Demo02;
​
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
​
public class Code07_TwoQueueImplementStack {
    public static class TwoQueueStack<T> {
        public Queue<T> queue;
        public Queue<T> help;
​
        public TwoQueueStack() {
            queue = new LinkedList<>();
            help = new LinkedList<>();
        }
​
        public void push(T value) {
            queue.offer(value);
        }
​
        public T poll() {
            while (queue.size() > 1) {
                help.offer(queue.poll());
            }
            T ans = queue.poll();
            Queue<T> tmp = queue;
            queue = help;
            help = tmp;
            return ans;
        }
​
        public T peek() {
            while (queue.size() > 1) {
                help.offer(queue.poll());
            }
            T ans = queue.poll();
            help.offer(ans);
            Queue<T> tmp = queue;
            queue = help;
            help = tmp;
            return ans;
        }
​
        public boolean isEmpty() {
            return queue.isEmpty();
        }
​
    }
​
    public static void main(String[] args) {
        System.out.println("test begin");
        TwoQueueStack<Integer> myStack = new TwoQueueStack<>();
        Stack<Integer> test = new Stack<>();
        int testTime = 1000000;
        int max = 1000000;
        for (int i = 0; i < testTime; i++) {
            if (myStack.isEmpty()) {
                if (!test.isEmpty()) {
                    System.out.println("Oops");
                }
                int num = (int) (Math.random() * max);
                myStack.push(num);
                test.push(num);
            } else {
                if (Math.random() < 0.25) {
                    int num = (int) (Math.random() * max);
                    myStack.push(num);
                    test.push(num);
                } else if (Math.random() < 0.5) {
                    if (!myStack.peek().equals(test.peek())) {
                        System.out.println("Oops");
                    }
                } else if (Math.random() < 0.75) {
                    if (!myStack.poll().equals(test.pop())) {
                        System.out.println("Oops");
                    }
                } else {
                    if (myStack.isEmpty() != test.isEmpty()) {
                        System.out.println("Oops");
                    }
                }
            }
        }
​
        System.out.println("test finish!");
​
    }
}

递归求最大值

复杂度：T(N)=a*T(N/b)+O(N^d)

a子函数个数 b几分 d剩下行为复杂度因子

1.log b a >d O(N^log b a)

2.log b a <d O(N^d) 常见a=b O(1)

3.log b a =d O(N^d *log N)

package Demo02;
​
public class Code08_GetMax {
    // 求arr中的最大值
    public static int getMax(int[] arr) {
        return process(arr, 0, arr.length - 1);
    }
​
    // arr[L..R]范围上求最大值  L ... R   N
    public static int process(int[] arr, int L, int R) {
        if (L == R) { // arr[L..R]范围上只有一个数，直接返回，base case
            return arr[L];
        }
        int mid = L + ((R - L) >> 1); // 中点    1
        int leftMax = process(arr, L, mid);
        int rightMax = process(arr, mid + 1, R);
        return Math.max(leftMax, rightMax);
    }
}

哈希表

package Demo02;
​
import java.util.HashMap;
import java.util.HashSet;
import java.util.TreeMap;
​
public class HashMapAndSortedMap {
​
        public static class Node{
            public int value;
            public Node(int v) {
                value = v;
            }
        }
​
        public static void main(String[] args) {
            // UnSortedMap C++里的哈希表
            HashMap<Integer, String> map = new HashMap<>();//K-V
            map.put(1000000, "我是1000000");
            map.put(2, "我是2");
            map.put(3, "我是3");
            map.put(4, "我是4");
            map.put(5, "我是5");
            map.put(6, "我是6");
            map.put(1000000, "我是1000001");
​
            System.out.println(map.containsKey(1));//有无加入1的记录
            System.out.println(map.containsKey(10));
​
            System.out.println(map.get(4));//查Value
            System.out.println(map.get(10));//无记录返回null
​
            map.put(4, "他是4");//更新V
            System.out.println(map.get(4));
​
            map.remove(4);//除去
            System.out.println(map.get(4));//null
​
​
​
            //       key
            HashSet<String> set = new HashSet<>();
            set.add("abc");
            set.contains("abc");//是否存在
            set.remove("abc");
​
            // 哈希表，增、删、改、查，在使用时，复杂度O（1）
​
​
            System.out.println("=====================");
​
​
            int a = 100000;
            int b = 100000;
            System.out.println(a == b);
​
            Integer c = 100000;
            Integer d = 100000;
            System.out.println(c.equals(d));//==引用传递 equal比较值
​
            Integer e = 127;  //  - 128  ~  127 此范围内是值传递
            Integer f = 127;
            System.out.println(e == f);
​
            //哈西表里一律值传递
​
            HashMap<Node, String> map2 = new HashMap<>();
            Node node1 = new Node(1);
            Node node2 = node1;
            map2.put(node1, "我是node1");
            map2.put(node2, "我是node1");
            System.out.println(map2.size());//1  非基础类型K 引用传递
​
            System.out.println("======================");
            //有序表（按序组织）
            TreeMap<Integer, String> treeMap = new TreeMap<>();
​
            treeMap.put(3, "我是3");
            treeMap.put(4, "我是4");
            treeMap.put(8, "我是8");
            treeMap.put(5, "我是5");
            treeMap.put(7, "我是7");
            treeMap.put(1, "我是1");
            treeMap.put(2, "我是2");
​
            System.out.println(treeMap.containsKey(1));
            System.out.println(treeMap.containsKey(10));
​
            System.out.println(treeMap.get(4));
            System.out.println(treeMap.get(10));
​
            treeMap.put(4, "他是4");
            System.out.println(treeMap.get(4));
​
            treeMap.remove(4);
            System.out.println(treeMap.get(4));
​
            System.out.println(treeMap.firstKey());//最小的K
            System.out.println(treeMap.lastKey());
            // <= 4
            System.out.println(treeMap.floorKey(4));//<=4 离4最近的K
            // >= 4
            System.out.println(treeMap.ceilingKey(4));//>=4 离4最近的K
​
            // O(logN)
​
        }
    }
syd2820
关注
Java数据结构之链表、栈、队列、树的实现方法示例
08-26
"Java数据结构之链表、栈、队列、树的实现方法示例" 在计算机科学中，数据结构是一种组织和存储数据的方式，以便实现高效的数据存取和处理。Java数据结构中常用的数据结构有链表、栈、队列、树等，本文将详细介绍...
数据结构算法集---C++语言实现.rar_queue stack_堆栈 栈_数据结构 队列_链表_队列
07-15
总的来说，这个C++数据结构算法集提供了对基本数据结构和算法的实现，包括堆栈、队列和链表，这对于学习和理解数据结构及其在实际编程中的应用非常有帮助。掌握这些基础知识将有助于提升编程能力，解决更复杂的问题...
数组、链表、队列、栈数据结构特点，各自优点和缺点 数组和链表.pdf
04-18
数组、链表、队列、栈数据结构特点，各自优点和缺点 在计算机科学中，数据结构是指用于组织和存储数据的方式。常见的数据结构包括数组、链表、队列、栈等。每种数据结构都有其特点、优点和缺点，本文将对这些数据...
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
链表-使用Python基于链表实现队列数据结构.zip
03-13
总的来说，理解链表和如何使用链表实现队列对于深入学习数据结构和算法至关重要。通过实践和实现这些基本概念，可以更好地理解和运用它们，从而提高代码的效率和可维护性。在Python中，虽然有许多内置的工具可以方便...
数据结构-二叉树及其遍历
宁zz的博客
11-15 676
本篇文章咱们聊聊数据结构中的树，准确的说因该是只说一说二叉树以及相关的三种递归遍历、三种非递归遍历以及层次遍历。🍃二叉树 (BinaryTree) 是 n (n>0) 个结点所构成的集合，它或为空树(n-0)或为非空树，对于非空树(1) 有且仅有一个称之为根的结点:(2) 除根结点以外的其余结点分为两个互不相交的子集 TI 和 T2，分别称为 T 的左子树和右子树，且 T1 和 T2 本身又都是二叉树。🍃二叉树与树一样具有递归性质，二叉树与树的区别。
华为OD机试真题---数组二叉树
风信子的博客
11-13 1078
二叉树只也可以用数组来存储，给定一个数组，树的根节点的值储存在下标1，对于储存在下标n的节点，他的左子节点和右子节点分别储存在下标2n和2n+1，并且我们用-1代表一个节点为空，给定一个数组存储的二叉树，试求从根节点到最小的 叶子节点只的路径，路径由节点的值组成。
排序算法 -计数排序
qq_46538985的博客
11-16 541
计数排序
数据结构——AVL树
未知陨落的博客
11-16 1093
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查 找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii 和E.M.Landis在1962年 发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度
【数据结构】快排之三路划分
2301_79633555的博客
11-13 405
在之前快排是排完序把key放在中间，左边比key值小，右边比key大，跟key相等的值在哪里并没有规定，跟key相等的值可以在左边，也可以在右边。因为假如cur没有遇见比key大的值，right没有--，那么cur与right在相同位置时，并不能确定right所指向的值是否小于key。但是，有些场景下hoae和lomuto（前后指针法）还是适应的不是很好，就是当数组中有大量重复数据时，该场景下性能是有些退化的。cur指向的值与left位置的值进行交换，然后left++，cur++核心思想是把数组中的数据。
【数据结构】10.线索二叉树
caryon的博客
11-13 850
介绍了线索二叉树的背景与实现
数据结构(初阶4)---循环队列详解
Mr_vantasy的博客
11-12 1108
c语言实现 循环队列，循环队列的疑点解析(๑ơ ₃ ơ)♥
数据结构《栈和队列》
weixin_74772041的博客
11-16 364
有关数据结构中的栈和队列的相关内容，以及它们的简单实现，和简单使用。
《数据结构》--二叉树【下】
Stark的博客
11-12 422
在节点结构中加入层号属性。结果容器由vector：res改为multimap：m。输出时，输出m.first和m.second即可将层号和节点值同时打印出来。最简单的方法就是在上面的基础上，输出m的最后一个元素的first属性值。在 二 的基础上，输出时，如果m.first == i,输出。二叉树满度也就是节点的度为2。也就是左右孩子都存在。分支节点是度不为0的节点。也就是有孩子节点存在。叶子节点是度为0的节点。也就是没有孩子节点。或者将代码改为：（插入时直接判断）
数据结构C语言描述3(图文结合)--双链表、循环链表、约瑟夫环问题
weixin_74085818的博客
11-16 1117
🚡 双向链表，对比单链表来说，顾名思义，就是指向指向有两个指针，指向前后节点。🌾 结合单链表，单链表有无头和有头之分，双向链表也是一样，这里是无头双链表，采用再封装写法，不是二级指针写法再封装写法比较写起来比较容易，个人比较偏爱🤠🤠🤠🤠双链表图示：总结起来一句话：增删改查增加元素删除元素拿取元素查询元素修改元素…………………………
数据结构：选择排序
最新发布
qincjun的博客
11-16 144
【代码】数据结构：选择排序。
排序排序的概念及其运用和选择排序
m0_73693552的博客
11-13 933
排序算法的概念，选择排序，交换数据的技巧
C++图解数据结构(基于SDL2)之MyTree
嵇康的专栏
11-16 283
点击界面,随机生成节点,然后按下鼠标左键,第一次点击起点,第二次点击终点,就会简历一条路径,从起点指向第二个点,并挂在根节点上(这里我第一点击生成的为41,41就为根节点)std::vector<MyNode*> vertices;addEdge+invertTree+hasPathSum(75)综合效果。// DFS前序遍历并动态显示遍历过程。// 获取鼠标点击位置的节点索引。// 绘制二叉树节点及其连接线。// 二叉树节点定义。
数据结构-哈夫曼树
wwwwwgery的博客
11-10 541
不同搜索树的效率是不一样的,根据不同的频率构造效率比较好或者最好的搜索树就是哈夫曼树将带权路径的长度降低最低每个叶子节点到根节点的距离乘权值，再全都加起来就得到了WPL值第一颗二叉树:从上到下计算 5x1+4x2+3x3+2x4+1x4=34第二颗二叉树:从上到下计算 1x1+2x2+3x3+4x4+5x4=50第二颗二叉树:从上到下计算 1x3+2x3+3x2+4x2+5x2=33哈夫曼树为了构造一个树WPL最小。
Java数据结构详解：链表、栈、队列与树实现详解
本文将深入探讨Java编程语言中四种基本数据结构：链表、栈、队列和树的实现方法。首先，我们从链表开始，它是一种线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的引用。节点定义的关键在于`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值