今日算法（七）

第一题：调整整数数组顺序使奇数位于偶数前面

题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

解析：1.利用冒泡排序的性质，之前是前偶后奇就进行交换

          2.利用一个辅助空间，遍历两遍，第一遍进行奇数的插入，第二遍进行偶数的插入，这种解法我就不写了。。。。

public class Solution {
public void reOrderArray(int [] array) {
if(array == null || array.length == 0){
return;
}
for(int i = 0; i < array.length; i++){
for(int j = 0; j < array.length - i -1; j++){
if(array[j]%2 == 0 && array[j+1]%2 == 1){
swap(array,j,j+1);
}
}
}
}

private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}

第二题：删除链表中倒数第K个节点

题目描述
输入一个链表，输出该链表中倒数第k个结点。

解析：关键点在怎么找到倒数第k个节点，使用两个指针，都指向起始点。然后一个先跑k个节点，另一个不动，然后两个一起跑，第一个节点跑到终点后，第二个节点的位置就是倒数第K个节点

/*
public class ListNode {
int val;
ListNode next = null;

ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
if(head == null){
return null;
}
int count = 0;
ListNode cur = head;
while(cur != null){
cur = cur.next;
count++;
}
if(k > count){//k的值不能比链表长度长
return null;
}
ListNode pre = head;
while(pre != null){
if(k != 0){
k--;
}else{
head = head.next;
}
pre = pre.next;
}
return head;
}
}

第三题：反转链表

题目描述

输入一个链表，反转链表后，输出链表的所有元素。

解析：基本操作，都坐下~~

/*
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 pre = null;
ListNode next = null;
while(head != null){
next = head.next;
head.next = pre;
pre = head;
head = next;
}
return pre;
}
}

第四题：合并两个排序的链表

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

解析：就是外排啦~~，外排：两个指针从头开始，谁小谁移动或者谁大谁移动。     本题的意思是：谁大谁移动。当有一个为null时，那么就直接连接另一个。

/*
public class ListNode {
int val;
ListNode next = null;

ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1 == null){
return list2;
}
if(list2 == null){
return list1;
}
ListNode cur = null;
ListNode head = null;
while(list1 != null && list2 != null){
if(list1.val <= list2.val){
if(head == null){
head = cur = list1;
}else{
cur.next = list1;
cur = cur.next;
}
list1 = list1.next;
}else{
if(head == null){
head = cur = list2;
}else{
cur.next = list2;
cur = cur.next;
}
list2 = list2.next;
}
}
if(list1 == null){
cur.next = list2;
}
if(list2 == null){
cur.next = list1;
}
return head;
}
}

第五题：树的子结构

题目描述

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

解析：递归解法先判断头结点是不是相等，不相等则判断左右节点与root2节点是否相等，递归case：root2==null

/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;

public TreeNode(int val) {
this.val = val;

}

}
*/
public class Solution {
public boolean HasSubtree(TreeNode root1,TreeNode root2) {
boolean falg = false;
//当Tree
9e54
1和Tree2都不为null的时候，才进行比较。否则直接返回false
if (root1 != null && root2 != null){

if (root1.val == root2.val){
falg = DoesTree1HaveTree2(root1,root2);
}
//根节点不匹配，则继续匹配左子节点
if (!falg){
falg = DoesTree1HaveTree2(root1.left,root2);
}
//根节点不匹配，则继续匹配右子节点
if (!falg){
falg = DoesTree1HaveTree2(root1.right,root2);
}
}
return falg;
}

public boolean DoesTree1HaveTree2(TreeNode root1,TreeNode root2){
//说明root2遍历完了，返回true
if (root2 == null){
return true;
}
//root遍历完了，root2还没，说明root2不是root1的子树
if (root1 == null){
return false;
}
//值不匹配返回false
if (root1.val != root2.val){
return false;
}
//匹配则继续递归左子节点和右子节点
return DoesTree1HaveTree2(root1.left,root2.left) && DoesTree1HaveTree2(root1.right,root2.right);

}
}