每日java5-18

86. 不使用第三个数交换两个数的值

public class twoSum {

public static void main(String[] args) {

int a=10,b=12;

a=b-a; //a=2;b=12

b=b-a; //a=2;b=10

a=b+a; //a=12;b=10

System.out.println(“a:”+a);

System.out.println(“b:”+b);

int x=10,y=12;

x=x+y;//a=22,b=12

y=x-y;//a=22,b=10

x=x-y;//a=12,b=10

System.out.println(“x:”+x);

System.out.println(“y:”+y);

}

}

87.链表

public class test {

//Node 类

public class NodeDemo {

private class Node {

private T data; // 存放结点数据

private Node next; // 下个结点

public Node() {

}

public Node(T data, Node next) {

this.data = data;

this.next = next;

}

}

private Node head;// 链表的头结点

private Node tail;// 链表的尾节点

int size;

public NodeDemo() {

head = null;

tail = null;

}

public NodeDemo(T data) {

head = new Node(data, null);

tail = head;

size++;

}

}

public static void main(String[] args) {

NodeDemo
nodeDemo = new NodeDemo();

nodeDemo.addTailNode(“111”);

nodeDemo.addTailNode(“222”);

nodeDemo.addTailNode(“333”);

nodeDemo.addTailNode(“444”);

System.out.println(nodeDemo);

System.out.println(“链表的size:” + nodeDemo.size);

System.out.println(“删除某个节点的位置:” + nodeDemo.findIndexByNode(“333”));

System.out.println(“查询指定位置的节点:” + nodeDemo.findNodeByIndex(2).data);

System.out.println(“删除指定位置的节点:” + nodeDemo.deleteNode(2));

System.out.println(nodeDemo);

System.out.println(“链表是否为空:” + nodeDemo.isEmpty());

nodeDemo.clear();

System.out.println(“清空后的链表:” + nodeDemo);

System.out.println(“链表是否为空:” + nodeDemo.isEmpty());

}

//尾部插入

public void addTailNode(T element) {

if (head == null) {

head
= new Node(element, null);

tail
= head;

}else {

Node
node = new Node(element, null);

tail.next
= node;

tail
= node;

}

size++;

}

//头部插入

public void addHeadNode(T element){

head
= new Node(element, head);

if (tail == null) {

tail
= head;

}

}

//指定位置插入

public void addIndexNode(T element, int index) {

if (head == null) {

addTailNode(element);

}else {

if (index == 0) {

addHeadNode(element);

}else {

Node
pre = findNodeByIndex(index-1);//找到要插入位置的前一个节点

Node
node = new Node(element, pre.next);

//插入后pre的next指向新节点，新节点的next指向原来pre的下一个节点

pre.next = node;

size++;

}

}

}

//根据结点查询结点存放的位置

public int findIndexByNode(T element) {

Node
current = head;

int index = 0;

while (current != null) {

if (current.data.equals(element)) {

return index;

}

current = current.next;

index++;

}

return -1;

}

//根据结点位置删除指定位置的结点

public T deleteNode(int index) {

Node
dNode = null;

if(index < 0 || index > size-1)  {

throw new IndexOutOfBoundsException(“链表越界”);

}

if (index == 0) {

dNode = head;

head
= head.next;

}else {

Node
pre = findNodeByIndex(index-1);//获取要删除的节点的前一个节点

dNode = pre.next;//要删除的节点就是pre的next指向的节点

pre.next = dNode.next;//删除以后pre的next指向被删除节点之前所指向的next

dNode.next = null;

}

return dNode.data;

}

//清空链表

public void clear() {

head
= tail = null;

size
= 0;

}

//判断链表是否为空

public boolean isEmpty() {

return size == 0 ? true : false;

}

//打印链表

public String toString() {

Node
node = head;

StringBuffer
sb = new StringBuffer();

while (node != null) {

sb.append(node.data+" ");

node = node.next;

}

return sb.toString();

}

}

88.删除链表重复元素，不保留重复元素。

创建链表：

public class ListNode {

int value;

ListNode next;

public ListNode(int value,ListNode next) {

this.value=value;

this.next=next;

}

}

算法：

public static ListNode remove(ListNode node) {

ListNode first=new ListNode(0,null);

first.next=node;

ListNode temp=node;

ListNode pre=first;

while(temp!=null&&temp.next!=null) {

if(temp.next.value==temp.value) {

int val=temp.value;

while(temp!=null&&temp.value==val) {

temp=temp.next;

}

pre.next=temp;

}else {

pre=temp;

temp=temp.next;

}

}

return node;

}

89.删除链表重复元素，只保留一个。

创建链表：

public class ListNode {

int value;

ListNode next;

public ListNode(int value,ListNode next) {

this.value=value;

this.next=next;

}

}

算法：

public static ListNode returnList(ListNode node){

ListNode temp=node;

while(temp!=null) {

ListNode q=temp.next;

while(q!=null&&q.value==temp.value) {

q=q.next;

}

temp.next=q;

temp=temp.next;

}

return node;

}

90.单链表的反转

定义一个链表：

public class ListNode {

private int data;

ListNode next;

public ListNode(int data) {

super();

this.data=data;

}

}

算法：

public static ListNode reserve(ListNode head) {

ListNode pre = head; // 上一节点

ListNode now = head.next; // 当前节点

while (now != null) {

ListNode temp = now.next; // 将下一节点存入临时节点

now.next = pre; // 当前节点指向上一个

pre = now;

now = temp;

}

head.next = null;

return pre;

}

遍历链表：

public static void print(ListNode li){

while(li!=null){

System.out.println(li.data+" ");

li=li.next;

}

}