博客围绕链表、数组和数学问题展开。涉及两个单调递增链表的合成、链表反转、查找链表倒数第k个结点，还包括调整数组中奇偶顺序、求浮点数的整数次方、小矩形覆盖大矩形的方法数，以及计算整数二进制中1的个数等算法问题。
目录
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
// 输入两个单调递增的链表，输出两个链表合成后的链表，
// 当然我们需要合成后的链表满足单调不减规则。
public Node Merge(Node list1, Node list2) {
Node head = list1.data < list2.data ? list1 : list2;
Node cur1 = head == list1 ? list1 : list2;//初始头结点所在的链表
Node cur2 = head == list1 ? list2 : list1;
Node pre = null;
Node nex = null;
while (cur1 != null && cur2 != null) {
if ((cur1.data <= cur2.data)) {
pre = cur1;
cur1 = cur1.next;
} else {//注意容易出现循环链表
nex = cur2.next;
pre.next = cur2;
cur2.next = cur1;//cur2节点添加到链表中
cur2 = nex;
pre = pre.next;
}
}
pre.next = cur1 == null ? cur2 : cur1;
return head;
}输入一个链表，反转链表后，输出新链表的表头。
public Node ReverseList(Node head) {
if (head == null) {
return null;
}
Node preNode = null;
Node nextNode = null;
while (head != null) {
nextNode = head.next;
head.next = preNode;
preNode = head;
head = nextNode;
}
System.out.println(preNode.data);
return preNode;
}用递归的方式翻转链表： // 用递归的方式翻转链表
// 以1-2-3-4为例：
// 程序到达Node newHead = reverse(head.next);时进入递归
// 我们假设此时递归到了3结点，此时head=3结点，temp=3结点.next(实际上是4结点)
// 执行Node newHead = reverse(head.next);传入的head.next是4结点，返回的newHead是4结点。
// 接下来就是弹栈过程了
// 程序继续执行 temp.next = head就相当于4->3
// head.next = null 即把3结点指向4结点的指针断掉。
// 返回新链表的头结点newHead
public Node iterationRevise(Node head) {
if (head == null || head.next == null) {
return head;
}
Node temp = head.next;//temp指向4节点
Node newHead = iterationRevise(head.next);
temp.next = head;//4节点指向3节点
head.next = null;//将3节点指向null，断开3节点指向4节点的连接；
return newHead;
}
public Node iterationRevise2(Node head) {
if (head == null || head.next == null) {
return head;
}
//递归走到链表的末端；先翻转后面的链表；
Node newHead = iterationRevise(head.next);
//将当前节点设置为后面节点的next节点
head.next.next = head;//翻转了链表的指向
head.next = null;//防止链表错乱
return newHead;
}输入一个链表，输出该链表中倒数第k个结点
public Node FindKthToTail(Node head, int k) {
int f = 0;
Node kNode = head;
while (kNode != null) {
f++;
kNode = kNode.next;
}
if (k > f) {
return null;
}
for (int i = 0; i < f - k; i++) {
head = head.next;
}
System.out.println(head.data);
return head;
}输入一个链表，输出该链表中倒数第k个结点。(改进，遍历一遍)： // 输入一个链表，输出该链表中倒数第k个结点。(改进，遍历一遍)
public Node FindKthToTail2(Node head, int k) {
if (head == null || k <= 0) {
return null;
}
Node kNode = head;
for (int i = 0; i < k; i++) {
if (head == null) {
return null;
}
head = head.next;
}//head为第k个了
while (head != null) {
kNode = kNode.next;
head = head.next;
}
System.out.println(kNode.data);
return kNode;
}输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
public void reOrderArray(int[] array) {
int[] result = new int[array.length];
int sizeOdd = 0;
int po = 0;
int even = 0;
for (int i = 0; i < array.length; i++) {
if ((array[i] & 0x1) == 1) {//如果为奇数
sizeOdd++;
}
}
for (int i = 0; i < array.length; i++) {
if ((array[i] & 0x1) == 0) {//如果为偶数
result[sizeOdd + even] = array[i];
even++;
} else {
result[po] = array[i];
po++;
}
}
for (int i = 0; i < array.length; i++) {
array[i] = result[i];
}
}如果：不保证相对位置不变,原地变换数组： public void reArray(int[] array) {
int left = 0;
int right = array.length - 1;
int temp;
while (left < right) {
if ((array[left] & 0x1) == 0) {//左边的为偶数
if ((array[right] & 0x1) == 1) {//右边的也为奇数
temp = array[left];
array[left] = array[right];
array[right] = temp;
right--;
left++;
} else {
right--;
}
} else {
left++;
}
}
}不保证相对位置不变,原地变换数组(更简洁的代码)： public void reArray2(int[] array) {
int left = 0;
int right = array.length - 1;
int temp;
while (left < right) {
while ((left < right) && (array[left] & 0x1) == 1) {//左边的为奇数
left++;
}
while ((left < right) && (array[right] & 0x1) == 0) {//右边的为偶数
right--;
}
temp = array[left];
array[left] = array[right];
array[right] = temp;
right--;
left++;
}
}给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
public double Power(double base, int exponent) {
if (base == 0) {
if (exponent >= 0) return 0;
if (exponent < 0) throw new RuntimeException("分母不能为0");
}
if (exponent == 0) return 1;
double res = base;
if (exponent < 0) {
exponent = -exponent;
for (; exponent != 0; exponent >>= 1) {
if ((exponent & 1) == 1) res = base * res;
else base = base * base;
}
res = 1 / res;
} else {
for (; exponent != 0; exponent >>= 1) {
if ((exponent & 1) == 1) res = base * res;
else base = base * base;
}
}
return res;
}将指数为正整数时的情况拿出来，使用递归实现，递归次数logn
public double Power2WithExponent(double base, int exponent) {
//指数为正整数时的结果，递归节省计算的次数
if (exponent == 0) return 1;
if (exponent == 1) return base;
double res = Power2WithExponent(base,exponent>>1);
res = res*res;
if((exponent & 0x1) == 1){//用与，为0为偶数，为1为奇数
res = res*base;
}
return res;
}
public double Power2(double base, int exponent) {
if (base == 0) {
if (exponent >= 0) return 0;
if (exponent < 0) throw new RuntimeException("分母不能为0");
}
if (exponent == 0) return 1;
double result = 0;
if (exponent < 0) {
exponent = -exponent;
result = Power2WithExponent(base,exponent);
result = 1/ result;
}else {
result = Power2WithExponent(base,exponent);
}
return result;
}我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
//我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。
//请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
//同斐波那契数列的应用
public int RectCover(int target) {
if(target == 1){
return 1;
}
if(target == 2){
return 2;
}
int a = 1;
int b = 2;
int total = 0;
for(int i = 3; i <= target; i++){
total = a+b;
a = b;
b = total;
}
return total;
}输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
public int NumberOf1(int n) {
int pre = 0;
int flag = 1;
while (flag != 0){//这个方法中循环的次数等于整数二进制的位数，32位的整数
if((n & flag) == 1){
pre++;
}
flag <<= 1;
}
return pre;
}更好的解法：
public int NumberOf2(int n) {//好的解法
int pre = 0;
while (n != 0){
pre++;
n = n & (n-1);
}
return pre;
}
扫一扫
1268
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
