内容简介　　本书是国外数据结构与算法分析方面的的标准教材, 使用最卓越的Java编程语言作为实现工具讨论了数据结构和算法分析。书中着重阐述了抽象数据类型的概念，并对算法的效率、性能和运动时间做了全面的分析，为读者开发高效率程序奠定了基础。 本书可作为高级数据结构课程或者高等院校本科生、研究生算法分析课程的教材。　　本书的主要特点：　　·包含用Java语言编写的丰富的样例程序，这些代码可从因特网上得到。　　·专用一章来讨论算法设计技巧，包括贪婪算法、分治算法、动态规划算法、随机化算法以及回溯算法　　·阐述当前流行的论题和新的数据结构，如斐波那契堆、斜堆、二项队列、跳跃表和伸展树　　·专用一章讨论摊还分析，并进而考察书中描述的一些高级数据结构的性能　　·安排了一章讨论高级数据结构及其实现，其中包括红黑树、自上而下伸展树、配对堆等　　·提出一些尚未解决和尚未完全解决的问题　　·书末附有两个关于Java 语言的附录，附录A介绍其本的Java 类 ，附录B则讨论了Collections类库，介绍了许多与本书的数据结构和算法密切相关的Java程序编辑推荐　　本书是国外数据结构与算法分析方面的的标准教材, 使用最卓越的Java编程语言作为实现工具讨论了数据结构和算法分析。书中着重阐述了抽象数据类型的概念，并对算法的效率、性能和运动时间做了全面的分析，为读者开发高效率程序奠定了基础。 本书可作为高级数据结构课程或者高等院校本科生、研究生算法分析课程的教材。　　本书的主要特点：　　·包含用Java语言编写的丰富的样例程序，这些代码可从因特网上得到。　　·专用一章来讨论算法设计技巧，包括贪婪算法、分治算法、动态规划算法、随机化算法以及回溯算法　　·阐述当前流行的论题和新的数据结构，如斐波那契堆、斜堆、二项队列、跳跃表和伸展树　　·专用一章讨论摊还分析，并进而考察书中描述的一些高级数据结构的性能　　·安排了一章讨论高级数据结构及其实现，其中包括红黑树、自上而下伸展树、配对堆等　　·提出一些尚未解决和尚未完全解决的问题　　·书末附有两个关于Java 语言的附录，附录A介绍其本的Java 类 ，附录B则讨论了Collections类库，介绍了许多与本书的数据结构和算法密切相关的Java程序媒体推荐书评本书的主要特点：·包含用Java语言编写的丰富的样例程序，这些代码可从因特网上得到。·专用一章来讨论算法设计技巧，包括贪婪算法、分治算法、动态规划算法、随机化算法以及回溯算法·阐述当前流行的论题和新的数据结构，如斐波那契堆、斜堆、二项队列、跳跃表和伸展树·专用一章讨论摊还分析，并进而考察书中描述的一些高级数据结构的性能·安排了一章讨论高级数据结构及其实现，其中包括红黑树、自上而下伸展树、配对堆等·提出一些尚未解决和尚未完全解决的问题·书末附有两个关于Java 语言的附录，附录A介绍其本的Java 类 ，附录B则讨论了Collections类库，介绍了许多与本书的数据结构和算法密切相关的Java程序作者简介作者：(美国)维斯 译者：冯舜玺Mark Allen Weiss 佛罗里国际大学计算机学院教授，普林斯顿于数据结构与算法方面的著名教材还有：《数据结构与算法分析——C语言描述》，该书中文版已由机械工业出版社引进出版，以及《Data Structures and Problem Solving :Using Java》、《 Data Structures and Prblem Solving:Using C++》等。他目前是Advanced Placement Computer Science Development Committee主席。 目录封面() 13:37:59在此购买，全网最低价，立刻节省29%下载（14.67M） 附件: 亲，您没有权限下载或查看附件喔:-)
马上 或 吧！
什么时候能有5拼元呢
深情顶帖，楼主加油！
深情顶帖，楼主加油！
liguim****
很好用谢谢。
该用户文章内容已被屏蔽
star65****
感谢分享~~~~~~~~
谢谢楼主分享
Powered by
CopyRight &1454人阅读
java（15）
哈希法（2）
1.输入一个正数n，输出所有和为n的连续正数序列。
分析：设定两个指针，min指向和为n的连续正数序列的最小值，max指向和为n的连续正数序列最大值。sum表示真正的和。
初始情况下,min、max和sum 都指向1.
当sum小于n时，max++；
当sum大于n时，min++;
当sum等于n时，输出整个序列。
public class a {
public static void getAns(int n) {
int min = 1;
int sum = 1;
int max = 1;
while(min &= n/2+1) {
if(sum == n) {
for(int k = k&= k++) {
System.out.println(k+"");
System.out.println();
sum = sum -
sum = sum+
if(sum & n) {
sum = sum -
sum = sum +
public static void main(String[] args) {
getAns(15);
2.给定一个排好序的链表，删除链表中重复的结点，返回链表头指针。
分析：(1)链表中重复的结点不需要保留一个，要全部删除。
(2)因为相同的结点全部要删除，所以我们设定三个指针，node指向当前节点,prev指向前驱，还有一个指向后继结点。一旦遇到node和后继结点相等，就node++,知道没有重复的再移动prev.
(3)注意：头结点也可能有重复，所以也可能被删除，所以需要定义一个root指向头结点。
public class a {
private static class ListNode {
private int
private ListN
public ListNode() {
public ListNode(int val) {
this.val =
public String toString() {
return val + "";
public static ListNode delete(ListNode head) {
if (head == null)
return null;
if (head.next == null)
ListNode root = new ListNode();
root.next =
ListNode prev =
ListNode node =
while (node != null && node.next != null) {
if (node.val == node.next.val) {
while (node.next != null && node.next.val == node.val)
node = node.
prev.next = node.
prev.next =
prev = prev.
node = node.
return root.
private static void print(ListNode head) {
while (head != null) {
System.out.print(head + "-&");
head = head.
System.out.println("null");
public static void main(String[] args) {
ListNode n1 = new ListNode(1);
ListNode n2 = new ListNode(1);
ListNode n3 = new ListNode(2);
ListNode n4 = new ListNode(2);
ListNode n5 = new ListNode(2);
ListNode n6 = new ListNode(3);
ListNode n7 = new ListNode(5);
n1.next = n2;
n2.next = n3;
n3.next = n4;
n4.next = n5;
n5.next = n6;
n6.next = n7;
n7.next = null;
ListNode result = delete(n1);
print(result);
3.对于一个有序数组，我们通常采用二分查找的方式来定位某一元素，请编写二分查找的算法，在数组中查找指定元素。
给定一个整数数组A及它的大小n，同时给定要查找的元素val，请返回它在数组中的位置(从0开始)，若不存在该元素，返回-1。若该元素出现多次，请返回第一次出现的位置。
分析：重点在返回第一次出现的位置。
public class c {
public static int getPos(int[] A, int n, int val) {
int low = 0, high = n - 1,
if (n == 0 || A == null)
return -1;
while (low &= high) {
mid = (low + high) / 2;
if (val == A[mid]) {
for(int j = j &= 0; j--) {
if(A[j] != A[mid]) {
mid = j + 1;
else if(A[j] == A[mid]) {
} else if (val & A[mid])
high = mid - 1;
low = mid + 1;
return -1;
public static void main(String[] args) {
int A[] = { 4, 4, 5, 5, 5, 5 };
int val = 4;
int n = A.
int result = getPos(A, n, val);
System.out.println(result);
4.对于一个字符串，请设计一个高效算法，找到第一次重复出现的字符。
给定一个字符串(不一定全为字母)A及它的长度n。请返回第一个重复出现的字符。保证字符串中有重复字符，字符串的长度小于等于500。
方法1：这是前辈给出的算法，利用HashSet的特性，即不允许重复放入元素，所以一旦检测到重复元素就返回false。对于本道题来说，这种方法简洁且容易理解，能高效实现功能，但是这种方法普适性较差。
import java.util.HashS
public class g {
public static char findFirstRepeat(String A, int n) {
HashSet hs=new HashSet();
int length=A.length();
char[] a=A.toCharArray();
for(int i=0;i &i++)
boolean b=hs.add(a[i]);
if(b==false)
return a[i];
return'0';
public static void main(String[] args) {
String A = "qywyer23tdd";
int n = A.length();
char b = findFirstRepeat(A, n);
System.out.println(b);
方法2：利用了哈希存储，将给定字符串以键值对形式存储在哈希Map中，key就是每一个字符，value就是每个字符出现的次数。存好后再按顺序遍历Map，找出第一次出现次数不为1的即可。返回。
注意：基于hash的存储是很高效的一种方式，存储键值对方便查找，可以根据key查找value,或者根据value查找key，或者查找特殊的字符等。
延伸：返回第一个只出现一次的字符，返回最后一个出现次数不为1的字符，返回所有出现次数为1的字符或者出现次数不为1的字符，返回给定出现次数的字符等等。
import java.util.ArrayL
import java.util.LinkedHashM
import java.util.List;
import java.util.Map;
import java.util.Map.E
public class g {
private static void findFirstRepeat(String A, int n) {
int sum = 1;
Map&String, Integer& hashMap = new LinkedHashMap
&String, Integer&();
for (int i = 0; i & i++) {
char item = A.charAt(i);
String item2 = String.valueOf(item);
String key = item2;
boolean contains = hashMap.containsKey(key);
if (contains) {
hashMap.put(item2, sum);
hashMap.put(item2, sum);
System.out.println(hashMap);
List&String& keyList = new ArrayList&String&();
for (Entry&String, Integer& e : hashMap.entrySet()) {
if (e.getValue().equals(2)) {
keyList.add(e.getKey());
for (String i : keyList) {
System.out.println(i);
public static void main(String[] args) {
String A = "qywyertdd";
int n = A.length();
findFirstRepeat(A, n);
关于类型转化问题：
(1)String---------》char / char[ ]
String str = "ab";
char str1 = str.charAt(0);
char str2 = str.charAt(1);
char[ ] str3 = str.toCharArray();
System.out.println (Arrays.toString(str3));
(2)char / char[]-----------》String
char m = 'a';
String str = String.valueOf(m);
String str2 = m + " ";
char[] m = {'a','b'};
String str3 = String.copyValueOf(m);
String str4 = new String(m);
(3)int -----------》 String
String s = String.valueOf(i);
String s = Integer.toString(i);
String s = "" +
(4)String ----------》 int
int i = Integer.parseInt([String]);
i = Integer.parseInt([String],[int radix]);
int i = Integer.valueOf(my_str).intValue();
关于哈希存储的处理方案(本人亲试！) ：
(1)根据key来查找，判断是否包含给定的key。
boolean contains = hashMap.containsKey(key);
if (contains) {
System.out.println("存在"+key);
System.out.println("不存在" + key);
(2)根据value来查找，判断是否包含给定的value.
boolean contains = hashMap.containsValue(Value);
if (contains) {
System.out.println("存在"+value);
System.out.println("不存在" +value);
(3)利用keySet遍历所有的key值。
for (Object key : hashMap.keySet()) {
System.out.println("key= " + key + " value " + hashMap.get(key));
牛课网经典例题
1.合并两个排序的链表
思路：定义两个指针，一个指向list1,一个指向List2,定义一个新链表，List1和list2中哪个小就复制到新链表中。注意判断list1和list2是否为空！！！
本题是利用递归来实现的。
public class ListNode {
ListNode next = null;
ListNode(int val) {
this.val = val;
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1 == null) {
return list2;
if(list2 == null) {
return list1;
ListNode s = null;
if(list1.val & list2.val) {
s = list1;
Merge(list1.next, list2);
} else if(list1.val &= list2.val) {
s = list2;
s.next = Merge(list1, list2.next);
处理二进制问题：
两个int32整数m和n的二进制表达，有多少个位(bit)不同么？
(1)m^n后，将结果赋值给一个String类型的变量，循环遍历变量的每一位，看是否等于1.
(2)m^n后，将二进制结果的最后一位&1,然后将二进制右移。
public class Solution {
* 获得两个整形二进制表达位数不同的数量
public int countBitDiff(int m, int n) {
int x = m^n;
int y = 0;
while(x&0) {
if((x&1) == 1) {
水仙花问题：水仙花，即给定一个三位数，每一位的数字立方加起来等于这个数本身。
import java.util.S
public class Solution {
public static void main(String[] args) {
Scanner san = new Scanner(System.in);
int min = san.nextInt();
int max = san.nextInt();
for(int mid = mid & mid++) {
int a = mid/100;
int b = mid%10;
int c = mid%100/10;
int sum = a*a*a + b*b*b + c*c*c;
if(sum == mid) {
System.out.println(mid);
题目：从键盘输入m和n，定义n是第一个数，之后的每个数都是前一个的平方根
，一共有m个数，计算总和。
import java.lang.M
import java.util.S
public class a {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
float n = scan.nextFloat();
int m = scan.nextInt();
float sum =
for(int i=2;i&=m;i++) {
sum += Math.sqrt(n);
n = (float) Math.sqrt(n);
System.out.println("sum=" +sum);
题目：Java的一维数组在不知道长度的情况下怎样声明？
(1) 不知道长度，所以不能直接声明大小
import java.util.ArrayL
import java.util.L
import java.util.S
public class a {
public static void main(String[] args) {
List&Integer& list = new ArrayList&Integer&();
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数组");
while(true) {
int a = scanner.nextInt();
if(a==0) {
list.add(a) ;
int size = list.size();
Integer[] array = (Integer[])list.toArray(new Integer[size]);
for(int i=0;i&array.i++){
System.out.print(array[i]+" ");
这样就得到一个从键盘输入的Int型数组，接下来就可以对数组进行各种操作。
符合一般情况下的需要多组测试用例的情况。
题目：给定一个正整数，编写程序计算有多少对质数的和等于这个输入的正整数，并输出结果，输出值小于1000.
测试用例：
输出：2 （(3,7) 和（5，5））。
import java.util.S
public class cc {
private static int cout(int number) {
int count = 0;
for (int i = 2; i & i++) {
for (int j = 2; j &= number / 2; j++) {
if (isPrime(i) && isPrime(j) && (i + j) == number) {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入给定的数字");
int a = scanner.nextInt();
int count = cout(a);
System.out.println("count=" + count);
public static boolean isPrime(int number) {
if (number & 2) {
return false;
for (int i = 2; i & i++) {
if (number % i == 0) {
return false;
return true;
题目：二分查找，在左区间输出0，右区间输出1.
逐渐逼近，保留6位。
注意特殊输入：
(1) key值小于输入临界最小值或者大于临界最大值。
(2) 临界最小值大于临界最大值。
(3) 两个临界值都为0，输出0。
import java.util.S
public class cc {
public static int comp(int key, int num) {
if (key &= num) {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入最小临界值");
int a = scanner.nextInt();
System.out.println("请输入最大临界值");
int b = scanner.nextInt();
System.out.println("请输入需要比较的值");
int key = scanner.nextInt();
if (key & a || key & b) {
System.out.println("error");
} else if (key == 0 && a == 0 && b == 0) {
System.out.println("error");
while (a &= b) {
for (int i = 0; i & 6; i++) {
num = (a + b) / 2;
System.out.println("num=" + num);
int s = comp(key, num);
if (s == 0) {
System.out.println("0");
System.out.println("1");
题目：镜像字符串，给定两个字符串，判断第二个是否为第一个的镜像字符串，是返回yes，否返回no.
import java.util.S
public class b {
public static Boolean count(String str1, String str2) {
int p1 = 0;
int p2 = 0;
char[] st1 = str1.toCharArray();
char[] st2 = str2.toCharArray();
for (int i = 0; i & st1. i++) {
if (st1[i] == st2[0]) {
while (p1 & st1.length && p2 & st2.length) {
if (st1[p1] == st2[p2]) {
if (p1 == st1.length) {
return false;
return true;
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入字符串");
String str1 = scanner.next();
String str2 = scanner.next();
if(str1.length()-str2.length()!=0) {
System.out.println("no");
if (str1 == null || str1.length() &= 0 || str2 == null
|| str2.length() &= 0) {
System.out.println("error");
Boolean num = count(str1, str2);
if (num.equals(true)) {
System.out.println("yes");
System.out.println("no");
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：3142次
排名：千里之外
原创：24篇
(1)(4)(10)(4)(2)(3)数据结构问题 求大神 java语言描述已知两个数组A和B 比如A=[2,2,2,3,3,1,5,0] 比如 B[2,3,6,5,2,3,9] 我们定义子数组为某一个数组里面的连续的一个或多个数组成的数组 比如上面两个数组的[2,3]是A,B的最大公共数组要求 写出一个函数int f(A,B) 返回任意两个数组的最大公共子串长度 以上例子返回2 1 不能增加额外的数组或其他存储 之能使用若干变量
小蒙奇XOdp57
骚等，我试试。。算法好头疼。。
这不是很容易吗？。。。。不过我也忘了我写的算不算java还是C#,将就看吧，反正都是差不多。大概类似：List你当是一个int的数组好了。一下子忘了怎么写，懒得查。int f(List A,ListB){
int i=0,int k=0;
Dictory sub_collection=new Dictionary() ;//...
为您推荐：
扫描下载二维码