精华内容
下载资源
问答
  • 该资源为2017、2019年青岛大学921数据结构与算法基础考研真题,资源高清无水印哦!
  • 该资源为2017年青岛大学921数据结构与算法基础考研真题,资源高清无水印哦!
  • 文章目录: 2014年 1.带头双循环链表删除一个结点返回其值 2.栈入队 3.二叉树二叉链表存储,先序遍历处于第k个位置的结点 4.无头结点单链表判断是否递增 ...5.二叉树二叉链表存储,增加一个指向双亲结点,查找x...
    展开全文
  • 深圳大学计算机软件学院 907 数据结构与算法历年考研真题答案汇编 最新资料 WORD 格式可编辑修改 目 录 2013 年深圳大学计算机软件学院 831 数据结构与算法考研真题 . 2012 年深圳大学计算机软件学院 819 数据...
  • 青岛大学921数据结构与算法基础真题,考研真题,青岛大学2019年硕士研究生入学考试试题B,学工办辛老师给的
  • 2019年沈阳工业大学808数据结构考研真题
  • 想看更多算法题,可以扫描上方二维码关注我微信公众号“数据结构算法”,截止到目前我已经在公众号中更新了500多道算法题,其中部分已经整理成了pdf文档,截止到目前总共有1000多页(并且还会不断的增加),可以在...

    在这里插入图片描述

    想看更多算法题,可以扫描上方二维码关注我微信公众号“数据结构和算法”,截止到目前我已经在公众号中更新了500多道算法题,其中部分已经整理成了pdf文档,截止到目前总共有1000多页(并且还会不断的增加),可以在公众号中回复关键字“pdf”即可下载。

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    ……

    总共12页,就不在一一展示,可以扫描最上面的二维码,关注微信公众号“数据结构和算法”,回复1032即可下载

    展开全文
  • 对于使用c++语言描述的数据结构,而又想做做题目,想学好点的同学,这是很好的资料哦。分了各个章节,都是考研的习题,DOC文件。很实用的家伙。
  • 该资源为北京师范大学847数据结构与程序设计历年考研真题汇编,资源高清无水印哦! 该资源为北京师范大学847数据结构与程序设计历年考研真题汇编,资源高清无水印哦!
  • 877数据结构与算法分析

    千次阅读 2021-05-02 18:45:02
    适合考昆明理工大学的877数据结构与算法分析,如果考昆工的数据结构与算法分析,也可以加入我们的QQ交流群:733804292(初试和复试都是这个) 百度网盘地址: 链接:...

    昆明理工大学计算机考研,自己的复习经验、去年的录取分数线以及考研大纲。一志愿过国家线也差不多可以进来。适合考昆明理工大学的877数据结构与算法分析,如果考昆工的数据结构与算法分析,也可以加入我们的QQ交流群:733804292(初试和复试都是这个)

    百度网盘地址:

    链接:https://pan.baidu.com/s/1IqPqtggDZwAuBUtGU1Vokg 
    提取码:yl9c 
    

    877数据结构与算法专业课包含专业:

    计算机系统与结构、计算机软件与理论、
    计算机应用技术、医疗信息技术、软件工程、
    计算机技术、人工智能
    
    展开全文
  • 此为南京邮电大学811数据结构考研真题+答案1999-2018(无2012),本人为2018年考研工科生,这门专业课几乎满分,其中上传的真题中2018年回忆版+答案最为珍贵(也是学得好才能全部回忆出来,哈哈!),除了3道选择题...
  • 考研题不同于leetcode,不会给你输入输出样例,所以审题一定要好好审题。那我重新写吧。 public void deleteDuplicate() { if (length == 0) { throw new IllegalArgumentException("顺序表长度为0,无法删除...

    2.2 顺序表

      顺序表内容如下:

    class ArrayList {
    	
    	public int[] arr;
    	public int length;
    
    	public ArrayList(int[] arr, int length) {
    	
    		if (arr.length < length) {
    			/* 给数组扩容,不过我这里没有实现扩容的方法,所以直接抛出异常 */
    			throw new IllegalArgumentException();
    		}
    		
    		this.arr = arr;
    		this.length = length;
    	
    	}
    
    	@Override
    	public String toString() {
    		if (length == 0) return "[]";
    		StringBuilder sb = new StringBuilder();
    		sb.append("[").append(arr[0]);
    		for (int i = 1; i < length; i++) {
    			sb.append(", ").append(arr[i]);
    		}
    		sb.append("]");
    		return sb.toString();
    	}
    	
    }
    

      所有函数都放在类中。

    1、删除最小元素
    public int deleteMin() {
    
    	if (length == 0) {
    		throw new IllegalArgumentException("顺序表长度为0,无法删除。");
    	}
    
    	int minIndex = 0;
    
    	for (int i = 0; i < length; i++) {
    		if (arr[i] < arr[minIndex]) {
    			minIndex = i;
    		}
    	}
    
    	int temp = arr[minIndex];
    	length--;
    	arr[minIndex] = arr[length - 1];
    	return temp;
    
    }
    

      这个题有点离谱,题上说是返回被删除的元素,但是给的答案却是返回删除是否成功的布尔值。

      后来再看了一下答案,原来他还传参了一个整形指针变量,到时候这个指针就会变成被删除元素的值,而返回的布尔值则是删除是否成功。毕竟c语言不支持抛出异常,他还想保证鲁棒性的话,就只能这样了。

    2、顺序表逆置
    public void reverse() {
    	for (int i = 0; i < length / 2; i++) {
    		int temp = i;
    		i = arr[length - i - 1];
    		arr[length - i - 1] = temp;
    	}
    }
    

      这个题说让写成O(1)的算法,我就当场骂娘了,这有for循环啊,你™咋写成O(1)。然后写完了以后看答案,和我写的一样,嗷,原来人家描述问题的单位是这个顺序表,而不是length,那这样写肯定就是一个O(1)算法了。

    3、删除某元素
    public void deleteElem(int x) {
    	for (int i = 0; i < length; i++) {
    		if (arr[i] == x) {
    			for (int j = i; j < length - 1; j++) {
    				arr[j] = arr[j + 1];
    			}
    			length--;
    		}
    	}
    }
    

      我这个写的有点小复杂了,而且时间复杂度是O(n^2),这肯定是没分的。

      王道的标准答案转写成java应该是这样的:

    public void deleteElem(int x) {
    	int j = 0;
    	for (int i = 0; i < length; i++) {
    		if (arr[i] != x) {
    			arr[j] = arr[i];
    			j++;
    		}
    	}
    	length = j;
    }
    
    4、☆删除排序顺序内的某开区间内元素
    public void deleteInOpenInterval(int s, int t) {
    	
    	if (length == 0) {
    		throw new IllegalArgumentException("顺序表长度为0,无法删除元素。");
    	}
    	
    	if (s >= t) {
    		throw new IllegalArgumentException("给出的最小值不小于最大值。不构成区间。");
    	}
    	int j = 0;
    	for (int i = 0; i < length; i++) {
    		if (s >= arr[i] || arr[i] >= t) {
    			arr[j] = arr[i];
    			j++;
    		}
    	}
    	
    	length = j;
    	
    }
    

      这是我的写法,我第一次写的时候没注意到居然是有序表,写的有点离谱哈,看答案解析看到说是有序表才点醒我。不过我还没看答案代码,自己再重新写一遍再看吧。

    public void deleteInOpenInterval(int s, int t) {
    	
    	if (length == 0) {
    		throw new IllegalArgumentException("顺序表长度为0,无法删除元素。");
    	}
    	
    	if (s >= t) {
    		throw new IllegalArgumentException("给出的最小值不小于最大值。不构成区间。");
    	}
    	
    	for (int i = 0; i < length; i++) {
    		if (arr[i] == s) {
    			s = i;
    			break;
    		}
    	}
    	
    	for (int i = s + 1; i < length; i++) {
    		if (arr[i] == t) {
    			t = i;
    			break;
    		}
    	}
    	
    	length -= ((t - s) + 1);
    	
    	for (int i = s + 1; i < length; i++) {
    		arr[i] = arr[t - s + 1];
    	}
    
    }
    

      错了,没分。
    呜呜呜
      呜呜呜,应该是删除元素哪里有问题的。看了看王道给的答案,确实,我这个删除的方法有点儿非主流。这样确实容易删错。按照王道的答案对这个算法进行改进:

    public void deleteInOpenInterval(int s, int t) {
    
    	if (length == 0) {
    		throw new IllegalArgumentException("顺序表长度为0,无法删除元素。");
    	}
    
    	if (s >= t) {
    		throw new IllegalArgumentException("给出的最小值不小于最大值。不构成区间。");
    	}
    
    	for (int i = 0; i < length; i++) {
    		if (arr[i] > s) {
    			s = i;
    			break;
    		}
    	}
    
    	for (int i = s + 1; i < length; i++) {
    		if (arr[i] >= t) {
    			t = i;
    			break;
    		}
    	}
    
    	for (;t < length; s++, t++) {
    		arr[s] = arr[t];
    	}
    
    	length = s;
    
    }
    

      这样子就好了 -_-||

    5、删除顺序表内闭区间元素
    public void deleteInCloseInterval(int s, int t) {
    
    	if (length == 0) {
    		throw new IllegalArgumentException("顺序表长度为0,无法删除元素。");
    	}
    
    	if (s > t) {
    		throw new IllegalArgumentException("给出的最小值不小于最大值。不构成区间。");
    	}
    
    	int j = 0;
    	for (int i = 0; i < length; i++) {
    		if (arr[i] < s || arr[i] > t) {
    			arr[j] = arr[i];
    			j++;
    		}
    	}
    
    	length = j;
    
    }
    

      王道书上用的不是这个算法,但是也差不多其实,如下:

    public void deleteInCloseInterval(int s, int t) {
    
    	if (length == 0) {
    		throw new IllegalArgumentException("顺序表长度为0,无法删除元素。");
    	}
    
    	if (s > t) {
    		throw new IllegalArgumentException("给出的最小值不小于最大值。不构成区间。");
    	}
    
    	int j = 0;
    	for (int i = 0; i < length; i++) {
    		if (s <= arr[i] && arr[i] <= t) {
    			j++;
    		} else {
    			arr[i - j] = arr[i];
    		}
    	}
    
    	length -= j;
    
    }
    

      这俩其实都是应用了双指针滑动窗口算法。这是顺序表上一个重要的算法。

    6、☆顺序表的去重

      我能想到的唯一算法就是三层for循环了,可以说是很垃圾了。不管了,先写吧。

    public void deleteDuplicate() {
    		for (int i = 0; i < length; i++) {
    			for (int j = i + 1; j < length; j++) {
    				if (arr[i] == arr[j]) {
    					length--;
    					for (int k = j; k < length; k++) {
    						arr[k] = arr[k + 1];
    					}
    				}
    			}
    		}
    	}
    

      虽然这个题没有对时间开销有要求,但这™时间开销都到O(n^3)了,写了个蛇皮棒棒锤啊。

      看了下标准答案,不仅鲁棒性比我这个强,而且用到了双指针滑动窗口,所以复杂度也只有O(n),麻了。

      又看了几遍答案解析,发现原来是有序顺序表……以后做题一定要先把有序划出来。这考研题不同于leetcode,不会给你输入输出样例,所以审题一定要好好审题。那我重新写吧。

    public void deleteDuplicate() {
    
    	if (length == 0) {
    		throw new IllegalArgumentException("顺序表长度为0,无法删除元素。");
    	}
    
    	int j = 0;
    	for (int i = 1; i < length; i++) {
    		if (arr[i] != arr[j]) {
    			arr[++j] = arr[i];
    		}
    	}
    
    	length = j + 1;
    
    }
    

      和王道树上的差不多了,强烈建议这段代码要熟练!!!另外多在leetcode上刷一些双指针滑动窗口算法的题。然后我看答案上问就是如果是无序顺序表应该怎么做,还提示说用散列。那咱就试试呗。散列我就直接调用了。

    public void deleteDuplicate() {
    
    	if (length == 0) {
    		throw new IllegalArgumentException("顺序表长度为0,无法删除元素。");
    	}
    
    	HashSet<Integer> set = new HashSet<>();
    
    	for (int i = 0, j = 0; i < length; i++) {
    		if (!set.contains(arr[i])) {
    			set.add(arr[i]);
    			arr[j] = arr[i];
    			j++;
    		}
    	}
    
    	length = set.size();
    
    }
    
    7、合并两个有序顺序表
    public static ArrayList merge(ArrayList l1, ArrayList l2) {
    	int[] arr = new int[l1.length + l2.length];
    	for (int i = 0, j = 0, k = 0; i < arr.length; i++) {
    		if (l1.arr[j] <= l2.arr[k]) {
    			arr[i] = l1.arr[j];
    			j++;
    		} else {
    			arr[i] = l2.arr[k];
    			k++;
    		}
    	}
    	return new ArrayList(arr, arr.length);
    }
    

      这个不错,O(n)。答案上那个办法能简单点,如下:

    public static ArrayList merge(ArrayList l1, ArrayList l2) {
    
    	int[] arr = new int[l1.length + l2.length];
    	int i = 0;
    	int j = 0;
    	int k = 0;
    
    	while (j < l1.length && k < l2.length) {
    		if (l1.arr[j] <= l2.arr[k]) {
    			arr[i++] = l1.arr[j++];
    		} else {
    			arr[i++] = l2.arr[k++];
    		}
    	}
    
    	while (j < l1.length) {
    		arr[i++] = l1.arr[j++];
    	}
    	
    	while (k < l2.length) {
    		arr[i++] = l2.arr[k++];
    	}
    	
    	return new ArrayList(arr, arr.length);
    
    }
    

      就像答案上这样,能用自增的就用自增,显得很简练,很高级。

    8、交换顺序表

      也就是把前m个元素和后n个元素位置打掉头。唉,我又是只能想出复杂度相当高的算法。唉,写吧。

    public void swapElem(int m, int n) {
    
    	if (m + n != length) {
    		throw new IllegalArgumentException("长度不匹配");
    	}
    
    	int[] temp;
    
    	/* 为了尽量减小内存消耗,所以要比较一下m和n的大小 */
    	if (m <= n) {
    
    		temp = new int[m];
    
    		for (int i = 0; i < m; i++) {
    			temp[i] = arr[i];
    		}
    
    		for (int i = 0; i < n; i++) {
    			arr[i] = arr[i + m];
    		}
    
    		for (int i = 0; i < m; i++) {
    			arr[i + n] = temp[i];
    		}
    
    	} else {
    
    		temp = new int[n];
    
    		for (int i = 0; i < n; i++) {
    			temp[i] = arr[i + m];
    		}
    
    		for (int i = m - 1; i >= 0; i--) {
    			arr[i + n] = arr[i];
    		}
    
    		for (int i = 0; i < n; i++) {
    			arr[i] = temp[i];
    		}
    
    	}
    
    }
    

      答案上和我这个不一样。思路详见答案。我把他的代码用java实现一遍。

    public void swapElem(int m) {
    
    	if (m >= length) {
    		throw new IllegalArgumentException("长度不匹配");
    	}
    
    	reverse(arr, 0, length);
    	reverse(arr, 0, length - m);
    	reverse(arr, length - m, length);
    
    }
    
    private static void reverse(int[] arr, int begin, int end) {
    	for (int i = 0; i < (end - begin) / 2; i++) {
    		int temp = arr[begin + i];
    		arr[begin + i] = arr[end - i - 1];
    		arr[end - i - 1] = temp;
    	}
    }
    
    9、在有序顺序表中查找元素

      查找成功则将该元素与其后继交换,否则插入该元素使该表仍然顺序排列。

    public void swapOrInsert(int x) {
    
    	/* 经典回顾之二分法查找了属于是 */
    
    	int low = 0;
    	int high = length - 1;
    	int index = 0;
    	boolean find = false;
    
    	while (low <= high) {
    
    		index = (low + high) / 2;
    
    		if (arr[index] == x) {
    			find = true;
    			break;
    		}
    
    		if (arr[index] < x) {
    			low = index + 1;
    		}
    
    		if (arr[index] > x) {
    			high = index - 1;
    		}
    
    	}
    
    	if (find && index < length - 1) {
    		int temp = arr[index];
    		arr[index] = arr[index + 1];
    		arr[index + 1] = temp;
    	} else if (!find) {
    		length++;
    		for (int i = length - 1; i > low; i--) {
    			arr[i] = arr[i - 1];
    		}
    		arr[low] = x;
    	}
    
    }
    

      答案上和我写的几乎一样,有一个需要改进的就是,二分查找while里面一定要写else,效率更高。如下:

    while (low <= high) {
    
    	index = (low + high) / 2;
    
    	if (arr[index] == x) {
    		find = true;
    		break;
    	}
    
    	if (arr[index] < x) {
    		low = index + 1;
    	}
    
    	else if (arr[index] > x) {
    		high = index - 1;
    	}
    
    }
    
    10、☆【2010年真题】数组左移

      (1) 先将整个数组逆置,变为:(xn-1, xn-2, …, xp+1, xp, xp-1, …, x1, x0),然后再将前(n-p)和后p个元素分别逆置,就可以得到正确的结果。

      (2) Java语言描述:

    public static void shiftLeft(int[]r, int p) {
    
    	/* 若为空数组则直接返回 */
    	if (r.length == 0) {
    		return;
    	}
    
    	// 逆置整个数组
    	reverse(r, 0, r.length);
    	// 逆置前一部分
    	reverse(r, 0, r.length - p);
    	// 逆置后一部分
    	reverse(r, r.length - p, r.length);
    
    }
    
    /**
     * 这个函数用来逆置数组的某一部分
     * @param arr 进行局部逆置的数组
     * @param begin 开始位置
     * @param end 结束位置
     */
    private static void reverse(int[] arr, int begin, int end) {
    	for (int i = 0; i < (end - begin) / 2; i++) {
    		int temp = arr[begin + i];
    		arr[begin + i] = arr[end - i - 1];
    		arr[end - i - 1] = temp;
    	}
    }
    

      (3) 时间复杂度为O(n)。空间复杂度为O(1)

      备注:答案跟我这个大同小异,没啥好说的。另外这个题类似于第8题

    11、☆【2011年真题】两个升序表共同的中位数

      (1) 首先,升序列表的中位数肯定是他的(length - 1) / 2处元素,两个顺序表的中位数肯定就是先要合并才能求出的,但我们这里实际上用不到专门开辟空间来合并两个列表就可以遍历合并后的列表了。我们可以先算出中位数应该在合并列表中的哪个位置。然后开始遍历,若l1[j] <= l2[k],则j++并判断此时是否遍历到中位数。若l1[j] > l2[k],则k++并判断此时是否遍历到中位数。

      (2) java语言描述:

    public static int finMedianOfTwoList(ArrayList l1, ArrayList l2) {
    	int pos = (l1.length + l2.length - 1) / 2;
    	int j = 0, k = 0;
    	for (int i = 0; i <= pos; i++) {
    		if (l1.arr[j] <= l2.arr[k]) {
    			if (i == pos) return l1.arr[j];
    			j++;
    		} else {
    			if (i == pos) return l1.arr[k];
    			k++;
    		}
    	}
    	return -1;
    }
    

      (3) 时间复杂度为O(n),空间复杂度为O(1)

      备注:首先一个是忘记写注释了,对于考研而言,这是很不好的一个习惯。前面的提就不说了,我是从第十个题开始下定决心以后写真题要带注释,结果这个题忘了。另外答案上的方法时间复杂度是O(log2n),空间复杂度和我这个一样,用的是类似于二分查找的归并思想。

    (1)

    ① 分别求A和B的中位数为a和b,并进行一下运算:

    ② 若a == b,返回,结束算法。

    ③ 若a < b,舍弃A中较小的一半,舍弃B中较大的一半。回到①

    ④ 若a > b,舍弃A中较大的一半,舍弃A中较小的一半。回到①

    (2)

    public static int finMedianOfTwoArr(int[] a, int[] b) {
    
    	int s1 = 0, e1 = a.length -1, s2 = 0, e2 = b.length - 1, m1, m2;
    
    	while (s1 != e1 || s2 != e2) {
    
    		m1 = (s1 + e1) / 2;
    		m2 = (s2 + e2) / 2;
    			
    		/* 判断是否满足条件一,满足则直接返回 */
    		if (a[m1] == b[m2]) {
    			return a[m1];
    		}
    			
    		/* 判断是否满足条件二 */
    		if (a[m1] < b[m2]) {
    			/* 若偶数个元素,舍弃a中间及以前 */
    			if ((s1 + e1) % 2 == 0) {
    				s1 = m1;
    			/* 否则舍弃b中间点及以后 */
    			} else { 
    				s1 = m1 + 1;
    			}
    			e2 = m2;
    			break;
    		}
    
    		/* 判断是否满足条件三 */
    		if (a[m1] > b[m2]) {
    			if ((s2 + e2) % 2 == 0) {
    				s2 = m2;
    			} else {
    				s2 = m2 + 1;
    			}
    			e1 = m1;
    			break;
    		}
    
    	}
    
    	return Math.min(a[s1], b[s2]);
    
    }
    

    (3) 时间复杂度为O(log2n),空间复杂度为O(1)

      同一个思路,其实也可以用面向对象的方法求解:

    class ArrayList {
    
    	final private int[] arr;
    	private int begin;
    	private int end;
    
    	public ArrayList(int[] arr) {
    		this.arr = arr;
    		begin = 0;
    		end = arr.length;
    	}
    
    	public int getElem(int index) {
    		return arr[begin + index];
    	}
    
    	public int getLength() {
    		return end - begin;
    	}
    
    	public int getMedium() {
    		return arr[begin + (end - begin) / 2];
    	}
    
    	public void retainMin() {
    		end -= (end - begin) / 2;
    	}
    
    	public void retainMax() {
    		begin += (end - begin) / 2;
    	}
    
    	public static int getMediumBetweenTwo(ArrayList l1, ArrayList l2) {
    
    		int a = 0;
    		int b = 0;
    
    		while (l1.getLength() == 0 || l2.getLength() == 0) {
    
    			a = l1.getMedium();
    			b = l2.getMedium();
    
    			if (a == b) return a;
    
    			if (a < b) {
    				l1.retainMin();
    				l2.retainMax();
    			} else {
    				l1.retainMax();
    				l2.retainMin();
    			}
    
    		}
    
    		return Math.min(a, b);
    
    	}
    
    }
    
    12、☆【2013年真题】找众数

      这个题就是先用一个隐式的栈加for找到众数,然后再用一个for看他出现了几次。
    (1)
      首先利用一个逻辑上的隐式的栈,该栈内的所有元素都是一样的,所以只需要用两个变量来描述栈。并让数组第一个元素入栈。
    遍历数组:

    ① 若当前遍历到的元素与栈内元素相同则入栈。

    ② 若当前遍历到的元素与站内元素不同:
     a. 若栈不为空,弹栈
     b. 若栈为空,则让当前遍历到的元素入栈

      遍历完数组后若栈为空,则说明不存在众数,返回-1,若栈不为空,众数为栈内元素。再次遍历数组统计该众数出现的次数,若大于数组长度的一半则返回众数,否则返回-1

    public static int majority (int[] arr) {
    
    	int count = 1;
    	int c = arr[0];
    
    	for (int i = 0; i < arr.length; i++) {
    		if (arr[i] == c) {
    			count++;
    		} else {
    			if (count > 0) {
    				count--;
    			} else {
    				c = arr[i];
    				count = 1;
    			}
    		}
    	}
    
    	if (count > 0) {
    		count = 0;
    		for (int i = 0; i < arr.length; i++) {
    			if (arr[i] == c) {
    				count++;
    			}
    		}
    	}
    
    	return count > arr.length / 2 ? c : -1;
    		
    }
    

    (3) 时间复杂度为O(n),空间复杂度为O(1)

    备注:找众数一定一定要掌握。

    13、☆【2018年真题】未出现的最小正整数

      佛了,我又是只能想到O(n2),唉
    (1)
      ① 首先定义变量min为1
      ② 假定未出现的最小正整数为min
      ③ 遍历数组
      ④ 若当前遍历到的元素等于min,则令min自增,并跳转到步骤②
      ⑤ 若数组遍历完都没有找到等于min的元素,则返回min
    (2)

    public static int findMinUnExistInteger (int[] arr) {
    
    	int min = 1;
    		
    	loop: while (true) {
    		for (int n : arr) {
    			if (n == min) {
    				min++;
    				continue loop;
    			}
    		}
    		return min;
    	}
    
    }
    

    (3) 时间复杂度为O(n2),空间复杂度为O(1)

      emmmm……题干上说了要求时间上尽可能高效,所以要用空间换时间,我就没好好审题。ε=(´ο`*)))唉,瞎j8乱写。王道上这个答案就挺好的,时间O(n),空间O(n)。如下:

    public static int findMinUnExistInteger (int[] arr) {
    
    	int[] target = new int[arr.length];
    
    	for (int n : arr) {
    		/* 若当前遍历到的元素值介于1~n,则进行标记 */
    		if (0 < n && n <= arr.length) {
    			target[n - 1] = 1;
    		}
    	}
    
    	/* 扫描target,找到目标值 */
    	for (int i = 0; i < arr.length; i++) {
    		if (target[i] == 0) return i;
    	}
    		
    	return -1;
    		
    }
    
    14、☆【2020年真题】三元组

      麻了啊,我就只能想到O(n3)的暴力算法。。。答案上时间O(n),空间O(1),考研出这个我就死定了。

      唉,先把答案抄一遍。消化消化。

    public static int findMinOfTrip(int[] a, int[] b, int[] c) {
    
    	int i = 0, j = 0, k = 0;
    	/* dMin用来记录三元组中的最小距离,处置设为最大值 */
    	int d, dMin = Integer.MAX_VALUE;
    
    	while (i < a.length && j < b.length && k < c.length) {
    			
    		d = Math.abs(a[i] - b[j]) + Math.abs(b[j] - c[k]) + Math.abs(c[k] - a[i]);
    		
    		/* 更新d */	
    		if (d < dMin) {
    			dMin = d;
    		}
    			
    		if (a[i] < b[j] && a[i] < c[k]) {
    			i++;
    		} else if (b[j] < a[i] && b[j] < c[k]) {
    			j++;
    		} else {
    			k++;
    		}
    			
    	}
    
    	return dMin;
    
    }
    

    2.3 链表

      链表长这样:

    class LinkedList {
    
    	public int val;
    	public LinkedList next;
    	public boolean haveHead;
    
    	public LinkedList() {
    
    	}
    
    	public LinkedList(int[] arr, boolean haveHead) {
    		this(arr, 0);
    		this.haveHead = haveHead;
    	}
    
    	private LinkedList(int[] arr, int begin) {
    		val = arr[begin];
    		if (begin != arr.length - 1) {
    			next = new LinkedList(arr, begin + 1);
    		}
    	}
    
    	@Override
    	public String toString() {
    
    		StringBuilder sb = new StringBuilder();
    		sb.append("[");
    		LinkedList cur = haveHead ? next : this;
    
    		if (cur != null) {
    			sb.append(cur.val);
    			cur  = cur.next;
    		}
    
    		while (cur != null) {
    			sb.append(", ").append(cur.val);
    			cur = cur.next;
    		}
    
    		sb.append("]");
    		return sb.toString();
    
    	}
    
    	public static free(Object obj) {
    		obj = null;
    	}
    
    }
    
    1、删除无头节点链表的某元素
    public static LinkedList deleteElem(int x, LinkedList node) {
    	if (node == null) return null;
    	node.next = deleteElem(x, node.next);
    	if (x == node.val) {
    		LinkedList temp = node.next;
    		free(node);
    		return temp;
    	} else {
    		return node;
    	}
    }
    

      答案上差不多,没啥好说的、

    2、☆删除有头节点链表的某元素
    public static void deleteElem(int x, LinkedList head) {
    	LinkedList cur = head;
    	while (cur.next != null) {
    		if (cur.next.val == x) {
    			LinkedList temp = cur.next;
    			cur.next = cur.next.next;
    			free(temp); // 启用虚拟机释放内存
    		}
    		cur = cur.next;
    	}
    }
    

      错了,没分了。如果要删除链表1->2->2->3中的元素2,那当cur = 1时,删除掉cur.next,链表变为1->2->3,同时cur向后移一位,变为2,再次判断cur.next就判断的是3了。修正这个算法也很简单,加个else,如下:

    public static void deleteElem(int x, LinkedList head) {
    	LinkedList cur = head;
    	while (cur.next != null) {
    		if (cur.next.val == x) {
    			LinkedList temp = cur.next;
    			cur.next = cur.next.next;
    			free(temp); // 启用虚拟机释放内存
    		} else {
    			cur = cur.next;
    		}
    	}
    }
    
    3、逆序输出单链表

      靠,我尽量空间上O(1)

      想了十来分钟,只能想到逆置链表后输出和节点入栈再弹栈输出的法子。太低效了。。。

    public static void printReserve(LinkedList head) {
    		
    	LinkedList cur = head.next;
    	Stack<Integer> stack = new Stack<>();
    		
    	while (cur != null) {
    		stack.push(cur.val);
    		cur = cur.next;
    	}
    
    	while (!stack.isEmpty()) {
    		System.out.println(stack.pop());
    	}
    		
    }
    

      答案上的方法是递归调用:

    public static void printReserve(LinkedList head) {
    	if (head != null) printRe(head.next);
    }
    
    private static void printRe(LinkedList node) {
    	if (node == null) return;
    	printRe(node.next);
    	System.out.println(node.val);
    }
    

      那么问题来了,第一个算法空间复杂度肯定是O(n)没错了,创建了一个栈嘛。那第二个算O(1)还是O(n)呢?方法栈的内存占用算不算到空间复杂度里面?(后来问了一下别人,这个是算的。所以我的算法并没有比答案的算法低效太多)

    4、删除单链表中最小元素

      遍历一次找到最小值对应的节点前的节点,记为prevOfMin。

      遍历结束后删除prevOfMin后面的节点。

    public static void deleteMin(LinkedList head) {
    	if (head == null || head.next == null) return;
    	LinkedList cur = head;
    	LinkedList prevOfMin = cur;
    	while (cur.next != null) {
    		if (cur.next.val < prevOfMin.next.val) {
    			prevOfMin = cur;
    		}
    		cur = cur.next;
    	}
    	LinkedList temp = prevOfMin.next;
    	prevOfMin.next = prevOfMin.next.next;
    	free(temp);
    }
    
    5、链表逆置

      这个题要求O(1),那咱就写呗。

    public void reverse(LinkedList head) {
    
    	LinkedList ans = new LinkedList();
    	LinkedList cur = head.next;
    	ans.next = null;
    
    	while (cur != null) {
    		LinkedList temp = cur;
    		cur = cur.next;
    		temp.next = ans.next;
    		ans.next = temp;
    	}
    		
    	head.next = ans.next;
    	
    }
    

      答案和这个大同小异

    6、☆链表排序

      。。。我个垃圾,几乎只会冒泡。。。我就写了个冒泡,我试着在力扣上提交,毫无悬念地超时了。。。下面是我的屎山代码:

    public static void sort(LinkedList head) {
    
    	LinkedList p = head.next;
    
    	while (p.next != null) {
    
    		LinkedList q = p.next;
    
    		while (q != null) {
    
    			if (p.val > q.val) {
    				int temp = p.val;
    				p.val = q.val;
    				q.val = temp;
    			}
    
    			q = q.next;
    
    		}
    
    		p = p.next;
    
    	}
    
    }
    

      答案肯定不是这样子整的,答案用的是直接插入排序,如下:

    public static void sort(LinkedList head) {
    
    	LinkedList p = head.next;
    	head.next = null;
    
    	while (p != null) {
    
    		LinkedList cur = head;
    
    		while (cur.next != null && p.val > cur.next.val) {
    			cur = cur.next;
    		}
    
    		cur.next = new LinkedList(p.val, cur.next);
    
    		p = p.next;
    
    	}
    
    }
    

      冒泡排序和直接插入排序虽然对顺序表来说都是O(n2),但是对于链表来说,冒泡排序是O(n2),而直接插入排序却是O(n),因为元素后移不需要额外开销。

    7、删除链表中属于某个区间的元素

       大概就这样

    public static void deleteBetweenSection(LinkedList head, int low, int high) {
    	LinkedList cur = head;
    	while (cur.next != null) {
    		if (low < cur.next.val && cur.next.val < high) {
    			LinkedList temp = cur.next;
    			cur.next = temp.next;
    			free(temp);
    		} else {
    			cur = cur.next;
    		}
    	}
    }
    

      答案上一样

    8、寻找公共节点

      我在力扣上做过这个题。我这个算法有个致命的缺点,那就是如果传参的两个链表如果没有公共节点,那就会陷入死循环,不过题上人也没给要求说是让没有公共节点就返回什么啥的。那我这也没问题。

    public static LinkedList findSameNode(LinkedList l1, LinkedList l2) {
    
    	LinkedList a = l1;
    	LinkedList b = l2;
    
    	while (true) {
    
    		if (a == b) return a;
    
    		if (a.next != null) {
    			a = a.next;
    		} else {
    			a = l1;
    		}
    
    		if (b.next != null) {
    			b = b.next;
    		} else {
    			b = l2;
    		}
    
    	}
    
    }
    

      答案上不是这么写的,答案上相对复杂一点,但是可以使得无公共节点时返回信息。如下:

    public static LinkedList findSameNode(LinkedList l1, LinkedList l2) {
    
    	LinkedList shortList = l1;
    	LinkedList longList = l2;
    	int dist = 0;
    
    	while (shortList != null && longList != null) {
    		shortList = shortList.next;
    		longList = longList.next;
    	}
    
    	boolean flag = shortList == null;
    		
    	while (shortList != null) {
    		dist++;
    		shortList = shortList.next;
    	}
    		
    	while (longList != null) {
    		dist++;
    		longList = longList.next;
    	}
    		
    	shortList = flag ? l1 : l2;
    	longList = flag ? l2 : l1;
    		
    	while (dist-- != 0) {
    		longList = longList.next;
    		while (longList != null) {
    			if (longList == shortList) {
    				return longList;
    			} else {
    				shortList = shortList.next;
    				longList = longList.next;
    			}
    		}
    	}
    		
    	return null;
    		
    }
    

      第二十二题那个算法比这个更高效。

    9、链表递增顺序输出
    public static void sortedOutPut(LinkedList head) {
    	while (head.next != null) {
    		LinkedList cur = head;
    		LinkedList preOfMin = cur;
    		while (cur.next != null) {
    			if (cur.next.val < preOfMin.next.val) {
    				preOfMin = cur;
    			}
    			cur = cur.next;
    		}
    		LinkedList min = preOfMin.next;
    		System.out.println(min.val);
    		preOfMin.next = min.next;
    		free(min);
    	}
    	free(head);
    }
    
    10、链表的分割
    public static LinkedList separate(LinkedList a) {
    
    	LinkedList cur = a.next;
    	a.next = null;
    	LinkedList b = new LinkedList(0, null);
    	b.haveHead = true;
    
    	LinkedList p = a;
    	LinkedList q = b;
    
    	int i = 0;
    	while(cur != null) {
    
    		if ((i & 1) == 0) {
    			p.next = new LinkedList(cur.val, p.next);
    			p = p.next;
    		} else {
    			q.next = new LinkedList(cur.val, q.next);
    			q = q.next;
    		}
    
    		cur = cur.next;
    		i++;
    
    	}
    
    	return b;
    
    }
    
    11、还是链表的分割

      和上面那个差不多其实,就该几行代码的事。

    public static LinkedList separate(LinkedList a) {
    
    	LinkedList cur = a.next;
    	a.next = null;
    	LinkedList b = new LinkedList(0, null);
    	b.haveHead = true;
    
    	LinkedList p = a;
    	LinkedList q = b;
    
    	int i = 0;
    	while(cur != null) {
    
    		if ((i & 1) == 0) {
    			p.next = new LinkedList(cur.val, p.next);
    			p = p.next;
    		} else {
    			q.next = new LinkedList(cur.val, q.next);
    		}
    
    		cur = cur.next;
    		i++;
    
    	}
    
    	return b;
    
    }
    
    12、链表去重

      挺好写的我感觉。

    public static void deleteDuplicate(LinkedList head) {
    
    	if (head == null || head.next == null) return;
    	LinkedList p = head.next;
    
    	while (p.next != null) {
    
    		// System.out.println("p = " + p.val);
    		LinkedList q = p;
    
    		while (q.next != null) {
    			// System.out.println("\tq.next = " + q.next.val);
    			if (q.next.val == p.val) {
    				// System.out.println("\t\tdelete q.next = " + q.next.val);
    				LinkedList temp = q.next;
    				q.next = temp.next;
    				free(temp);
    			} else {
    				q = q.next;
    			}
    		}
    
    		p = p.next;
    
    	}
    
    }
    
    13、链表合并
    public static LinkedList merge(LinkedList a, LinkedList b) {
    
    	LinkedList head = new LinkedList(0, null);
    	head.haveHead = true;
    	a = a.next;
    	b = b.next;
    
    	while (a != null && b != null) {
    		if (a.val < b.val) {
    			head.next = new LinkedList(a.val, head.next);
    			a = a.next;
    		} else {
    			head.next = new LinkedList(b.val, head.next);
    			b = b.next;
    		}
    	}
    
    	while (a != null) {
    		head.next = new LinkedList(a.val, head.next);
    		a = a.next;
    	}
    
    	while (b != null) {
    		head.next = new LinkedList(b.val, head.next);
    		b = b.next;
    	}
    
    	return head;
    
    }
    
    14、通过链表公共元素获得新链表

      没咋看懂,也不太会。

      看了下答案上的思路,没看代码,写出来是这样的:

    public static LinkedList getListOfCommonElem(LinkedList a, LinkedList b) {
    
    	a = a.next;
    	b = b.next;
    	LinkedList head = new LinkedList();
    	head.next = null;
    
    	while (a != null && b != null) {
    		if (a.val < b.val) {
    			a = a.next;
    		} else if (b.val < a.val) {
    			b = b.next;
    		} else {
    			head.next = new LinkedList(a.val, head.next);
    			a = a.next;
    			b = b.next;
    		}
    	}
    
    	return head;
    
    }
    

      答案和这个差不多,只是答案是尾插法,我是头插法。题上又没说非得按某种顺序排列,那我觉得我这个也没有问题。

    15、求交集

      和上面那个还蛮像的

    public static void interSection(LinkedList a, LinkedList b) {
    
    	while (a.next != null && b.next != null) {
    
    		if (a.next.val < b.next.val) {
    			LinkedList temp = a.next;
    			a.next = temp.next;
    			free(temp);
    		} else if (b.next.val < a.next.val) {
    			b = b.next;
    		} else {
    			a = a.next;
    			b = b.next;
    		}
    
    	}
    
    	if (b.next == null) a.next = null;
    
    }
    

      答案上差不多,有一点不同是,答案把b都删了。。。。而且有一个好的地方是答案上a未遍历完而b遍历完的情况下,是逐渐遍历a的结点并释放的,这很好。如下:

    public static void interSection(LinkedList a, LinkedList b) {
    
    	LinkedList temp;
    
    	while (a.next != null && b.next != null) {
    
    		if (a.next.val < b.next.val) {
    			temp = a.next;
    			a.next = temp.next;
    			free(temp);
    		} else if (b.next.val < a.next.val) {
    			temp = b.next;
    			b.next = temp.next;
    			free(temp);
    		} else {
    			a = a.next;
    			temp = b.next;
    			b.next = temp.next;
    			free(temp);
    		}
    
    	}
    
    	while (b.next != null) {
    		temp = b.next;
    		b.next = temp.next;
    		free(temp);
    	}
    
    	while (a.next != null) {
    		temp = a.next;
    		a.next = temp.next;
    		free(temp);
    	}
    
    	free(b);
    
    }
    
    16、☆链表连续子序列

      这个题我看答案上说这其实是字符串匹配的链式表达形式,建议学完字符串后再来这里试试。试试就试试。现在先用局限性的知识做吧。

    public boolean isSubsequence(LinkedList list) {
    
    	LinkedList cur = next;
    
    	loop: while (cur != null) {
    
    		LinkedList p = cur;
    		LinkedList q = list.next;
    
    		while (q != null && p != null) {
    			if (q.val == p.val) {
    				q = q.next;
    				p = p.next;
    			} else {
    				cur = cur.next;
    				continue loop;
    			}
    		}
    			
    		return q == null;
    
    	}
    
    	return false;
    
    }
    

      答案和这个差不多,虽然只用了一个循环,但他循环里面会将结点置为开始结点从头开始,所以时间复杂度其实是一样的。假设第一个链表长度为m,第二个为n,那么时间复杂度为O(n2)

    17、双向循环链表是否对称

      这个感觉还好了,我感觉没有多难,当然也有可能是我太普信了。

    class DoubleLinkedList {
    
    	public int val;
    	public DoubleLinkedList next;
    	public DoubleLinkedList prev;
    
    	public static boolean isSymmetrical(DoubleLinkedList head) {
    		
    		DoubleLinkedList s = head.next;
    		DoubleLinkedList r = head.prev;
    		
    		while (s != r && s != r.next) {
    			if (s.val == r.val) return false;
    			s = s.next;
    			r = r.next;
    		}
    		
    		return true;
    		
    	}
    
    }
    

      没啥问题,答案差不多一样。

    18、合并两个循环链表

      这个我感觉用c语言好点,不用释放h1,直接*(h1) = *(h2)

    public static void mergeCircularList(LinkedList h1, LinkedList h2) {
    		
    	LinkedList p = h1;
    	while (p.next != h1) p = p.next;
    	p.next = h2.next;
    	free(h2);
    		
    	while (p.next != null) p = p.next;
    	p.next = h1;
    		
    }
    

      答案上是分别找到h1和h2的尾指针。h1的尾部指h2.next,然后h2的尾部指向h1。

    19、循环链表递增顺序输出

      。。。就是第9题套壳儿

    public static void sortedOutPut(LinkedList head) {
    	while (head.next != head) {
    		LinkedList cur = head;
    		LinkedList preOfMin = cur;
    		while (cur.next != head) {
    			if (cur.next.val < preOfMin.next.val) {
    				preOfMin = cur;
    			}
    			cur = cur.next;
    		}
    		LinkedList min = preOfMin.next;
    		System.out.println(min.val);
    		preOfMin.next = min.next;
    		free(min);
    	}
    	free(head);
    }
    

      答案上虽然不能说是一模一样,但也可以说是一模一样了。

    20、按访问频度动态地给链表排序

      可没给我累死

    class DoubleLinkedList {
    
    	private final Node head;
    
    	static class Node {
    
    		private int data;
    		private int freq;
    
    		private Node next;
    		private Node prev;
    
    		public Node() {
    
    		}
    
    		public Node(int data, Node next) {
    			next.prev = this;
    			this.data = data;
    			this.next = next;
    		}
    
    		private Node(int[] arr, int begin) {
    
    			data = arr[begin];
    
    			if (begin != arr.length - 1) {
    				Node temp = new Node(arr, begin + 1);
    				temp.prev = this;
    				next = temp;
    			}
    
    		}
    
    	}
    
    	public DoubleLinkedList(int[] arr) {
    		head = new Node(0, new Node(arr, 0));
    	}
    
    	@Override
    	public String toString() {
    
    		StringBuilder sb = new StringBuilder();
    		sb.append("[");
    		Node cur = head.next;
    
    		if (cur != null) {
    			sb.append(cur.data).append(":").append(cur.freq);
    			cur  = cur.next;
    		}
    
    		while (cur != null) {
    			sb.append(", ").append(cur.data).append(":").append(cur.freq);
    			cur = cur.next;
    		}
    
    		sb.append("]");
    		return sb.toString();
    
    	}
    
    	public Node locate(int x) {
    
    		Node node = head.next;
    		while (node.data != x) node = node.next;
    
    		node.freq++;
    		node.prev.next = node.next;
    		if (node.next != null) {
    			node.next.prev = node.prev;
    		}
    
    		Node cur = head;
    		while (cur.next != null && node.freq < cur.next.freq) cur = cur.next;
    
    		node.next = cur.next;
    		node.prev = cur;
    		node.prev.next = node;
    		if (node.next != null) {
    			node.next.prev = node;
    		}
    
    		return node;
    
    	}
    
    }
    

      答案上差不多,注意一下,双向链表的插入和删除都要注意的一点是,比如插删node,有时候可能node是最后一个节点,那你不能直接node.next.prev = node.prev,因为node.next可能为空,要先对node.next判空。插入也是,比如cur后面插node,不能直接cur.next.prev = node,因为cur有可能是最后一个元素,也就是cur.next很有可能是空,要先判空。

    21、【2009年真题】寻找倒数第k个节点

      O(n) 快慢指针法

    public static boolean findNthToLast(LinkedList list, int k) {
    
    	LinkedList q = list;
    	LinkedList p = list;
    	while (k-- > 0 && q != null) q = q.next;
    	if (q == null) return false;
    
    	while (q != null) {
    		p = p.next;
    		q = q.next;
    	}
    
    	System.out.println(p.val);
    	return true;
    
    }
    
    22、【2012年真题】链式字符串的公共节点

      第八题套壳儿,无非就是整形换成字符串。但是我看答案上这个题和第八题的解法是不一样的。如下:

    private int length() {
    		LinkedList head = next;
    		int n = 0;
    		while (head != null) {
    			n++;
    			head = head.next;
    		}
    		return n;
    	}
    
    	public static LinkedList findCommonNode(LinkedList h1, LinkedList h2) {
    
    		int m = h1.length();
    		int n = h2.length();
    
    		LinkedList p;
    		LinkedList q;
    
    		for (p = h1; m > n; m--) {
    			p = p.next;
    		}
    
    		for (q = h2; n > m; n--) {
    			q = q.next;
    		}
    
    		while (p.next != null && p.next != q.next) {
    			p = p.next;
    			q = q.next;
    		}
    
    		return p.next;
    		
    }
    

      这我感觉比第八题那个快多了捏。

    23、【2015年真题】链表去重(绝对值相同也去)

      第十二题复杂化

    public static void deleteSameAbs(LinkedList head) {
    
    	if (head == null || head.next == null) return;
    	LinkedList p = head.next;
    
    	while (p.next != null) {
    
    		// System.out.println("p = " + p.val);
    		LinkedList q = p;
    
    		while (q.next != null) {
    			// System.out.println("\tq.next = " + q.next.val);
    			if (q.next.val == Math.abs(p.val)) {
    				// System.out.println("\t\tdelete q.next = " + q.next.val);
    				LinkedList temp = q.next;
    				q.next = temp.next;
    				free(temp);
    			} else {
    				q = q.next;
    			}
    		}
    
    		p = p.next;
    
    	}
    
    }
    

      靠、这个题和第十二题都有问题,啊啊啊啊。过几天再改。麻了。

    24、☆判断链表是否有环

      在力扣上见到过这个题,不过当时直接pass了。

    public static LinkedList findEntryOfRing(LinkedList head) {
    
    	LinkedList p = head.next;
    	int i = 0;
    
    	while (p != null) {
    
    		//System.out.println("p = " + p.val);
    
    		LinkedList q = head;
    		for (int j = 0; j < i; j++) {
    			q = q.next;
    			//System.out.println("\tq = " + q.val);
    			if (q == p) return p;
    		}
    
    		i++;
    		p = p.next;
    
    	}
    
    	return null;
    
    }
    

      我麻了,写是写出来了,内存开销。。。有点大啊。我看看答案是咋写的。。。。。答案是快慢指针。如下:

    public static LinkedList findEntryOfRing(LinkedList head) {
    
    	LinkedList fast = head, slow = head;
    		
    	while (slow != null && fast.next != null) {
    		slow = slow.next;
    		fast = fast.next.next;
    		if (slow == fast) break;
    	}
    
    	if (slow == null || fast.next == null) {
    		return null;
    	}
    		
    	LinkedList p = head, q = slow;
    
    	while (p != q) {
    		p = p.next;
    		q = q.next;
    	}
    		
    	return p;
    		
    }
    

      靠、没咋看懂。其实,根据这个算法画画图就差不多懂了。第一个while循环那里挺好理解,第二个就不太懂了。

      答案上说相遇时从头结点到环的入口的距离等于n倍的环长减去环的入口点到相遇点的距离。n是快指针绕过的圈数。这样子的话。。。就可以解释第二个while里面的内容了。唉……反正我人是麻了,麻麻的。

    25、【2019年真题】链表重新排列

      类似于十、十一题。

    public static void reArrange(LinkedList head) {
    
    	LinkedList slow = head, fast = head;
    	LinkedList p = new LinkedList();
    	LinkedList q = new LinkedList();
    	LinkedList r = q;
    
    	while (slow.next != null && fast.next.next != null) {
    		slow = slow.next;
    		fast = fast.next.next;
    		p.next = new LinkedList(slow.val, p.next);
    		if (fast.next == null) break;
    	}
    
    	while (slow.next != null) {
    		slow = slow.next;
    		r.next = new LinkedList(slow.val, r.next);
    		r = r.next;
    	}
    
    	// System.out.println(p);
    	// System.out.println(q);
    
    	head.next = null;
    	boolean flag = false;
    
    	while (p.next != null && q.next != null) {
    		if (flag) {
    			p = p.next;
    			head.next = new LinkedList(p.val, head.next);
    		} else {
    			q = q.next;
    			head.next = new LinkedList(q.val, head.next);
    		}
    		flag = !flag;
    	}
    
    }
    

      贼,终于写完了,题真够多的。

    展开全文
  • 南邮数据结构真题2012-2020
  • 长沙理工大学考研数据结构真题,包含近十年初试真题+答案,和近几年复试真题。本人花钱购买的,已上岸。考试代码850;真题加答案
  • 包含西华大学计算机 考研专业课16-20年内 考研初试中数据结构的历年真题
  • 注意:所有答案必须写在答题本上,不得写在...1、算法算法的特性 2、树的度及深度 3、完全二叉树 4、索引文件 5、强连通性 二、选择题(共30分,每题2分) 1、设核S和队列Q的初始状态均为空,元素ABCDEFG 依...
  • 第1章 绪 论1.1 复习笔记一、什么是数据结构数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和操作等的学科。二、基本概念和术语1数据数据是对客观事物的符号表示,是计算机...
  • 目 录 2013年中国传媒大学文学院706算法与数据结构考研真题 2012年中国传媒大学文学院706算法与数据结构考研真题 2011年中国传媒大学文学院706算法与数据结构考研真题 2010年中国传媒大学文学院705算法与数据结构...
  • 3.1 栈 3、出入栈是否非法   挺好写的,我感觉。 public static boolean func(char[] arr) { int length = 0; for (int i = 0; i < arr.length;... if (arr[i] == 'O') length--;...4、判断回文
  • 计算机考研传说中的数据结构1800题,包含各大高校历年的数据结构考研真题,带目录可快速检索。
  • 岳教佬袜石乓涟葫蓬赞搓醚营枣醛砾仅佛掸扯涵讼婆恤浇袜劫杯翼强娶仓拓芬灼型歪魁楚治海拷惧擎窑捉瞄晒铂忘讣 遇酶辙甫瘪要沧辱涪兹竖料做铂渣过积滴蝎销捻篆履胎删枣卒声摸湖仟胆润效颅诈攻燥旨壁耿觅惭紫奖组译旧...
  • 西安交通大学软件工程及计算机考研数据结构核心题库,希望大家好好利用本资料
  • 该资源为2017年北方工业大学861数据结构考研强化模拟题及答案详解,资源高清无水印哦!
  • 2017年华中科技大学887数据结构与算法分析考研试题本站小编 免费考研网/2020-02-27一.名词解释(25分,1个5分)1.1堆分配存储表示1.2完全图1.3树的结点层次1.4拓扑排序1.5时间复杂度二.选择题(25分,1个5分)2.1 折半...
  • 该资源为2017年南京财经大学826数据结构考研题库及答案详解,资源高清无水印哦!
  • 数据结构习题集leetcode21PAT 6-1 单链表逆转 (20 分)leetcode 141. 环形链表PAT 6-2 顺序表操作集 (20 分) leetcode21 /* Created by salmon on 2021-9-14 21:27. */ /** * Definition for singly-linked list....
  • 导语内容提要程玉胜主编的《数据结构与算法C语言版习题精编实验指导》作为《数据结构与算法(C语言版)》教材的配套教学参考书,主要内容包括习题解析和实验指导两大部分,其中“例题精解”、“习题实训”是习题解析...
  • 本资源是合肥工业大学数据结构四套卷,其中的题目证实每年出题的方向,做透了这几套卷子考研不愁,请好好利用
  • 请填空: 第 2 页,共 73 页 其中 队头和队尾指针分别为front 和rear , 则此循 【答案】 【解析】通过递归算法,首先找到最高位的值,将其放到str 对应的数组中,依次反向获取从高位到地位的值,将其放到数组中,...
  • 想看更多算法题,可以扫描上方二维码关注我微信公众号“数据结构算法”,截止到目前我已经在公众号中更新了500多道算法题,其中部分已经整理成了pdf文档,截止到目前总共有1000多页(并且还会不断的增加),可以在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,569
精华内容 1,027
关键字:

数据结构与算法考研真题

数据结构 订阅