Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit ea8ba0b

Browse files
author
liuhaibin
committed
init
0 parents  commit ea8ba0b

File tree

203 files changed

+18533
-0
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

203 files changed

+18533
-0
lines changed

‎[数据结构（Java版）（第4版）][叶核亚][习题解答]/02.3.2 3. 单链表【实验2-6，习题解答】平均值/src/SinglyList_average.java

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
//《数据结构（Java版）（第4版）习题解答》，作者：叶核亚，2014年12月26日
2+
//§2.3 线性表的链式存储和实现
3+
//【实验2-7，习题解答】求单链表元素的平均值。
4+
5+
public class SinglyList_average
6+
{
7+
//算法可行，但效率低，时间复杂度是O(n*n)。
8+
public static double average(SinglyList<Integer> list) //求所有元素的平均值
9+
{
10+
int sum=0;
11+
for(int i=0; i<list.size(); i++) //size()的时间是O(n)
12+
sum += list.get(i).intValue(); //get(i)的时间是O(n)
13+
return (double)sum/list.size(); //实数除，存在除数为0错误
14+
}
15+
16+
public static double averageAll(SinglyList<Integer> list)//求所有元素的平均值，时间复杂度是O(n)
17+
{
18+
int sum=0, count=0;
19+
// for (Node<Integer> p=list.head.next; p!=null; p=p.next) //遍历单链表，O(n)，要求head和next权限必须是public
20+
for (Node<Integer> p=list.first(); p!=null; p=list.next(p)) //以迭代方式遍历单链表。O(n)
21+
{
22+
sum += p.data.intValue(); //元素值求和
23+
count++; //统计元素个数
24+
}
25+
if (list.isEmpty())
26+
throw new IllegalArgumentException("不能对空单链表计算平均值。"); //抛出无效参数异常
27+
return (double)sum/count; //返回平均值。实数除，避免了除数为0错误
28+
}
29+
30+
public static void main(String args[])
31+
{
32+
Integer[] values={10,20,30};
33+
SinglyList<Integer> list = new SinglyList<Integer>(values);//Array1.random(10,100));//见例1.4//返回产生n个随机数的数组
34+
System.out.println("list="+list.toString());
35+
System.out.println("average(list)="+average(list));
36+
System.out.println("averageAll(list)="+averageAll(list));
37+
System.out.println("averageExceptMaxMin(list)="+averageExceptMaxMin(list));
38+
}
39+
40+
//【实验2-7】 （第3版例2.3）
41+
//去掉最高分和最低分，再求平均值，O(n)
42+
public static double averageExceptMaxMin(SinglyList<Integer> list)
43+
{
44+
if (list.isEmpty())
45+
throw new IllegalArgumentException("不能对空单链表计算平均值。"); //抛出无效参数异常
46+
int sum=0, i=0, max=Integer.MIN_VALUE, min=Integer.MAX_VALUE;
47+
Node<Integer> p=list.head.next; //要求head权限必须是public
48+
while (p!=null) //遍历单链表
49+
{
50+
int value = p.data.intValue();
51+
sum += value;
52+
if (value>max)
53+
max = value;
54+
if (value<min)
55+
min = value;
56+
p = p.next;
57+
i++;
58+
}
59+
if (i==1 || i==2)
60+
return (double)sum/i; //返回两个元素的平均值，避免了除数为0错误
61+
return (double)(sum-max-min)/(i-2); //返回去掉最高分和最低分后的平均值
62+
}
63+
}
64+
/*
65+
程序运行结果如下：
66+
list=(10,20,30)
67+
average(list)=20.0
68+
averageAll(list)=20.0
69+
averageExceptMaxMin(list)=20.0
70+
71+
*/
72+
/*修改
73+
double average(SeqList<Student> list) //求平均值
74+
{
75+
int n=stulist.length(); //顺序表长度
76+
double sum=0;
77+
for (int i=0; i<n; i++)
78+
sum += stulist.get(i).score; //此处get(i)返回Student结构类型
79+
return n>0 ? sum/n: 0; //给出0个元素结果，避免除数为0错误
80+
}
81+
double average(SinglyList<Student> list) //求平均值
82+
{
83+
int n=stulist.length(); //单链表长度
84+
if (n>0)
85+
{
86+
double sum=0;
87+
for (int i=0; i<n; i++)
88+
sum += stulist.get(i).score; //此处get(i)返回Student结构类型
89+
return sum/n;
90+
}
91+
return 0.0; //给出0个元素的结果，避免除数为0错误
92+
}
93+
*/
94+
95+

‎[数据结构（Java版）（第4版）][叶核亚][习题解答]/02.3.2 3. 单链表【思考题2-8，习题解答】合并连接/src/SinglyList_addAll.java

Lines changed: 90 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,90 @@
1+
//《数据结构（Java版）（第4版）习题解答与实验指导》，作者：叶核亚，2014年12月31日，JDK 8.25
2+
//§2.3 线性表的链式存储和实现
3+
//3. 带头结点的单链表类
4+
//【思考题2-8，习题解答】 合并连接单链表。
5+
//【例2.1】 单链表作为方法参数与返回值问题讨论。
6+
7+
public class SinglyList_addAll
8+
{
9+
public static void main(String args[])
10+
{
11+
//(1) 连接（浅拷贝）与添加（深拷贝）
12+
String[] valuea={"a","b","c"}, valueb={"x","y"};
13+
SinglyList<String> lista = new SinglyList<String>(valuea);
14+
SinglyList<String> listb = new SinglyList<String>(valueb);
15+
System.out.println("lista="+lista.toString()+"\nlistb="+listb.toString());
16+
lista.addAll(listb); //2.15（a），在lista之后链接listb
17+
System.out.println("lista.concat(listb);");
18+
System.out.println("lista="+lista.toString()+"\nlistb="+listb.toString());
19+
listb.insert("z");
20+
System.out.println("listb.insert(\"z\");");
21+
System.out.println("lista="+lista.toString()+"\nlistb="+listb.toString());
22+
23+
/* lista.append(listb);
24+
System.out.println("lista.append(listb);\nlista: "+lista.toString());
25+
System.out.println("listb: "+listb.toString());
26+
27+
ExSinglyList<String> listc = new ExSinglyList<String>(listb);//深拷贝
28+
System.out.println("listc: "+listc.toString());
29+
30+
31+
listb.append("q");
32+
System.out.println("listb.append(\"q\")\nlista: "+lista.toString());
33+
System.out.println("listb: "+listb.toString());
34+
35+
//(2) 返回子表（深拷贝）
36+
ExSinglyList<String> listsub = lista.sub(0,3);
37+
System.out.println("listsub = lista.sub(0,3);\nlistsub: "+listsub.toString());
38+
39+
*/
40+
}
41+
}
42+
/*
43+
程序运行结果如下：
44+
//(1)没有设置list为空
45+
lista=ExSinglyList(a,b,c)
46+
listb=ExSinglyList(x,y)
47+
lista.concat(listb);
48+
lista=ExSinglyList(a,b,c,x,y)
49+
listb=ExSinglyList(x,y)
50+
listb.insert("z"); //作用于两条单链表
51+
lista=ExSinglyList(a,b,c,x,y,z)
52+
listb=ExSinglyList(x,y,z)
53+
54+
//(2)没有设置list为空
55+
lista=ExSinglyList(a,b,c)
56+
listb=ExSinglyList(x,y)
57+
lista.concat(listb);
58+
lista=ExSinglyList(a,b,c,x,y)
59+
listb=ExSinglyList()
60+
listb.insert("z"); //仅作用于listb，两条单链表无关
61+
lista=ExSinglyList(a,b,c,x,y)
62+
listb=ExSinglyList(z)
63+
64+
lista: (a,b,c)
65+
listb: (x,y)
66+
listc: (x,y)
67+
lista.append(listb);
68+
lista: (a,b,c,x,y)
69+
listb: (x,y)
70+
listb.append("z");
71+
lista: (a,b,c,x,y)
72+
listb: (x,y,z)
73+
lista.concat(listb);
74+
lista: (a,b,c,x,y,x,y,z)
75+
listb: ()
76+
listb.append("q")
77+
lista: (a,b,c,x,y,x,y,z)
78+
listb: (q)
79+
listsub = lista.sub(0,3);
80+
listsub: (a,b,c)
81+
lista.search(listsub): a
82+
将(a,b,c,x,y,x,y,z)中(x,y)全部替换为(a,b,c)的结果是(a,b,c,a,b,c,a,b,c,z)
83+
lista.replaceAll(listc, listsub);
84+
lista: (a,b,c,a,b,c,a,b,c,z)
85+
将(a,b,c,a,b,c,a,b,c,z)中(a,b,c)全部删除的结果是(z)
86+
lista.removeAll(listsub);
87+
lista: (z)
88+
89+
90+
*/

‎[数据结构（Java版）（第4版）][叶核亚][习题解答]/03.1 【例3.1】 CC++语言下标越界错误/strcopy.cpp

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
//《数据结构（C++版）（第3版）》 作者：叶核亚
2+
//【例3.1】 C/C++语言的string.h中strcpy()和strcat()函数存在下标越界错误。
3+
4+
#include <iostream>
5+
using namespace std;
6+
#include <string.h>
7+
8+
int main()
9+
{
10+
char src[]="abcdefghijlkmn", dest[3]="", *p;
11+
p = strcpy(dest, src); //VC++ 2008编译警告:“strcpy函数不安全”
12+
cout<<"src=\""<<src<<"\", dest=\""<<dest<<"\", p=\""<<p<<"\""<<endl;
13+
14+
system("pause");
15+
return 0;
16+
//之后有运行错
17+
}
18+
19+
/*
20+
程序运行 ：
21+
22+
23+
24+
*/

‎[数据结构（Java版）（第4版）][叶核亚][习题解答]/03.2.2 常量字符串类【实验3-9，习题解答】浮点数类/src/Double_ex.java

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
2+
public class Double_ex
3+
{
4+
public static void main(String args[])
5+
{
6+
String str[]={"12345", "-0.1234567", "-12345E2", "-12345.67E-2","-12345E0"};
7+
for (int i=0; i<str.length; i++)
8+
{
9+
System.out.println("java.lang.Double.parseDouble(\""+str[i]+"\")="+Double.parseDouble(str[i]));
10+
}
11+
}
12+
}
13+
/*
14+
³ÌÐòÔËÐнá¹ûÈçÏ£º
15+
java.lang.Double.parseDouble("12345")=12345.0
16+
java.lang.Double.parseDouble("-0.1234567")=-0.1234567
17+
java.lang.Double.parseDouble("-12345E2")=-1234500.0
18+
java.lang.Double.parseDouble("-12345.67E-2")=-123.4567
19+
java.lang.Double.parseDouble("-12345E0")=-12345.0
20+
21+
*/
22+
23+

‎[数据结构（Java版）（第4版）][叶核亚][习题解答]/03.2.2 常量字符串类【实验3-9，习题解答】浮点数类/src/MyDouble.java

Lines changed: 107 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,107 @@
1+
//《数据结构（Java版）（第4版）习题解答与实验指导》，作者：叶核亚，2015年2月5日
2+
//3.2.2 常量字符串类
3+
//【实验3-9，习题解答】 浮点数类。
4+
5+
public final class MyDouble implements Comparable<MyDouble>//浮点数类，最终类
6+
{
7+
private final double value; //最终变量，存储浮点数
8+
9+
public MyDouble(double value) //由double值构造浮点数对象
10+
{
11+
this.value = value;
12+
}
13+
14+
public MyDouble(String s) throws NumberFormatException //由字符串s构造浮点数对象，s包含正负号
15+
{
16+
this.value = this.parseDouble(s);
17+
}
18+
19+
public double doubleValue() //返回浮点数值
20+
{
21+
return this.value;
22+
}
23+
24+
public String toString() //返回浮点数值的字符串。覆盖Object类方法
25+
{
26+
return this.value+""; //“+”自动将浮点数转换为字符串
27+
}
28+
29+
public int compareTo(MyDouble dobj) //比较两个对象值大小，返回-1、0或1
30+
{
31+
return this.value<dobj.value? -1 : (this.value==dobj.value ? 0 : 1);
32+
}
33+
34+
//返回实数字符串s表示的浮点数，语法图见教材图3.21（a），由数字序列和运算符构造实数
35+
public static double parseDouble(String s) throws NumberFormatException
36+
{
37+
int i=0, sign=s.charAt(0)=='-' ? -1 : 1; //sign记住符号位
38+
if (s.charAt(0)=='+' || s.charAt(0)=='-') //跳过符号位
39+
i++;
40+
double value=0, power=0.1;//10.0E0; //power表示底数为10的幂//能够将整数赋给浮点数
41+
while (i<s.length() && s.charAt(i)>='0' && s.charAt(i)<='9')//获得整数部分值
42+
value = value*10+s.charAt(i++)-'0';
43+
if (i<s.length() && s.charAt(i)=='.') //若是小数点
44+
{ i++;
45+
while (i<s.length() && s.charAt(i)>='0' && s.charAt(i)<='9')//获得小数部分值
46+
{ value += (s.charAt(i)-'0')*power;
47+
i++;
48+
power*=0.1;
49+
}
50+
}
51+
value *=sign;
52+
53+
if (i<s.length() && (s.charAt(i)=='E' || s.charAt(i)=='e')) //处理阶码
54+
{ i++;
55+
power = (s.charAt(i)=='-') ? 0.1 :10; //阶码的符号位决定指数的正负及其运算
56+
if (s.charAt(i)=='+' || s.charAt(i)=='-')
57+
i++;
58+
int exp=0;
59+
while (i<s.length() && s.charAt(i)>='0' && s.charAt(i)<='9')
60+
exp = exp*10+s.charAt(i++)-'0'; //获得指数的绝对值
61+
for (int j=0; j<exp; j++)
62+
value*=power;
63+
}
64+
return value;
65+
}
66+
67+
//返回实数字符串s表示的浮点数，语法图见教材图3.21（b），由整数、数字序列和运算符构造实数
68+
public static double toDouble(String s)
69+
{
70+
int dot=s.indexOf('.'), e=s.indexOf('E'); //寻找小数点和E
71+
if (e==-1)
72+
e=s.indexOf('e');
73+
if (dot==-1 && e==-1)
74+
return MyInteger.parseInt(s); //s中没有小数和阶码，返回整数
75+
76+
int i=0, sign=s.charAt(0)=='-' ? -1 : 1; //sign记住符号位
77+
if (s.charAt(0)=='+' || s.charAt(0)=='-') //跳过符号位
78+
i++;
79+
80+
double value=0, power=0.1; //power表示底为10的幂，赋值为整数
81+
if (dot!=-1) //s中有小数部分
82+
{ value=MyInteger.parseInt(s.substring(i,dot)); //获得正整数部分值
83+
dot++; //跳过小数点
84+
while (dot<s.length() && s.charAt(dot)>='0' && s.charAt(dot)<='9') //获得小数部分值
85+
{
86+
value += (s.charAt(dot)-'0')*power;
87+
dot++;
88+
power*=0.1;
89+
}
90+
}
91+
value *=sign;
92+
93+
if (e!=-1) //处理阶码
94+
{ if (dot==-1) //s中没有小数部分
95+
value=MyInteger.parseInt(s.substring(0,e));//获得整数部分值
96+
e++;
97+
power = (s.charAt(e)=='-') ? 0.1 :10; //阶码的符号位决定指数的正负及运算
98+
if (s.charAt(e)=='+' || s.charAt(e)=='-')
99+
e++;
100+
int exp=MyInteger.parseInt(s.substring(e)); //获得指数部分的正整数值
101+
for (int j=0; j<exp; j++)
102+
value*=power;
103+
}
104+
return value;
105+
}
106+
}
107+
//@author：Yeheya。2015-2-5

‎[数据结构（Java版）（第4版）][叶核亚][习题解答]/03.2.2 常量字符串类【实验3-9，习题解答】浮点数类/src/MyDouble_ex.java

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
//《数据结构（Java版）（第4版）习题解答与实验指导》，作者：叶核亚，2015年2月5日
2+
//3.2.2 常量字符串类
3+
//【实验3-9，习题解答】 浮点数类。
4+
5+
public class MyDouble_ex
6+
{
7+
public static void main(String args[])
8+
{
9+
String str[]={"12345", "-123","-0.1234567", "-12345E2", "-12345.67E-2","-12345E0"};
10+
for (int i=0; i<str.length; i++)
11+
{
12+
System.out.println("parseDouble(\""+str[i]+"\")="+MyDouble.parseDouble(str[i]));
13+
System.out.println("toDouble(\""+str[i]+"\")="+MyDouble.toDouble(str[i]));
14+
}
15+
}
16+
}
17+
/*
18+
程序运行结果如下：
19+
parseDouble("12345")=12345.0
20+
toDouble("12345")=12345.0
21+
parseDouble("-0.1234567")=-0.12345670000000002
22+
toDouble("-0.1234567")=-0.12345670000000002
23+
parseDouble("-12345E2")=-1234500.0
24+
toDouble("-12345E2")=-1234500.0
25+
parseDouble("-12345.67E-2")=-123.45670000000001
26+
toDouble("-12345.67E-2")=-123.45670000000001
27+
parseDouble("-12345E0")=-12345.0
28+
toDouble("-12345E0")=-12345.0
29+
*/

0 commit comments

Comments
 (0)