/*【程序21】
*
作者 南枫题目：求1+2!+3!+...+20!的和
1.
程序分析：此程序只是把累加变成了累乘。
*/
package cn.com.flywater.FiftyAlgorthm;
public class Twenty_firstFactorialSum {
static long sum = 0;
static long fac = 0;
public static void main(String[] args) {
long sum = 0;
long fac = 1;
for(int i=1; i<=10; i++) {
fac = fac * i;
sum += fac;
}
System.out.println(sum);
}
}
/*
【程序22】
*
作者 南枫题目：利用递归方法求5!。
1.
程序分析：递归公式：fn=fn_1*4!
*/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class Twenty_secondFactorialRecursion {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
Twenty_secondFactorialRecursion tfr =new Twenty_secondFactorialRecursion();
System.out.println(tfr.recursion(n));
}
public long recursion(int n) {
long value = 0 ;
if(n ==1 || n == 0) {
value = 1;
} else if(n > 1) {
value = n * recursion(n-1);
}
return value;
}
}
/*
【程序23】
*
作者 ：南枫题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
1.
程序分析：利用递归的方法，递归分为回推和递推两个阶段。要想知道第五个人岁数，需知道第四人的岁数，依次类推，推到第一人（10岁），再往回推。
**/
package cn.com.flywater.FiftyAlgorthm;
public class Twenty_thirdPeopleAge {
public static void main(String[] args) {
int age = 10;
for(int i=2; i<=5; i++) {
age += 2;
}
System.out.println(age);
}
}
/*
【程序24】
*
作者 南枫题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。说明： 这个算法实现虽然实现了这个功能，但不健壮，当输入字符是，会出现异常。
*/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class Twenty_fourthNumber {
publicstatic void main(String[] args) {
Twenty_fourthNumber tn = newTwenty_fourthNumber();
Scanner s = new Scanner(System.in);
long a = s.nextLong();
if(a < 0 || a > 100000) {
System.out.println("Error Input,please run this program Again");
System.exit(0);
}
if(a >=0 && a <=9) {
System.out.println( a + "
是一位数");
System.out.println("
按逆序输出是"+ '\n' + a);
} else if(a >= 10 && a<= 99) {
System.out.println(a + "
是二位数");
System.out.println("
按逆序输出是");
tn.converse(a);
} else if(a >= 100 && a<= 999) {
System.out.println(a + "
是三位数");
System.out.println("
按逆序输出是");
tn.converse(a);
} else if(a >= 1000 && a<= 9999) {
System.out.println(a + "
是四位数");
System.out.println("
按逆序输出是");
tn.converse(a);
} else if(a >= 10000 && a<= 99999) {
System.out.println(a + "
是五位数");
System.out.println("
按逆序输出是");
tn.converse(a);
}
}
public void converse(long l) {
String s = Long.toString(l);
char[] ch = s.toCharArray();
for(int i=ch.length-1; i>=0; i--) {
System.out.print(ch[i]);
}
}
}
这个算法实在太土了，也许只有我南枫才会这样写，下面写一个优雅一点的
import java.util.Scanner;
public class Twenty_fourthNumber {
public static void main(String[] args) {
Twenty_fourthNumber tn = newTwenty_fourthNumber();
Scanner s = new Scanner(System.in);
long a = s.nextLong();
String s = Long.toString(l);
char[] ch = s.toCharArray();
System.out.println(a + "
是"
+ ch.length + “位数”);
for(int i=ch.length-1; i>=0; i--) {
System.out.print(ch[i]);
}
}
}
/*
【程序25】
*
作者 南枫题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
**/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class Twenty_fifthPalindrom {
static int[] a = new int[5];
static int[] b = new int[5];
public static void main(String[] args) {
boolean is =false;
Scanner s = new Scanner(System.in);
long l = s.nextLong();
if (l > 99999 || l < 10000) {
System.out.println("Input error,please input again!");
l = s.nextLong();
}
for (int i = 4; i >= 0; i--) {
a[i] = (int) (l / (long) Math.pow(10,i));
l =(l % ( long) Math.pow(10, i));
}
System.out.println();
for(int i=0,j=0; i<5; i++, j++) {
b[j] = a[i];
}
for(int i=0,j=4; i<5; i++, j--) {
if(a[i] != b[j]) {
is = false;
break;
} else {
is = true;
}
}
if(is == false) {
System.out.println("is not aPalindrom!");
} else if(is == true) {
System.out.println("is aPalindrom!");
}
}
}
这个更好，不限位数
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.print("
请输入一个正整数：");
long a = s.nextLong();
String ss = Long.toString(a);
char[] ch = ss.toCharArray();
boolean is =true;
int j=ch.length;
for(int i=0; i
if(ch[i]!=ch[j-i-1]){is=false;}
}
if(is==true){System.out.println("
这是一个回文数");}
else {System.out.println("
这不是一个回文数");}
}
/*
【程序26】
*
作者 南枫题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续 判断第二个字母。
1.
程序分析：用情况语句比较好，如果第一个字母一样，则判断用情况语句或if语句判断第二个字母。此程序虽然实现了基本功能，但必须严格按照题目的要求输入，否则程序无法执行
**/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class Twenty_sixthWeek {
Scanner s = new Scanner(System.in);
public static void main(String[] args) {
Twenty_sixthWeek tw = newTwenty_sixthWeek();
char ch = tw.getChar();
switch(ch) {
case 'M':
System.out.println("Monday");
break;
case 'W':
System.out.println("Wednesday");
break;
case 'F':
System.out.println("Friday");
break;
case 'T': {
System.out.println("pleaseinput the second letter!");
char ch2 = tw.getChar();
if(ch2 == 'U'){System.out.println("Tuesday"); }
else if(ch2 == 'H'){System.out.println("Thursday"); }
};
break;
case 'S': {
System.out.println("pleaseinput the scecond letter!");
char ch2 = tw.getChar();
if(ch2 == 'U') {System.out.println("Sunday");}
else if(ch2 == 'A'){System.out.println("Saturday"); }
};
break;
}
}
public char getChar() {
String str = s.nextLine();
char ch = str.charAt(0);
if(ch<'A' || ch>'Z') {
System.out.println("Input error,please input a capital letter");
getChar();
}
return ch;
}
}
/*
【程序27】
*
作者 南枫题目：求100之内的素数
1.
程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。
**/
packagecn.com.flywater.FiftyAlgorthm;
public class Twenty_seventhPrimeNumber {
public static void main(String[] args) {
boolean b =false;
int count = 0;
for(int i=2; i<100; i+=1) {
for(int j=2; j<=Math.sqrt(i); j++){
if(i % j == 0) {
b = false;
break;
} else{
b = true;
}
}
if(b == true) {
count ++;
System.out.print(i + " ");
}
}
System.out.println('\n' + "Thenumber of PrimeNumber is :" + count);
}
}
/*【程序28】
*
作者 南枫题目：对10个数进行排序
1.
程序分析：可以利用选择法，即从后9个比较过程中，选择一个最小的与第一个元素交换， 下次类推，即用第二个元素与后8个进行比较，并进行交换。
**/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class Twehty_eighthNumberSort {
publicstatic void main(String[] args) {
Scanner s = new Scanner(System.in);
int[] a = new int[10];
for(int i=0; i<10; i++) {
a[i] = s.nextInt();
}
for(int i=0; i<10; i++) {
for(int j=i+1; j<10; j++) {
if(a[i] > a[j]) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
for(int i=0; i<10; i++) {
System.out.print(a[i] + "");
}
}
}
/*
【程序29】
*
作者 南枫
*
按程序分析，好像只是求主对角线的和题目：求一个3*3矩阵对角线元素之和
1.
程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。
**/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class Twenty_ninthCrossSum {
publicstatic void main(String[] args) {
Scanner s = new Scanner(System.in);
int[][] a = new int[3][3];
for(int i=0; i<3; i++) {
for(int j=0; j<3; j++) {
a[i][j] = s.nextInt();
}
}
System.out.println("
输入的3
* 3 矩阵是:");
for(int i=0; i<3; i++) {
for(int j=0; j<3; j++) {
System.out.print(a[i][j] + "");
}
System.out.println();
}
int sum = 0;
for(int i=0; i<3; i++) {
for(int j=0; j<3; j++) {
if(i == j) {
sum += a[i][j];
}
}
}
System.out.println("
对角线和是" + sum);
}
}
/*
【程序30】
*
作者 南枫题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
1.
程序分析：首先判断此数是否大于最后一个数，然后再考虑插入中间的数的情况，插入后此元素之后的数，依次后移一个位置。
**/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class ThirtiethInsert {
public static void main(String[] args) {
int[] a = new int[]{1, 2, 3, 4, 5, 6,7};
int[] b = new int[a.length+1];
int t1 =0, t2 = 0;
int i =0;
Scanner s= new Scanner(System.in);
int num = s.nextInt();
/*
*
定义两个数组a，b，一个a的长度比另一个b大1，a看做是
*
已经排好序的。
*
接下来的过程是
* 1:
如果num比最后一个数大，把num赋值给数组b的最后一个数
*
再按顺序把a的每个元素赋给b
* 2:
否则（num不比a 的最后一个数大），
*
如果a的元素比num 小，则将这些元素按顺序赋给b
*
将num赋给比num大的b数组的元素，
*
跳出第一个for循环。
* 3:
定义一个循环控制变量，从num传给数组后num的下标值加一开始；
*
直到b的结尾，将剩下的a的值赋给b,赋值的过程是b[j]= a[i-1];
*
*/
if(num >= a[a.length-1]) {
b[b.length-1] = num;
for(i=0; i
b[i] = a[i];
}
} else {
for(i=0; i
if(num >= a[i]) {
b[i] = a[i];
} else {
b[i] = num;
break;
}
}
for(int j=i+1; j
b[j] = a[j-1];
}
}
for (i = 0; i < b.length; i++) {
System.out.print(b[i] + "");
}
}
}
/*
【程序21】
*
作者 南枫题目：求1+2!+3!+...+20!的和
1.
程序分析：此程序只是把累加变成了累乘。
*/
package cn.com.flywater.FiftyAlgorthm;
public class Twenty_firstFactorialSum {
static long sum = 0;
static long fac = 0;
public static void main(String[] args) {
long sum = 0;
long fac = 1;
for(int i=1; i<=10; i++) {
fac = fac * i;
sum += fac;
}
System.out.println(sum);
}
}
/*
【程序32】
*
作者 南枫题目：取一个整数a从右端开始的4～7位。程序分析：可以这样考虑：
(1)
先使a右移4位。
(2)
设置一个低4位全为1,其余全为0的数。可用~(~0< <4)
(3)
将上面二者进行&运算。
**/
/*
这个题我不会做，如有高手路过，还望指点
*
*/
package cn.com.flywater.FiftyAlgorthm;
public class Thirty_secondFS {
public static void main(String[] args) {
}
}
我没有用提示的方法，采用了字串截取。
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
boolean is =true;
System.out.print("
请输入一个7位以上的正整数：");
long a = s.nextLong();
String ss = Long.toString(a);
char[] ch = ss.toCharArray();
int j=ch.length;
if (j<7){System.out.println("
输入错误！");}
else {
System.out.println("
截取从右端开始的4～7位是："+ch[j-7]+ch[j-6]+ch[j-5]+ch[j-4]);
}
}
【程序33】
*
作者 南枫题目：打印出杨辉三角形（要求打印出10行如下图）
1.
程序分析：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
*/
/*
*
网上千篇一律是这种写法，我也没有什么创新，
* a[i][j]=a[i-1][j]+a[i-1][j-1]
就是这个程序的核心
*
定义的是二维数组，为了使输出的结果看起来漂亮一点
*
可以用for（int
k=0; k<2*(10-i)-1; k++）控制输出的空格
*
这个循环是在控制行数的循环里面，控制列数的循环外面。
*
记得在输出菱形时为了控制下半部分的输出，在下拼命的写出
* for(int k=1; k<=WIDTH-2*i-1; k++)
才算了事。
*/
package cn.com.flywater.FiftyAlgorthm;
public class Thirty_thirdYangTriangle {
public static void main(String[] args) {
int[][] a = new int[10][10];
for(int i=0; i<10; i++) {
a[i][i] = 1;
a[i][0] = 1;
}
for(int i=2; i<10; i++) {
for(int j=1; j
a[i][j] = a[i-1][j-1] + a[i-1][j];
}
}
for(int i=0; i<10; i++) {
for(int k=0; k<2*(10-i)-1; k++) {
System.out.print(" ");
}
for(int j=0; j<=i; j++) {
System.out.print(a[i][j] +" ");
}
System.out.println();
}
}
}
/*
【程序34】
*
作者 南枫题目：输入3个数a,b,c，按大小顺序输出。
1.
程序分析：利用指针方法。
*/
/*
*
可惜，Java好像没有指针
*/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class Thirty_forthCompare {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int a = s.nextInt();
int b = s.nextInt();
int c = s.nextInt();
if(a < b) {
int t = a;
a = b;
b = t;
}
if(a < c) {
int t = a;
a = c;
c = t;
}
if(b < c) {
int t = b;
b = c;
c = t;
}
System.out.println("
从大到小的顺序输出:");
System.out.println(a + " " +b + " " + c);
}
}
/*
【程序35】
*
作者 南枫题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
**/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class Thirty_fifthSwop {
static final int N = 8;
public static void main(String[] args) {
int[] a = new int [N];
Scanner s = new Scanner(System.in);
int index1 = 0, index2 = 0;
System.out.println("please inputnumbers");
for(int i=0; i
a[i] = s.nextInt();
System.out.print(a[i] + "");
}
int max =a[0], min = a[0];
for(int i=0; i
if(a[i] > max) {
max = a[i];
index1 = i;
}
if(a[i] < min) {
min = a[i];
index2 = i;
}
}
if(index1 != 0) {
int temp = a[0];
a[0] = a[index1];
a[index1] = temp;
}
if(index2 != a.length-1) {
int temp = a[a.length-1];
a[a.length-1] = a[index2];
a[index2] = temp;
}
System.out.println("afterswop:");
for(int i=0; i
System.out.print(a[i] + "");
}
}
}
/*
【程序36】
*
作者 南枫题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
**/
/*
*
这个题不知道有什么好办法，比较直接方法的是把这个数组分成两个数组，
*
再将两个数组合起来，但如果不控制好数组的下标，就会带来很多麻烦。
*/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class Thirty_sixthBackShift {
public static final int N =10;
public static void main(String[] args) {
int[] a = new int[N];
Scanner s = new Scanner(System.in);
System.out.println("please inputarray a, ten numbers:");
for(int i=0; i
a[i] = s.nextInt();
}
System.out.println("please inputm , one number:");
int m = s.nextInt();
int[] b = new int[m];
int[] c = new int[N-m];
for(int i=0; i
b[i] = a[i];
}
for(int i=m,j=0; i
c[j] = a[i];
}
for(int i=0; i
a[i] = c[i];
}
for(int i=m,j=0; i
a[i] = b[j];
}
for(int i=0; i
System.out.print(a[i] + "");
}
}
}
/*
【程序37】
*
作者 南枫题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
**/
/*
*
这个程序是完全抄别人的
*/
package cn.com.flywater.FiftyAlgorthm;
import java.util.Scanner;
public class Thirty_sevenCount3Quit {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
boolean[] arr = new boolean[n];
for(int i=0; i
arr[i] = true;//
下标为TRUE时说明还在圈里
}
int leftCount = n;
int countNum = 0;
int index = 0;
while(leftCount > 1) {
if(arr[index] == true) {//
当在圈里时
countNum ++; //
报数递加
if(countNum == 3) {//
报道3时
countNum =0;//
从零开始继续报数
arr[index] = false;//
此人退出圈子
leftCount --;//
剩余人数减一
}
}
index ++;//
每报一次数，下标加一
if(index == n) {//
是循环数数，当下标大于n时，说明已经数了一圈，
index = 0;//
将下标设为零重新开始。
}
}
for(int i=0; i
if(arr[i] == true) {
System.out.println(i);
}
}
}
}
/*
【程序38】
*
作者 南枫题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。
*/
package cn.com.flywater.FiftyAlgorthm;
public class Thirty_eighthStringLength {
public static void main(String[] args) {
String s = "jdfifdfhfhuififffdfggee";
System.out.print("
字符串的长度是：");
System.out.println(s.length());
}
}
*
【程序39】
*
作者 南枫题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,
当输入n为奇数时，调用函数1/1+1/3+...+1/n(利用指针函数)
**/
package cn.com.flywater.FiftyAlgorthm;
import java.text.DecimalFormat;
import java.util.*;
public class Thirty_ninthFactionSum {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n = s.nextInt();
DecimalFormat df = newDecimalFormat("#0.00000");
System.out.println( n +" ****result " + df.format(sum(n)));
}
public static double sum(int n) {
double result = 0;
if(n % 2 == 0) {
for(int i=2; i<=n; i+=2) {
result += (double)1 / n;
}
} else {
for(int i=1; i<=n; i+=2) {
result += (double)1 / i ;
}
}
return result;
}
}
/*
【程序40】
*
作者 南枫题目：字符串排序。
**/
package cn.com.flywater.FiftyAlgorthm;
public class FortiethStringSort {
publicstatic void main(String[] args) {
String temp = null;
String[] s = new String[5];
s[0] ="china".toLowerCase();
s[1] = "apple".toLowerCase();
s[2] ="MONEY".toLowerCase();
s[3] = "BOOk".toLowerCase();
s[4] = "yeah".toLowerCase();
/*
for(int i=0; i
for(int j=i+1; j
if(s[i].compareToIgnoreCase(s[j])> 0) {
temp = s[i];
s[i] = s[j];
s[j] = temp;
}
}
}*/
for(int i=0; i
for(int j=i+1; j
if(compare(s[i], s[j]) == false) {
temp = s[i];
s[i] = s[j];
s[j] = temp;
}
}
}
for(int i=0; i
System.out.println(s[i]);
}
}
static boolean compare(String s1, String s2) {
boolean result = true;
for(int i=0; i
if(s1.charAt(i) > s2.charAt(i)) {
result = false;
break;
} else if(s1.charAt(i)
result = true;
break;
} else {
if(s1.length() < s2.length()) {
result = true;
} else {
result = false;
}
}
}
return result;
}
}
LinkedList
类里面较重要的方法就是"addBefore(){}"和"privatevoid remove(DNode curr){}"
很多方法都与它俩有关系!!
下面的代码是个双向循环链表,在LinkedList里抄的...
package LinkedList;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.NoSuchElementException;
public class MyLinkedList {
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
private DNode header;
private int listSize;
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
public MyLinkedList() {
header = new DNode();
listSize = 0;
}
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
private static class DNode {
T nodeValue;
DNode prev;
DNode next;
public DNode() { // for header
nodeValue = null;
prev = this; // left
next = this; // right
}
public DNode(T item) {
nodeValue = item;
prev = this;
next = this;
}
}
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
public boolean isEmpty() {
return (header.prev == header ||header.next == header);
}
public int size() {
return listSize;
}
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
private DNodeaddBefore(DNode curr, T item) {
DNode newNode, prevNode;
newNode = newDNode(item);
prevNode = curr.prev;
newNode.prev = prevNode;
newNode.next = curr;
prevNode.next = newNode;
curr.prev = newNode;
return newNode;
}
public boolean add(T item) {
addBefore(header, item);
listSize++;
return true;
}
public void addFirst(T item) {
addBefore(header.next, item);
listSize++;
}
public void addLast(T item) {
addBefore(header, item);
listSize++;
}
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
private void remove(DNodecurr) {
if(curr.next == curr) return;
DNode prevNode =curr.prev, nextNode = curr.next;
prevNode.next = nextNode;
nextNode.prev= prevNode;
}
public boolean remove(Object o) {
for(DNode p =header.next; p != header; p = p.next) {
if(o.equals(p.nodeValue)) {
remove(p);
listSize--;
return true;
}
}
return false;
}
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
public void printList() {
for(DNode p =header.next; p != header; p = p.next)
System.out.println(p.nodeValue);
}
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
private class MyIterator implementsIterator {
public DNode nextNode =header.next;
public DNodelastReturned = header;
public boolean hasNext() {
return nextNode != header;
}
public T next() {
if(nextNode == header)
throw newNoSuchElementException("");
lastReturned = nextNode;
nextNode = nextNode.next;
returnlastReturned.nodeValue;
}
public void remove() {
if(lastReturned == header)
throw newIllegalStateException("");
MyLinkedList.this.remove(lastReturned);
lastReturned = header;
listSize--;
}
}
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
private class MyListIterator extendsMyIterator implements ListIterator {
private int nextIndex;
MyListIterator(int index) {
if(index < 0 || index >listSize)
throw newIndexOutOfBoundsException("");
//
如果index小于listSize/2，就从表头开始查找定位，否则就从表尾开始查找定位
if(index < (listSize>> 1)) {
nextNode = header.next;
for(nextIndex = 0;nextIndex < index; nextIndex++)
nextNode =nextNode.next;
}else {
nextNode = header;
for(nextIndex = listSize;nextIndex > index; nextIndex--)
nextNode =nextNode.prev;
}
}
public boolean hasPrevious() {
return nextIndex != 0;
//return nextNode.prev !=header;
}
public T previous() {
if (nextIndex == 0)
throw newNoSuchElementException("no");
lastReturned = nextNode =nextNode.prev;
nextIndex--;
returnlastReturned.nodeValue;
}
public void remove() {
if(lastReturned == header)
throw newIllegalStateException("");
MyLinkedList.this.remove(lastReturned);
nextIndex--;
listSize--;
if(lastReturned == nextNode)
nextNode = nextNode.next;
lastReturned = header;
}
public void add(T item) {
MyLinkedList.this.addBefore(nextNode, item);
nextIndex++;
listSize++;
lastReturned = header;
}
public void set(T item) {
if (lastReturned == header)
throw newIllegalStateException();
lastReturned.nodeValue =item;
}
public int nextIndex() {
return nextIndex;
}
public int previousIndex() {
return nextIndex - 1;
}
}
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
public Iterator iterator() {
return new MyIterator();
}
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
public ListIteratorlistIterator(int index) {
return new MyListIterator(index);
}
//
～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
public static void main(String[]args) {
MyLinkedList t =new MyLinkedList();
t.add("A");
t.add("B");
t.add("C");
t.add("D");
//t.remove("B");
//t.addFirst("AA");
//t.addLast("BB");
//t.printList();
ListIterator it =t.listIterator(t.size());
while(it.hasPrevious()) {
System.out.println(it.previous());// D C B A
}
}
}// MyLinkedList end
～
ArrayList
底层数组实现的,当实例化一个ArrayList是也相当实例化了一个数组所以对元素的随即访问较快,而增加删除操作慢
LinkedList
底层实现是一个双向链表,没一个结点都包含了前一个元素的引用和后一个元素的引用和结点值所以对元素的随即访问很慢,而增删较快
java
实现链表和c实现一样。就是指针变成了引用。【参考资料】JAVA的链表(2009-05-11
01:35:49)标签：java链表 分类：学习资料又是个不错的地方：http://blog.sina.com.cn/s/articlelist_1282789430_0_1.html
链表是一种重要的数据结构，在程序设计中占有很重要的地位。C语言和C＋＋语言中是用指针来实现链表结构的，由于Java语言不提供指针，所以有人认为在Java语言中不能实现链表，其实不然，Java语言比C和C＋＋更容易实现链表结构。Java语言中的对象引用实际上是一个指针（本文中的指针均为概念上的意义，而非语言提供的数据类型），所以我们可以编写这样的类来实现链表中的结点。 class Node
{
Object data;
Node next;//指向下一个结点 }
将数据域定义成Object类是因为Object类是广义超类，任何类对象都可以给其赋值，增加了代码的通用性。为了使链表可以被访问还需要定义一个表头，表头必须包含指向第一个结点的指针和指向当前结点的指针。为了便于在链表尾部增加结点，还可以增加一指向链表尾部的指针，另外还可以用一个域来表示链表的大小，当调用者想得到链表的大小时，不必遍历整个链表。下图是这种链表的示意图： 链表的数据结构 我们可以用类List来实现链表结构，用变量Head、Tail、Length、Pointer来实现表头。存储当前结点的指针时有一定的技巧，Pointer并非存储指向当前结点的指针，而是存储指向它的前趋结点的指针,当其值为null时表示当前结点是第一个结点。那么为什么要这样做呢？这是因为当删除当前结点后仍需保证剩下的结点构成链表，如果Pointer指向当前结点，则会给操作带来很大困难。那么如何得到当前结点呢，我们定义了一个方法cursor(),返回值是指向当前结点的指针。类List还定义了一些方法来实现对链表的基本操作，通过运用这些基本操作我们可以对链表进行各种操作。例如reset()方法使第一个结点成为当前结点。insert(Object
d)方法在当前结点前插入一个结点，并使其成为当前结点。remove()方法删除当前结点同时返回其内容，并使其后继结点成为当前结点，如果删除的是最后一个结点，则第一个结点变为当前结点。 链表类List的源代码如下： import java.io.*;
public class List
{
private Node Head=null;
private Node Tail=null;
private Node Pointer=null;
private int Length=0;
public void deleteAll()
{
Head=null;
Tail=null;
Pointer=null;
Length=0;
}
public void reset()
{
Pointer=null;
}
public boolean isEmpty()
{
return(Length==0);
}
public boolean isEnd()
{
if(Length==0)
throw newjava.lang.NullPointerException();
else if(Length==1)
return true;
else
return(cursor()==Tail);
}
public Object nextNode()
{
if(Length==1)
throw newjava.util.NoSuchElementException();
else if(Length==0)
throw newjava.lang.NullPointerException();
else
{
Node temp=cursor();
Pointer=temp;
if(temp!=Tail)
return(temp.next.data);
else
throw newjava.util.NoSuchElementException();
}
}
public Object currentNode()
{
Node temp=cursor();
return temp.data;
}
public void insert(Object d)
{
Node e=new Node(d);
if(Length==0)
{
Tail=e;
Head=e;
}
else
{
Node temp=cursor();
e.next=temp;
if(Pointer==null)
Head=e;
else
Pointer.next=e;
}
Length＋＋;
}
public int size()
{
return (Length);
}
public Object remove()
{
Object temp;
if(Length==0)
throw newjava.util.NoSuchElementException();
else if(Length==1)
{
temp=Head.data;
deleteAll();
}
else
{
Node cur=cursor();
temp=cur.data;
if(cur==Head)
Head=cur.next;
else if(cur==Tail)
{
Pointer.next=null;
Tail=Pointer;
reset();
}
else
Pointer.next=cur.next;
Length－－;
}
return temp;
}
private Node cursor()
{
if(Head==null)
throw newjava.lang.NullPointerException();
else if(Pointer==null)
return Head;
else
return Pointer.next;
}
public static void main(String[] args)
{
List a=new List ();
for(int i=1;i<=10;i＋＋)
a.insert(new Integer(i));
System.out.println(a.currentNode());
while(!a.isEnd())
System.out.println(a.nextNode());
a.reset();
while(!a.isEnd())
{
a.remove();
}
a.remove();
a.reset();
if(a.isEmpty())
System.out.println("There is noNode in List \n");
System.in.println("You can pressreturn to quit\n");
try
{
System.in.read();
//确保用户看清程序运行结果 }
catch(IOException e)
{}
}
}
class Node
{
Object data;
Node next;
Node(Object d)
{
data=d;
next=null;
}
}