将二叉搜索树转换为双向链表(不创建新的结点)&&数组中出现超过一半的数字

转换的双向链表是从小到大顺序的，而二叉搜索树如果按照中序遍历则肯定是这个序列，所以要在中序遍历的过程中建立双向链表。

而因为结点的左右指针都要在遍历中用到，所以创建一个新的遍历plast来记载已经找到的双向链表的最后一个结点，然后将其它结点与其连接。初始值为NULL。

创建和遍历二叉树就不用再说明了，关键是链接的过程，详细参照代码。

#include<iostream>
#include<string>
#include<queue>
using namespace std;
struct Binarytree{
int value;
Binarytree *left;
Binarytree *right;
};
int path[20];
Binarytree* Buildtree(){
int x;
scanf("%d",&x);
if(x == 0)
return NULL;
queue<Binarytree *> Bq;
Binarytree* root = (Binarytree *)malloc(sizeof(Binarytree));
root->value = x;
root->left = NULL;
root->right = NULL;
Binarytree* temp = root;
Bq.push(temp);
while(!Bq.empty()){
temp = Bq.front();
Bq.pop();
if(temp->left == NULL){
int x;
printf("输入%d的左结点\n",temp->value);
scanf("%d",&x);
if(x!=0){
Binarytree * tleft = (Binarytree *)malloc(sizeof(Binarytree));
tleft->value = x;
tleft->left = tleft->right = NULL;
temp->left = tleft;
Bq.push(tleft);
}
}
if(temp->right == NULL){
int x;
printf("输入%d的右结点\n",temp->value);
scanf("%d",&x);
if(x!=0){
Binarytree * tright = (Binarytree *)malloc(sizeof(Binarytree));
tright->value = x;
tright->left = tright->right = NULL;
temp->right = tright;
Bq.push(tright);
}
}
}
return root;
}

Binarytree *plast;
void reverse(Binarytree *pCurrent){
if(pCurrent->left)
reverse(pCurrent->left);
pCurrent->left = plast;
if(plast)
plast->right = pCurrent;
plast = pCurrent;
if(pCurrent->right)
reverse(pCurrent->right);
}

int main(){
Binarytree *root = Buildtree();
plast = NULL;
reverse(root);
plast->right = NULL;
Binarytree *phead = plast;
while(phead->left){
printf("%d->",phead->value);
phead = phead->left;
}
Binarytree *phead1 = phead;
printf("%d\n",phead->value);
while(phead1->right){
printf("%d->",phead1->value);
phead1 = phead1->right;
}
printf("%d\n",phead1->value);
system("PAUSE");
return 0;
}

数组中超过一半的数字，有两种思路：

一、联想到求第K大的数这个题目，对数组进行快速排序，一半后面的数肯定是寻找的数字，即找到那个坐标就行。

二、利用数组的性质，进行遍历，如果和前面一个数相同，计数加一，否则减去一，如果为0，重新开始计数，多出的那个数字可以找出。

#include<iostream>
#include<string>
int test[] = {1,5,3,5,5,5,2,4,5};

//检查数组是否有效
bool IsValidArray(int *a,int len){
if(a == NULL || len<=0)
return false;
return true;
}
//检查多于一半
bool IsMoreThanHalf(int *a,int len,int result){
int times =0;
for(int i=0;i<len;i++){
if(a[i] == a[result])
++times;
}
if(2*times <= len)
return false;
return true;
}
//分治
int partion(int a[],int beg,int end){
int key = a[beg];
int i = beg+1,j = end;
while(i<j){
while(a[j]>=key && j>beg)
--j;
while(a[i]<key && i<j)
++i;
if(i<j){
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
int temp = a[j];
a[j] = key;
key = temp;
return j;
}
//用快排获得结果,改变数组
int GetHalf_Partion(int *a,int len){
if(a == NULL || len<=0)
return -1;
int beg = 0,end = len-1;
int mid = len>>1;
int result = partion(a,beg,end);
while(result != mid){
if(result>mid){
end = result-1;
result = partion(a,beg,end);
}
else{
beg = result+1;
result = partion(a,beg,end);
}
}
return a[result];
}
//统计获得结果，不改变数组
int GetHalf_Count(int a[],int len){
int result = a[0];
int times =1;
for(int i =1;i<len;i++){
if(times == 0){
result = a[i];
times = 1;
}
else if(a[i] == result)
++times;
else
--times;
}
return result;
}

int main(){
int result;
result =GetHalf_Count(test,9);
printf("%d\n",result);
result =GetHalf_Partion(test,9);
printf("%d\n",result);
system("PAUSE");
return 0;
}