目录
3.1代码的规范性
3.2代码的完整性
3.2.1数值的整数次方
3.2.2打印从1到最大的n位数
3.2.3删除链表的结点
题目一:在O(1)时间内删除链表结点
package test;
/**
* @author wyl
* @time 2018年8月10日下午2:34:46
* 删除链表的结点
*/
public class Test7 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ListNode node1=new ListNode(1);
ListNode node2=new ListNode(2);
ListNode node3=new ListNode(3);
ListNode node4=new ListNode(4);
node1.next=node2;
node2.next=node3;
node3.next=node4;
System.out.println("删除前:链表结点");
for(ListNode x=node1;x!=null;x=x.next){
System.out.print(x.val);
}
deleteNode(node1,node3);//栈实现 后进先出
System.out.println("\n删除后:链表结点");
for(ListNode x=node1;x!=null;x=x.next){
System.out.print(x.val);
}
}
private static void deleteNode(ListNode head, ListNode deleteNode) {
// TODO Auto-generated method stub
if (head==null || deleteNode==null) {
return;
}
/**
* 链表有多个结点,要删除的不是尾结点
* O(1)时间
*/
if (deleteNode.next!=null) {
ListNode tmp=deleteNode.next;//要删除结点的下一个结点
deleteNode.val=tmp.val;//把下一个结点的内容复制到需要删除结点上覆盖原来的内容
deleteNode.next=tmp.next;
tmp=null;//再删除下一个结点
}else if (head==deleteNode) {
/**
* 链表只有一个结点,删除头结点(也是尾结点)
* O(1)时间
*/
deleteNode=null;
head=null;
}else {
/**
* 链表有多个结点,要删除的是尾结点
* O(n)时间
*/
ListNode tmp=head;
while(tmp.next!=deleteNode){//遍历找到要删除的结点
tmp=tmp.next;
}
tmp.next=null;
deleteNode=null;
}
}
}
package test;
/**
* @author wyl
* @time 2018年8月10日下午2:36:55
*/
public class ListNode {
int val;
ListNode next=null;
public ListNode(int val) {
// TODO Auto-generated constructor stub
this.val=val;
}
}
题目二:删除链表中重复的结点
在一个排序的链表中,存在重复的结点,请删除该链表中重复的结点,重复的结点不保留,返回链表头指针。
栗子:1-2-3-3-4-4-5
处理后:1-2-5
借鉴别人的思路:
先定义一个first对象(值为-1,主要用于返回操作后的链表),first.next指向head
定义一个last同样指向first(主要用于操作记录要删除结点的前一个结点)
定义一个p指向head,指向当前结点
操作流程:
①先判断当前p指向与p.next指向是否为空,为空则进入⑤;否则进入②;
②判断当前节点p的值与p.next的值是否相等,如果相等,进入③;否则,进入④;
③记录p.val的值为val,循环判断val是否与当前p指向相等,相等的话p=p.next,last.next指向p;
④last指向p,p指向p.next;
⑤返回first.next;
package test;
/**
* @author wyl
* @time 2018年8月12日上午9:08:33
*/
public class Solution {
public ListNode deleteDuplication(ListNode pHead){
ListNode first=new ListNode(-1);
first.next=pHead;
ListNode last=first;//last指向删除结点的前一个结点
ListNode p=pHead;//指向当前结点
while(p!=null&&p.next!=null){
if (p.val==p.next.val) {//当前结点p的值与p.next的值相等
int val=p.val;
while(p!=null && p.val==val){
p=p.next;
}
last.next=p;
}else {//当前结点p的值与p.next的值不等
last=p;
p=p.next;
}
}
return first.next;
}
}
3.2.4正则表达式匹配
3.2.5表示数值的字符串
3.2.6调整数组顺序使奇数位于偶数前面
3.3代码的鲁棒性
3.3.1链表中倒数第k个结点
输入一个链表,输出该链表的倒数第k个结点。
为了符合大多数人的习惯,即链表尾结点是倒数第一个结点。
链表是单向链表,单链表的结点只有从前往后的指针而没有从后往前的指针。
为了实现只遍历链表一次,就能找到实现找到倒数第k个结点,可以定义两个指针:
第一个指针从链表的头指针开始遍历向前走k-1步,第二个指针保持不动;
从第k步开始,第二个指针也开始从链表的头指针开始遍历。
由于两个指针的距离保持在k-1,当第一个(走在前面的)指针到达链表的尾结点时,
第二个(走在后面的)指针正好指向倒数第k个结点。
package test;
/**
* @author wyl
* @time 2018年8月12日上午10:56:02
*/
public class Test11 {
public static void main(String[] args) {
ListNode node1=new ListNode(1);
ListNode node2=new ListNode(2);
ListNode node3=new ListNode(3);
ListNode node4=new ListNode(4);
ListNode node5=new ListNode(5);
ListNode node6=new ListNode(6);
ListNode node7=new ListNode(7);
node1.next=node2;
node2.next=node3;
node3.next=node4;
node4.next=node5;
node5.next=node6;
node6.next=node7;
ListNode k=findKTHtoTail(node1,3);
System.out.println(k.val);
}
private static ListNode findKTHtoTail(ListNode head, int k) {
//链表为空,或者k为零
if (head==null || k==0) {
return null;
}
/**
* 定义两个结点 before,behind
*/
ListNode before=head;
ListNode behind=null;
//第一个指针先走k-1步
for(int i=0;i<k-1;i++){
if (before.next!=null) {
before=before.next;
}else {
return null;
}
}
//第二个指针开始走
behind=head;
//当第一个指针到达表尾时,第二个指针整好到达倒数第k个结点
while(before.next!=null){
before=before.next;
behind=behind.next;
}
return behind;
}
}
3.3.2链表中环的入口结点
3.3.3反转链表
定义一个函数,输入一个链表的头结点,反转该链表并输出反转后链表的头结点。
package test;
/**
* @author wyl
* @time 2018年8月12日上午10:56:02
*/
public class Test12 {
public static void main(String[] args) {
ListNode node1=new ListNode(1);
ListNode node2=new ListNode(2);
ListNode node3=new ListNode(3);
ListNode node4=new ListNode(4);
ListNode node5=new ListNode(5);
ListNode node6=new ListNode(6);
ListNode node7=new ListNode(7);
node1.next=node2;
node2.next=node3;
node3.next=node4;
node4.next=node5;
node5.next=node6;
node6.next=node7;
ListNode reverseHead=reverseList(node1);
System.out.println(reverseHead.val);
}
private static ListNode reverseList(ListNode head) {
// TODO Auto-generated method stub
ListNode reversedHead=null;//反转后的头结点
ListNode p=head;//当前结点
ListNode pre=null;//当前结点的前一个结点
while(p!=null){
ListNode post=p.next;//当前结点的后一个结点
if (post==null) {
reversedHead=p;
}
p.next=pre;//p.next指向当前结点的前一个结点
pre=p;
p=post;
}
return reversedHead;
}
}
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode ReverseList(ListNode head) {
if (head ==null) {
return null;
}
ListNode bef=null,cur,aft;
cur=head;
while(cur!=null){
aft=cur.next;
cur.next=bef;
bef=cur;
cur=aft;
}
// head=bef;
return bef;
}
}
3.3.4合并两个排序的链表
package test;
/**
* @author wyl
* @time 2018年8月12日上午10:56:02
*/
public class Test14 {
public static void main(String[] args) {
ListNode node1=new ListNode(1);
ListNode node2=new ListNode(3);
ListNode node3=new ListNode(5);
ListNode node4=new ListNode(2);
ListNode node5=new ListNode(4);
ListNode node6=new ListNode(5);
ListNode node7=new ListNode(8);
node1.next=node2;
node2.next=node3;
node4.next=node5;
node5.next=node6;
node6.next=node7;
ListNode k=mergeList(node1,node4);
System.out.println(k.val);
}
//合并两个有序链表,是合并后的链表依旧是有序的
private static ListNode mergeList(ListNode node1, ListNode node4) {
// TODO Auto-generated method stub
/**
* 若两个链表有一个为空,则直接返回另一个链表
*/
if (node1==null) {
return node4;
}else if(node4==null){
return node1;
}
ListNode mergeHead=null;
/**
* 若第一个链表的结点<第二个链表的结点,
* 合并后的头结点为第一个链表额头结点;
* 否则,为第二个链表的头结点
*/
if(node1.val<node4.val){
mergeHead=node1;
mergeList(node1.next, node4);
}else{
mergeHead=node4;
mergeList(node1, node4.next);
}
return mergeHead;
}
}
3.3.5树的子结构