「链表求和java」链表相加求和
今天给各位分享链表求和java的知识，其中也会对链表相加求和进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、java使用LinkedList进行大数相加，求指点。。。
- 2、用java单链表实现一元多项式相加的算法。（）
- 3、HDU1236 Java代码一直WA,求解,附代码附注释
- 4、为什么说python是人工智能的首选语言
- 5、用java单链表实现一元多项式相加的算法？
java使用LinkedList进行大数相加，求指点。。。
public
static void main(String[] args) {
// TODO Auto-generated method stub
ListInteger bigNumber =
new LinkedListInteger();
for(int i = 0; i 30; i++) {
bigNumber.add(7);
}
ListInteger bigNumber1 =
new LinkedListInteger();
for(int i = 0; i 30; i++) {
bigNumber1.add(6);
}
System.
out.println("bigNumber:"+bigNumber);
System.
out.println("bigNumber1:"+bigNumber1);
ListInteger m = addMethod(bigNumber, bigNumber1);
for(int i = m.size()-1; i =0; i--){ //因为是顺着放进去的，所以应该倒着取出来。
System.
out.print(m.get(i));
}
}
public static ListInteger addMethod(ListInteger a, ListInteger b) {
ListInteger sum =
new LinkedListInteger();
int ii = 0; //存储十位上的数
for(int i = 0; i 30; i++) {
int temp;
if(ii 0){
temp = a.get(i) + b.get(i) + ii;
//当十位上有数字是就应该加上
ii = 0;
}
else{
temp = a.get(i) + b.get(i);
}
if(temp = 10) {
int u = temp%10;
int y = temp/10;
sum.add(u);
ii = y;
if(i == 29){ //当加到最后一位时，应该把十位也放进结果里
sum.add(ii);
}
}
else {
sum.add(temp);
}
}
return sum;
}
用java单链表实现一元多项式相加的算法。（）
public class Test {
public static void main(String[] args) {
try{
LinkList list1 = new LinkList();
LinkList list2 = new LinkList();
LinkList list3 = null;
list1.addAt(0, new Item(1, 5));
list1.addAt(1, new Item(-1.5, 3));
list1.addAt(2, new Item(1, 1));
list2.addAt(0, new Item(0.5, 5));
list2.addAt(1, new Item(0.5, 4));
list2.addAt(2, new Item(1.5, 3));
list2.addAt(3, new Item(3, 0));
list3 = mergeLinkList(list1, list2);
System.out.println("一元多项式的相加过程：");
list1.listAll();
System.out.println(" + ");
list2.listAll();
System.out.println(" = ");
list3.listAll();
}
catch(Exception e){
e.printStackTrace();
}
}
//两个一元多项式相加，返回新的一元多项式
public static LinkList mergeLinkList(LinkList list1, LinkList list2){
int i = 0;
Item item = new Item();
Node curr1, curr2;
LinkList list3 = new LinkList();
curr1 = list1.getHead().getNext();
curr2 = list2.getHead().getNext();
while(curr1 != null curr2 != null){
if(curr1.getData().getExp() curr2.getData().getExp()){
item = curr1.getData();
list3.addAt(i, item);
curr1 = curr1.getNext();
i++;
}
else if(curr1.getData().getExp() curr2.getData().getExp()){
item = curr2.getData();
list3.addAt(i, item);
curr2 = curr2.getNext();
i++;
}
else{
item = new Item(curr1.getData().getCoef() + curr2.getData().getCoef(), curr1.getData().getExp());
if(item.getCoef() != 0){
list3.addAt(i, item);
i++;
}
curr1 = curr1.getNext();
curr2 = curr2.getNext();
}
}
while(curr1 != null){
item = curr1.getData();
list3.addAt(i++, item);
curr1 = curr1.getNext();
}
while(curr2 != null){
item = curr2.getData();
list3.addAt(i++, item);
curr2 = curr2.getNext();
}
return list3;
}
}
/**
* 一元多项式的一般项类
*/
class Item{
private double coef; //一元多项式的一般项的系数
private int exp; //一元多项式的一般项的指数
public Item(){
this.coef = 0.0;
this.exp = 0;
}
public Item(double coef, int exp){
this.coef = coef;
this.exp = exp;
}
public double getCoef(){
return this.coef;
}
public void setCoef(double coef){
this.coef = coef;
}
public int getExp(){
return this.exp;
}
public void setExp(int exp){
this.exp = exp;
}
}
/**
* 链表结点类
*/
class Node{
private Item data;
private Node next; //链表结点的指针域，指向直接后继结点
public Node(){
data = null;
next = null;
}
public Node(Item data, Node next){
this.data = data;
this.next = next;
}
public Item getData(){
return this.data;
}
public void setData(Item data){
this.data = data;
}
public Node getNext(){
return this.next;
}
public void setNext(Node next){
this.next = next;
}
}
/**
* 链表类
*/
class LinkList{
private Node head = null; //头结点指针
private int size = 0;
public LinkList(){
head = new Node();
size = 0;
}
//在i位置插入元素elem
public boolean addAt(int i, Item elem) {
if(i 0 || i size){
return false;
}
Node pre,curr;
int pos;
for(pre=head; i0 pre.getNext()!=null; i--,pre=pre.getNext());
curr = new Node(elem, pre.getNext());
pre.setNext(curr);
size++;
return true;
}
//删除i位置的元素
public boolean removeAt(int i) {
if(i 0 || i = size){
return false;
}
Node pre,curr;
for(pre=head; i0 pre.getNext()!=null; i--,pre=pre.getNext());
curr = pre.getNext();
pre.setNext(curr.getNext());
size--;
return true;
}
//根据值value查询结点是否存在，若存在返回位置，否则返回-1
public int findByValue(Item value){
Node curr;
int pos;
for(pos=0,curr=head.getNext(); curr!=null; pos++,curr=curr.getNext()){
if(curr.getData().toString().equals(value.toString())){
break;
}
}
if(curr==null){
return -1;
}
return pos;
}
public Node getHead(){
return this.head;
}
public void setHead(Node head){
this.head = head;
}
public int getSize(){
return this.size;
}
public boolean isEmpty(){
return (size==0);
}
public void listAll(){
for(Node curr=head.getNext(); curr!=null; curr=curr.getNext()){
System.out.print("(" + curr.getData().getCoef() + ", " + curr.getData().getExp() + ")\t");
}
System.out.println();
}
}
HDU1236 Java代码一直WA,求解,附代码附注释
import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); // in.hasNextInt() 用来判断是否还能读取int while(in.hasNextInt()) { int n = in.nextInt(); int u = in.nextInt(); int d = in.nextInt(); if(n == 0) System.exit(1); int sum = 0; int time = 0; while(true) { sum += u; time ++; if(sum = n) break; sum -= d; time ++; } System.out.println(time); } } }
为什么说python是人工智能的首选语言
为什么Python是人工智能技术首选的编程语言？
原因1：Python是一种说人话的语言
所谓"说人话"，是指这种语言：
开发者不需要关注底层
语法简单直观
表达形式一致
我们先来看几个代码的例子：
C 语言Hello World 代码：
int main(){ printf("Hello, World!"); return 0;}
Java 语言Hello World 代码：
public class HelloWorld { public static void main(String[] args){ System.out.println("Hello World!"); }}
Python 语言Hello World代码：
print("Hello World!")
仅仅是一个Hello World程序，就能看出区别了，是不是？
编译 VS 解释
当然，仅仅是一个Hello World的话，C和Java的代码也多不了几行。
可是不要忘了，C和Java的代码要运行，都必须先经过编译的环节。
对于C语言来说，在不同的操作系统上使用什么样的编译器，也是一个需要斟酌的问题。一旦代码被copy到新的机器，运行环境和之前不同，还需要重新编译，而那台机器上有没有编译器还是一个问题，安装上编译器后，也许和之前最初的编译器有所区别，还得修改源代码来满足编译环境的需求……
我到底做错了什么？我只是想运行一个别人写的程序而已。
而Python则不用编译，直接运行。而且都可以不用写文件，一条条语句可以直接作为命令行运行，真的太方便了。
语言语法
和Python比，Java的语法更"啰嗦"。
从上面的例子已经可以看出，创建一个链表，Java还需要声明和逐个插入节点，而Python则可一行代码完成从链表创建到插入节点及赋值的全部操作。
Java非让你很别扭地写好几行，Python直接一句搞定。
这样的结果就是，Python写起来省事，读起来也方便。可读性远超Java。
表达风格
在10年或者更久远之前，Python经常被用来和Perl相提并论。毕竟在那个时候，C是系统级语言，Java是面向对象语言，而Python Perl则是脚本语言的双子星。
Python和Perl在设计层面有一个非常大的区别：
Python力求让不同的人在撰写同样功能实现的代码时，所用的表达形式尽量一致；
而Perl则是故意追求表达的千姿百态，让同一个人在不同地方写同样功能时所用具体形式都不同。
从哲学层面讲，Perl的追求更加自由主义，更利于释放人类的多样化天性。然而，Perl写的程序——那叫一个乱七八糟！
如果不是想成为代码诗人，或者语言大师，只是想用尽量简单直接的方法，把事情做了，首选语言确实是Python。
原因2：强大的AI支持库
矩阵运算
NumPy由数据科学家Travis Oliphant创作，支持维度数组与矩阵运算。结合Python内置的math和random库，堪称AI数据神器！有了它们，就可以放心大胆玩矩阵了！
大家知道，不管是Machine Learning，还是Deep Learning，模型、算法、网络结构都可以用现成的，但数据是要自己负责I/O并传递给算法的。
而各种算法，实际上处理的都是矩阵和向量。
使用NumPy，矩阵的转置、求逆、求和、叉乘、点乘……都可以轻松地用一行代码搞定，行、列可以轻易抽取，矩阵分解也不过是几行代码的问题。
而且，NumPy在实现层对矩阵运算做了大量的并行化处理，通过数学运算的精巧，而不是让用户自己写多线程程序，来提升程序效率。
有了Python这种：语法简洁明了、风格统一；不需要关注底层实现；连矩阵元素都可以像在纸上写公式一样；写完公式还能自动计算出结果的编程语言，开发者就可以把工作重心放在模型和算法上了。
用java单链表实现一元多项式相加的算法？
public class Test {
public static void main(String[] args) {
try{
LinkList list1 = new LinkList();
LinkList list2 = new LinkList();
LinkList list3 = null;
list1.addAt(0, new Item(1, 5));
list1.addAt(1, new Item(-1.5, 3));
list1.addAt(2, new Item(1, 1));
list2.addAt(0, new Item(0.5, 5));
list2.addAt(1, new Item(0.5, 4));
list2.addAt(2, new Item(1.5, 3));
list2.addAt(3, new Item(3, 0));
list3 = mergeLinkList(list1, list2);
System.out.println("一元多项式的相加过程：");
list1.listAll();
System.out.println(" + ");
list2.listAll();
System.out.println(" = ");
list3.listAll();
}
catch(Exception e){
e.printStackTrace();
}
}
/**
* 一元多项式的一般项类
*/
class Item{
private double coef; //一元多项式的一般项的系数
private int exp; //一元多项式的一般项的指数
public Item(){
this.coef = 0.0;
this.exp = 0;
}
public Item(double coef, int exp){
this.coef = coef;
this.exp = exp;
}
public double getCoef(){
return this.coef;
}
public void setCoef(double coef){
this.coef = coef;
}
public int getExp(){
return this.exp;
}
public void setExp(int exp){
this.exp = exp;
}
}
/**
* 链表结点类
*/
class Node{
private Item data;
private Node next; //链表结点的指针域，指向直接后继结点
public Node(){
data = null;
next = null;
}
public Node(Item data, Node next){
this.data = data;
this.next = next;
}
public Item getData(){
return this.data;
}
public void setData(Item data){
this.data = data;
}
public Node getNext(){
return this.next;
}
public void setNext(Node next){
this.next = next;
}
}
/**
* 链表类
*/
class LinkList{
private Node head = null; //头结点指针
private int size = 0;
public LinkList(){
head = new Node();
size = 0;
}
//在i位置插入元素elem
public boolean addAt(int i, Item elem) {
if(i 0 || i size){
return false;
}
Node pre,curr;
int pos;
for(pre=head; i0 pre.getNext()!=null; i--,pre=pre.getNext());
curr = new Node(elem, pre.getNext());
pre.setNext(curr);
size++;
return true;
}
//删除i位置的元素
public boolean removeAt(int i) {
if(i 0 || i = size){
return false;
}
Node pre,curr;
for(pre=head; i0 pre.getNext()!=null; i--,pre=pre.getNext());
curr = pre.getNext();
pre.setNext(curr.getNext());
size--;
return true;
}
java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。
关于链表求和java和链表相加求和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。