算法数据结构体系学习 第九节

最新推荐文章于 2024-09-27 11:17:47 发布
最新推荐文章于 2024-09-27 11:17:47 发布
阅读量81 收藏
点赞数
分类专栏： 算法数据结构体系学习 文章标签： 算法 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29374433/article/details/126186199
版权

排序算法总结

排序算法时间复杂度额外空间复杂度稳定性
选择排序O(N^2)O(1)无
冒泡排序O(N^2)O(1)有
插入排序O(N^2)O(1)有
归并排序O(N*logN)O(N)有
随机快排O(N*logN)O(logN)无
堆排序O(N*logN)O(1)无
计数排序O(N)O(M)有
基数排序O(N)O(N)有

1）不基于比较的排序，对样本数据有严格要求，不易改写
2）基于比较的排序，只要规定好两个样本怎么比大小就可以直接复用
3）基于比较的排序，时间复杂度的极限是O(NlogN)
4）时间复杂度O(NlogN)、额外空间复杂度低于O(N)、且稳定的基于比较的排序是不存在的。
5）为了绝对的速度选快排、为了省空间选堆排、为了稳定性选归并

常见的坑

1）归并排序的额外空间复杂度可以变成O(1)，“归并排序 内部缓存法”，但是将变得不再稳定。
2）“原地归并排序" 是垃圾贴，会让时间复杂度变成O(N^2)
3）快速排序稳定性改进，“01 stable sort”，但是会对样本数据要求更多。

在整型数组中，请把奇数放在数组左边，偶数放在数组右边，要求所有奇数之间原始的相对次序不变，所有偶数之间原始相对次序不变。
时间复杂度做到O(N)，额外空间复杂度做到O(1)

工程上对排序的改进

1)稳定性的考虑
2)充分利用O(N*logN)和O(N^2)排序各自的优势

链表问题

面试时链表解题的方法论

1)对于笔试，不用太在乎空间复杂度，一切为了时间复杂度

2)对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法

链表面试题常用数据结构和技巧

1）使用容器(哈希表、数组等)
2）快慢指针

快慢指针

1）输入链表头节点，奇数长度返回中点，偶数长度返回上中点
2）输入链表头节点，奇数长度返回中点，偶数长度返回下中点
3）输入链表头节点，奇数长度返回中点前一个，偶数长度返回上中点前一个
4）输入链表头节点，奇数长度返回中点前一个，偶数长度返回下中点前一个

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

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


    // head 头
    public static Node midOrUpMidNode(Node head) {
        if(head==null||head.next==null||head.next.next==null){
            return head;
        }
        Node slow=head.next;
        Node quick=head.next.next;
        while (quick.next!=null&&quick.next.next!=null){
            slow=slow.next;
            quick=quick.next.next;
        }
        return slow;
    }

    public static Node midOrDownMidNode(Node head) {
        if(head==null||head.next==null){
            return head;
        }
        Node slow=head.next;
        Node quick=head.next;
        while (quick.next!=null&&quick.next.next!=null){
            slow=slow.next;
            quick=quick.next.next;
        }
        return slow;
    }

    public static Node midOrUpMidPreNode(Node head) {
        if(head==null||head.next==null||head.next.next==null){
            return head;
        }
        Node slow=head.next;
        Node quick=head.next.next;
        while (quick.next!=null&&quick.next.next!=null){
            slow=slow.next;
            quick=quick.next.next;
        }
        return slow;
    }

    public static Node midOrDownMidPreNode(Node head) {
        if(head==null||head.next==null){
            return head;
        }
        Node slow=head;
        Node quick=head.next;
        while (quick.next!=null&&quick.next.next!=null){
            slow=slow.next;
            quick=quick.next.next;
        }
        return slow;
    }

    public static Node right1(Node head) {
        if (head == null) {
            return null;
        }
        Node cur = head;
        ArrayList<Node> arr = new ArrayList<>();
        while (cur != null) {
            arr.add(cur);
            cur = cur.next;
        }
        return arr.get((arr.size() - 1) / 2);
    }

    public static Node right2(Node head) {
        if (head == null) {
            return null;
        }
        Node cur = head;
        ArrayList<Node> arr = new ArrayList<>();
        while (cur != null) {
            arr.add(cur);
            cur = cur.next;
        }
        return arr.get(arr.size() / 2);
    }

    public static Node right3(Node head) {
        if (head == null || head.next == null || head.next.next == null) {
            return null;
        }
        Node cur = head;
        ArrayList<Node> arr = new ArrayList<>();
        while (cur != null) {
            arr.add(cur);
            cur = cur.next;
        }
        return arr.get((arr.size() - 3) / 2);
    }

    public static Node right4(Node head) {
        if (head == null || head.next == null) {
            return null;
        }
        Node cur = head;
        ArrayList<Node> arr = new ArrayList<>();
        while (cur != null) {
            arr.add(cur);
            cur = cur.next;
        }
        return arr.get((arr.size() - 2) / 2);
    }

    public static void main(String[] args) {
        Node test = null;
        test = new Node(0);
        test.next = new Node(1);
        test.next.next = new Node(2);
        test.next.next.next = new Node(3);
        test.next.next.next.next = new Node(4);
        test.next.next.next.next.next = new Node(5);
        test.next.next.next.next.next.next = new Node(6);
        test.next.next.next.next.next.next.next = new Node(7);
        test.next.next.next.next.next.next.next.next = new Node(8);

        Node ans1 = null;
        Node ans2 = null;

        ans1 = midOrUpMidNode(test);
        ans2 = right1(test);
        System.out.println(ans1 != null ? ans1.value : "无");
        System.out.println(ans2 != null ? ans2.value : "无");

        ans1 = midOrDownMidNode(test);
        ans2 = right2(test);
        System.out.println(ans1 != null ? ans1.value : "无");
        System.out.println(ans2 != null ? ans2.value : "无");

        ans1 = midOrUpMidPreNode(test);
        ans2 = right3(test);
        System.out.println(ans1 != null ? ans1.value : "无");
        System.out.println(ans2 != null ? ans2.value : "无");

        ans1 = midOrDownMidPreNode(test);
        ans2 = right4(test);
        System.out.println(ans1 != null ? ans1.value : "无");
        System.out.println(ans2 != null ? ans2.value : "无");

    }

给定一个单链表的头节点head，请判断该链表是否为回文结构。

1）哈希表方法特别简单（笔试用）

2）改原链表的方法就需要注意边界了（面试用）

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

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

	// need n extra space
	public static boolean isPalindrome1(Node head) {
		Stack<Node> stack = new Stack<Node>();
		Node cur = head;
		while (cur != null) {
			stack.push(cur);
			cur = cur.next;
		}
		while (head != null) {
			if (head.value != stack.pop().value) {
				return false;
			}
			head = head.next;
		}
		return true;
	}

	// need n/2 extra space
	public static boolean isPalindrome2(Node head) {
		if (head == null || head.next == null) {
			return true;
		}
		Node right = head.next;
		Node cur = head;
		while (cur.next != null && cur.next.next != null) {
			right = right.next;
			cur = cur.next.next;
		}
		Stack<Node> stack = new Stack<Node>();
		while (right != null) {
			stack.push(right);
			right = right.next;
		}
		while (!stack.isEmpty()) {
			if (head.value != stack.pop().value) {
				return false;
			}
			head = head.next;
		}
		return true;
	}

	// need O(1) extra space
	public static boolean isPalindrome3(Node head) {
		if (head == null || head.next == null) {
			return true;
		}
		Node n1 = head;
		Node n2 = head;
		while (n2.next != null && n2.next.next != null) { // find mid node
			n1 = n1.next; // n1 -> mid
			n2 = n2.next.next; // n2 -> end
		}
		// n1 中点
		
		
		n2 = n1.next; // n2 -> right part first node
		n1.next = null; // mid.next -> null
		Node n3 = null;
		while (n2 != null) { // right part convert
			n3 = n2.next; // n3 -> save next node
			n2.next = n1; // next of right node convert
			n1 = n2; // n1 move
			n2 = n3; // n2 move
		}
		n3 = n1; // n3 -> save last node
		n2 = head;// n2 -> left first node
		boolean res = true;
		while (n1 != null && n2 != null) { // check palindrome
			if (n1.value != n2.value) {
				res = false;
				break;
			}
			n1 = n1.next; // left to mid
			n2 = n2.next; // right to mid
		}
		n1 = n3.next;
		n3.next = null;
		while (n1 != null) { // recover list
			n2 = n1.next;
			n1.next = n3;
			n3 = n1;
			n1 = n2;
		}
		return res;
	}

	public static void printLinkedList(Node node) {
		System.out.print("Linked List: ");
		while (node != null) {
			System.out.print(node.value + " ");
			node = node.next;
		}
		System.out.println();
	}

	public static void main(String[] args) {

		Node head = null;
		printLinkedList(head);
		System.out.print(isPalindrome1(head) + " | ");
		System.out.print(isPalindrome2(head) + " | ");
		System.out.println(isPalindrome3(head) + " | ");
		printLinkedList(head);
		System.out.println("=========================");

		head = new Node(1);
		printLinkedList(head);
		System.out.print(isPalindrome1(head) + " | ");
		System.out.print(isPalindrome2(head) + " | ");
		System.out.println(isPalindrome3(head) + " | ");
		printLinkedList(head);
		System.out.println("=========================");

		head = new Node(1);
		head.next = new Node(2);
		printLinkedList(head);
		System.out.print(isPalindrome1(head) + " | ");
		System.out.print(isPalindrome2(head) + " | ");
		System.out.println(isPalindrome3(head) + " | ");
		printLinkedList(head);
		System.out.println("=========================");

		head = new Node(1);
		head.next = new Node(1);
		printLinkedList(head);
		System.out.print(isPalindrome1(head) + " | ");
		System.out.print(isPalindrome2(head) + " | ");
		System.out.println(isPalindrome3(head) + " | ");
		printLinkedList(head);
		System.out.println("=========================");

		head = new Node(1);
		head.next = new Node(2);
		head.next.next = new Node(3);
		printLinkedList(head);
		System.out.print(isPalindrome1(head) + " | ");
		System.out.print(isPalindrome2(head) + " | ");
		System.out.println(isPalindrome3(head) + " | ");
		printLinkedList(head);
		System.out.println("=========================");

		head = new Node(1);
		head.next = new Node(2);
		head.next.next = new Node(1);
		printLinkedList(head);
		System.out.print(isPalindrome1(head) + " | ");
		System.out.print(isPalindrome2(head) + " | ");
		System.out.println(isPalindrome3(head) + " | ");
		printLinkedList(head);
		System.out.println("=========================");

		head = new Node(1);
		head.next = new Node(2);
		head.next.next = new Node(3);
		head.next.next.next = new Node(1);
		printLinkedList(head);
		System.out.print(isPalindrome1(head) + " | ");
		System.out.print(isPalindrome2(head) + " | ");
		System.out.println(isPalindrome3(head) + " | ");
		printLinkedList(head);
		System.out.println("=========================");

		head = new Node(1);
		head.next = new Node(2);
		head.next.next = new Node(2);
		head.next.next.next = new Node(1);
		printLinkedList(head);
		System.out.print(isPalindrome1(head) + " | ");
		System.out.print(isPalindrome2(head) + " | ");
		System.out.println(isPalindrome3(head) + " | ");
		printLinkedList(head);
		System.out.println("=========================");

		head = new Node(1);
		head.next = new Node(2);
		head.next.next = new Node(3);
		head.next.next.next = new Node(2);
		head.next.next.next.next = new Node(1);
		printLinkedList(head);
		System.out.print(isPalindrome1(head) + " | ");
		System.out.print(isPalindrome2(head) + " | ");
		System.out.println(isPalindrome3(head) + " | ");
		printLinkedList(head);
		System.out.println("=========================");

	}

将单向链表按某值划分成左边小、中间相等、右边大的形式

1）把链表放入数组里，在数组上做partition（笔试用）

2）分成小、中、大三部分，再把各个部分之间串起来（面试用）

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

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

	public static Node listPartition1(Node head, int pivot) {
		if (head == null) {
			return head;
		}
		Node cur = head;
		int i = 0;
		while (cur != null) {
			i++;
			cur = cur.next;
		}
		Node[] nodeArr = new Node[i];
		i = 0;
		cur = head;
		for (i = 0; i != nodeArr.length; i++) {
			nodeArr[i] = cur;
			cur = cur.next;
		}
		arrPartition(nodeArr, pivot);
		for (i = 1; i != nodeArr.length; i++) {
			nodeArr[i - 1].next = nodeArr[i];
		}
		nodeArr[i - 1].next = null;
		return nodeArr[0];
	}

	public static void arrPartition(Node[] nodeArr, int pivot) {
		int small = -1;
		int big = nodeArr.length;
		int index = 0;
		while (index != big) {
			if (nodeArr[index].value < pivot) {
				swap(nodeArr, ++small, index++);
			} else if (nodeArr[index].value == pivot) {
				index++;
			} else {
				swap(nodeArr, --big, index);
			}
		}
	}

	public static void swap(Node[] nodeArr, int a, int b) {
		Node tmp = nodeArr[a];
		nodeArr[a] = nodeArr[b];
		nodeArr[b] = tmp;
	}

	public static Node listPartition2(Node head, int pivot) {
		Node sH = null; // small head
		Node sT = null; // small tail
		Node eH = null; // equal head
		Node eT = null; // equal tail
		Node mH = null; // big head
		Node mT = null; // big tail
		Node next = null; // save next node
		// every node distributed to three lists
		while (head != null) {
			next = head.next;
			head.next = null;
			if (head.value < pivot) {
				if (sH == null) {
					sH = head;
					sT = head;
				} else {
					sT.next = head;
					sT = head;
				}
			} else if (head.value == pivot) {
				if (eH == null) {
					eH = head;
					eT = head;
				} else {
					eT.next = head;
					eT = head;
				}
			} else {
				if (mH == null) {
					mH = head;
					mT = head;
				} else {
					mT.next = head;
					mT = head;
				}
			}
			head = next;
		}
		// 小于区域的尾巴，连等于区域的头，等于区域的尾巴连大于区域的头
		if (sT != null) { // 如果有小于区域
			sT.next = eH;
			eT = eT == null ? sT : eT; // 下一步，谁去连大于区域的头，谁就变成eT
		}
		// 下一步，一定是需要用eT 去接 大于区域的头
		// 有等于区域，eT -> 等于区域的尾结点
		// 无等于区域，eT -> 小于区域的尾结点
		// eT 尽量不为空的尾巴节点
		if (eT != null) { // 如果小于区域和等于区域，不是都没有
			eT.next = mH;
		}
		return sH != null ? sH : (eH != null ? eH : mH);
	}

	public static void printLinkedList(Node node) {
		System.out.print("Linked List: ");
		while (node != null) {
			System.out.print(node.value + " ");
			node = node.next;
		}
		System.out.println();
	}

	public static void main(String[] args) {
		Node head1 = new Node(7);
		head1.next = new Node(9);
		head1.next.next = new Node(1);
		head1.next.next.next = new Node(8);
		head1.next.next.next.next = new Node(5);
		head1.next.next.next.next.next = new Node(2);
		head1.next.next.next.next.next.next = new Node(5);
		printLinkedList(head1);
		// head1 = listPartition1(head1, 4);
		head1 = listPartition2(head1, 5);
		printLinkedList(head1);

	}

一种特殊的单链表节点类描述如下

class Node {
int value;
Node next;
Node rand;
Node(int val) { value = val; }
}
rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节点，也可能指向null。
给定一个由Node节点类型组成的无环单链表的头节点 head，请实现一个函数完成这个链表的复制，并返回复制的新链表的头节点。
【要求】
时间复杂度O(N)，额外空间复杂度O(1)

    public static class Node {
        int val;
        Node next;
        Node random;

        public Node(int val) {
            this.val = val;
            this.next = null;
            this.random = null;
        }
    }

    public static Node copyRandomList1(Node head) {
        Map<Node,Node> map=new HashMap<>();
        Node cur=head;
        while (cur!=null){
            map.put(cur,new Node(cur.val));
            cur=cur.next;
        }
        cur=head;
        while (cur!=null){
            map.get(cur).next=map.get(cur.next);
            map.get(cur).random=map.get(cur.random);
            cur=cur.next;
        }
        return map.get(head);
    }

    public static Node copyRandomList2(Node head) {
        if (head == null) {
            return null;
        }
        Node cur = head;
        Node next = null;
        // 1 -> 2 -> 3 -> null
        // 1 -> 1' -> 2 -> 2' -> 3 -> 3'
        while (cur != null) {
            next=cur.next;
            cur.next=new Node(cur.val);
            cur.next.next=next;
            cur=next;
        }
        cur = head;
        Node copy = null;
        // 1 1' 2 2' 3 3'
        // 依次设置 1' 2' 3' random指针
        while (cur != null) {
            next=cur.next.next;
            copy=cur.next;
            copy.random=cur.random!=null?cur.random.next:null;
            cur=next;
        }
        Node res = head.next;
        cur = head;
        while (cur!=null){
            next=cur.next.next;
            copy=cur.next;
            cur.next=next;
            copy.next=next==null?next.next:null;
            cur=next;
        }
        return res;
    }
以前你的名字
关注
专栏目录
数据结构与算法面试题80道
m0_54854484的博客
05-27 8867
1.把二元查找树转变成排序的双向链表 题目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 10 / \ 6 14 / \ / \ 4 8 12 16 转换成双向链表 4=6=8=10=12=14=16。 首先我们定义的二元查找树 节点的数据结构如下： struct BSTreeNode{int m_nValue; // value of nodeBSTreeNode *m_pLeft; // left child of nodeBSTreeNo
数据结构与算法 Python语言描述
04-19
根据给定文件的信息，我们...通过上述知识点的梳理，可以看出《数据结构与算法：Python语言描述》是一本内容全面、实践性强的数据结构教材，旨在帮助学习者建立扎实的数据结构基础，并掌握高效的算法设计与实现能力。
java实现单链表NodeList
quarkx的博客
11-17 1496
Java实现 单链表 NodeLIst 定义多种方法
C语言链表之单链表
weixin_60964305的博客
11-15 1744
1.什么是链表 链表是由一个个结点链接而成的，它和数组有一点相似，但和数组又有不同数组的内存段是连续的，而链表的内存段是一段一段的，不连续的 2.结点的组成 结点分为两个部分：数据域和指针域 数据域用来存放数据，指针域用来指向下一个数据域 3.结点是如何连接成链表的 我们先来创建四个结点，如图 这是四个结点，下面来看一下它们是如何连接的： 原本这四个结点的指针域都是指向NULL的，这是为了防止指针成为野指针，如图： 当它们连接成链表的时候，除了最后一个结点的指...
C语言链表操作功能实现详解心得
h674174380的博客
07-16 688
C语言链表操作功能实现详解心得
算法数据结构（九）----链表
u011624267的博客
07-28 108
面试时链表解题方法论 1)对于笔试，不用太在乎空间复杂度，一切为了时间复杂度 2)对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法 链表面试题常用数据结构和技巧 1）使用容器(哈希表、数组等) 2）快慢指针 快慢指针求解 1）输入链表头节点，奇数长度返回中点，偶数长度返回上中点 2）输入链表头节点，奇数长度返回中点，偶数长度返回下中点 3）输入链表头节点，奇数长度返回中点前一个，偶数长度返回上中点前一个 4）输入链表头节点，奇数长度返回中点前一个，偶数长度..
链表基本操作(学习笔记)
Pichairen
11-14 532
一、节点类的构造函数 函数原型： node(const value_type&amp; init_data = value_type(), node* init_link = NULL); 构造函数的第一个参数是传递到数据域的引用参数，第二个参数是一个指向节点的指针 函数实现： node(const value_type&amp; init_data = value_type()...
数据结构与算法——知识点总结
记录知识，学习分享
06-02 2万+
本文包含数据结构与算法主要的基本知识点，便于知识的梳理和回顾。 如需详细了解具体知识点请自行结合课本或者网上查阅。 目录 1、概述 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 1、概述 从 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 ...
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
热门推荐
chongyang_的博客
11-07 27万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
算法与数据结构体系课学习记录
weixin_43819429的博客
04-08 593
算法与数据结构体系课学习记录 前言 慕课上的波波老师的算法与数据结构体系课的学习记录，记录一下学习的过程。刚看完了第一周觉得还是很基础，内容比较少，不知道后面会不会渐渐的高能起来。第二周的算法也很简单，但是波波老师的代码风格很舒服 课程主要内容 课程章节 第1周 线性查找法 第2周 排序基础 第3周 数据结构基础：动态数组，栈和队列 第4周 动态数据结构基础：链表 第5周 归并排序法 第6周 快速排序法 第7周 二分查找法 第8周 二分搜索树 第9周 堆，优先队列和堆排序 第10周 冒
数据结构与算法01：绪论【LEARN FROM 李春葆《数据结构教程》】
是谢添啊
09-11 3057
数据：所有能够输入到计算机中，且能被计算机处理的符号的集合。数据结构中主要讨论结构化数据。数据元素：是数据（集合）中的一个“个体”，它是数据的基本单位。数据项：数据项是用来描述数据元素的，它是数据的最小单位。数据对象：具有相同性质的若干个数据元素的集合，如整数数据对象是所有整数的集合。默认情况下，数据结构中讨论的数据都是数据对象。数据结构。
数据挖掘 机器学习原理与SPSS Clementine应用宝典 第13章 遗传算法 共25页.ppt
07-10
数据挖掘 机器学习原理与SPSS Clementine应用宝典 第9章 决策树算法.ppt 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第10章 关联规则.ppt 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第11章 粗糙集理论....
数据挖掘 机器学习原理与SPSS Clementine应用宝典 第3章 数据挖掘的体系结构与模型.pdf
07-10
数据挖掘 机器学习原理与SPSS Clementine应用宝典 第9章 决策树算法.ppt 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第10章 关联规则.ppt 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第11章 粗糙集理论....
数据结构与算法基础课程 C语言C++程序语言设计教程 4_1串 共18页.pptx
07-20
### 数据结构与算法基础课程知识点概述 #### 一、课程概览 该课程是一门针对C语言和C++编程语言的数据结构与...在后续的学习过程中，学生还将接触到更多复杂的数据结构和算法，逐步构建起完整的计算机科学知识体系。
数据挖掘 机器学习原理与SPSS Clementine应用宝典 第9章 决策树算法 共67页.ppt
07-10
数据挖掘 机器学习原理与SPSS Clementine应用宝典 第9章 决策树算法.ppt 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第10章 关联规则.ppt 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第11章 粗糙集理论....
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 469
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
使用Python实现图形学的纹理映射算法
最新发布
qq_42568323的博客
09-27 1109
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
【算法】贪心+堆排序实现大根堆及标准库容器类的融合使用
2301_77954967的博客
09-25 1737
先看题这个算法，是要通过循环找到所有元素中最大的那个偶元素，对其除以2，然后再找这之后的最大的那个偶元素以此类推笔者的经历不多，第一次做的时候没有想到大根堆的算法，只是用sort将每次除以2后的整个数组进行降序排序，这样的作法使用sort对数组进行排序后，虽然可以确定数组中的元素大小顺序，但在每次选择偶数进行减半操作时，需要遍历整个数组来找到合适的偶数，效率较低。对于一个较大的数组，排序后可能需要花费较多的时间来找到下一个要进行减半操作的偶数，尤其是当操作次数较多时，这种遍历的方式会变得非常耗时。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 397
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
数据结构1800题解析：算法复杂度与数据存储
通过这些试题，学习者可以深入理解数据结构的基本概念，熟悉各种数据结构的操作和特性，以及如何分析算法的时间复杂度，从而提升在实际编程和系统设计中的能力。同时，试题中的选择题形式也方便自我检测和复习，帮助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值