if（points[j].x==points[i].x&&points[j].y==points[i].x）{
dup++;
continue;
}
//如果这两个点只是x的值相等但是y值不等，那么让key值等integer.max_value
doublekey=points[j].x-points[i].x==0?
Integer.MAX_VALUE:
0.0+（double）（points[j].y-points[i].y）/（double）（points[j].x-points[i].x）;
if（map.containsKey（key））{
map.put（key,map.get（key）+1）;
}else{
//这一步是怎么回事啊，为什么要放如2呢？
//第一次开始的时候，斜率k值还不存在，上面的式子说明存在连个点斜率相同，讲k值设置为2，如果是上面的式子中
//的k值没有相同的也没有关系，我把k值设置为了最大值integer。
maxint
map.put（key,2）;
}
}
for（inttemp:
map.values（））{
//可能存在重复
if（temp+dup>max）{
max=temp+dup;
}
}
}
returnmax;
}
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
Pointpoint1=newPoint（4,4）;
Pointpoint2=newPoint（4,2）;
Pointpoint3=newPoint（6,3）;
Pointpoint4=newPoint（2,1）;
Pointpoint5=newPoint（10,5）;
Point[]s=newPoint[5];
s[0]=point1;
s[1]=point2;
s[2]=point3;
s[3]=point4;
s[4]=point5;
System.out.println（maxPoints（s））;
}
}
classPoint{
intx;
inty;
Point（）{x=0;y=0;}
Point（inta,intb）{x=a;y=b;}
}
/*
*其实就是列表进行重新排序，显示分为两半，再将这两个列表进行重新排列，确定下一个，
*重新排序完成后，一定记着或许会留下来一个，因为可能这两半中有一个要比另一个大
*/
packagestudy;
publicclassReorderList{
publicListNode2reverse（ListNode2head）{
ListNode2newHead=null;
while（head!
=null）{
//得到最后的尾巴的值赋值为newHead
ListNode2temp=head.next;
head.next=newHead;
newHead=head;
head=temp;
//在这个里面就不需要再去对newHead的next进行赋值，因为么人个里面的dummy会做这件事
}
returnnewHead;
}
privatevoidmerage（ListNode2head1,ListNode2head2）{
intindex=0;
ListNode2dummy=newListNode2（0）;
while（head1!
=null&&head2!
=null）{
if（index%2==0）{
dummy.next=head1;
head1=head1.next;
}else{
dummy.next=head2;
head2=head2.next;
}
dummy=dummy.next;
index++;
}
if（head1!
=null）{
dummy.next=head1;
}else{
dummy.next=head2;
}
}
privateListNode2findMid（ListNode2head）{
ListNode2fast=head,slow=head;
while（fast!
=null&&fast.next!
=null）{
fast=fast.next.next;
slow=slow.next;
}
returnslow;
}
publicvoidreorderList（ListNode2head）{
if（head==null||head.next==null）{
return;
}
ListNode2mid=findMid（head）;
//注意这里是将后半部分进行反转；
ListNode2tail=reverse（mid.next）;
mid.next=null;
merage（head,tail）;
}
}
packagestudy;
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
publicclassReverseWordsInAString{
publicstaticStringreverseWords（Strings）{
if（s==null||s.length（）==0）{
return"";
}
String[]array=s.split（""）;
StringBuildersb=newStringBuilder（）;
for（inti=array.length-1;i>=0;--i）{
if（!
array[i].equals（""））{
sb.append（array[i]）.append（""）;
}
}
returnsb.length（）==0?
"":
sb.substring（0,sb.length（）-1）;
}
publicstaticvoidmain（Stringargs[]）throwsIOException{
BufferedReaderbr=newBufferedReader（newInputStreamReader（System.in））;
Stringinput=br.readLine（）;
Stringn=reverseWords（input）;
System.out.println（n）;
}
}
packagestudy;
publicclassSortList{
/**
*@paramargs
*/
privatestaticListNodefindMiddle（ListNodehead）{
//找到中间节点，归并排序的第一步
ListNodeslow=head,fast=head.next;
while（fast!
=null&&fast.next!
=null）{
//fast总是以比slow快2倍的速度去向下查找，这样就可以查找到中间节点
fast=fast.next.next;
slow=slow.next;
}
returnhead;
}
//归并排序第二步
privatestaticListNodemerge（ListNodehead1,ListNodehead2）{
ListNodedummy=newListNode（0）;
ListNodetail=dummy;
//建造一个类似与过渡变量的tail
while（head1!
=null&&head2!
=null）{
if（head1.val//先对tail赋值给head1或者head2中比较小的节点
tail.next=head1;
head1=head1.next;
}else{
//在对head1和head2的next赋值给head1和head2，方便下次循环的比较
tail.next=head2;
head2=head1.next;
}
//最后让中间过渡变量留下原先的，继续做为下一次循环时使用的中间过渡变量
升级会员 