练习coding~

//@duanby 小顶堆. 选K小元素放入result数组中.
void GetLargetstNNum(int array[],int result[],int length, int K)
{
	priority_queue<int,vector<int>,greater<int> > heap;
	int i;
	for (i=0;i<length;++i)
	{
		heap.push(array[i]);
	}

	for (i=0;i<K;++i)
	{
		result[i]=heap.top();
		heap.pop();
	}
}

//小米笔试，给一个浮点数序列，取最大乘积子序列的值，例如  -2.5， 4， 0，
//3，0.5，8，-1，则取出的最大乘积子序列为 3，0.5，8。
int max___(int a, int b)
{
	return a>b?a:b;
}
static double MaxMulSeqCore(double array[],int start, int end)
{
	if (start > end)
	{
		return 0.0;
	}

	int mid = start +((end-start)>>1);
	double leftMax = MaxMulSeqCore(array,start,mid-1);
	double rightMax = MaxMulSeqCore(array,mid+1,end);

	double midMax=array[mid],midMaxTemp=array[mid];
	double temp;
	int i;

	for (i=mid-1;i>start;i--)
	{
		midMaxTemp *= array[i] ;
		if (midMaxTemp>midMax )
		{
			midMax=midMaxTemp;		
		}
	}
	midMaxTemp=midMax;
	for (i=mid+1;i<end;i++)
	{
		midMaxTemp *=array[i];
		if (midMaxTemp>midMax)
		{
			midMax=midMaxTemp;
		}
	}
	
	return max___(max___(leftMax,rightMax),midMax);
}
double MaxMulSeq(double array[],int length)
{
	if (NULL == array || length <= 0)
	{
		return 0.0;
	}
	return MaxMulSeqCore(array,0,length-1);
}

typedef int ElemType;
typedef struct node {
	ElemType value;
	node *next;
}Node,*LinkList;
//@duanby 反转链表
Node *ReverseLinkList(LinkList &head)
{
	if (NULL == head || NULL == head->next)
	{
		return head;
	}
	Node *reverse = ReverseLinkList(head->next);
	head->next->next=head;
	head->next=NULL;
	return reverse;
}
//@duanby 合并链表
Node *MergeLinkList(LinkList &head1, LinkList &head2)
{
	if (NULL == head1)
	{
		return head2;
	}
	if (NULL == head2)
	{
		return head1;
	}
	Node *mergeHead = NULL;
	if (head1->value > head2->value)
	{
		mergeHead=head1;
		mergeHead->next=MergeLinkList(head1->next,head2);
	}
	else
	{
		mergeHead=head2;
		mergeHead->next=MergeLinkList(head1,head2->next);
	}

	return mergeHead;

}
//创建链表
void CreateLinkList(LinkList &head)
{
	int data;
	cin >> data ;
	while (0 != data)
	{
		Node *newNode  = new Node;
		newNode->value = data;
		newNode->next = NULL;

		if (NULL==head)
		{
			head=newNode;
		}
		else
		{
			newNode->next=head;
			head=newNode;
		}
		cin >> data;
	}
}
//打印链表
void PrintLinkList(LinkList head)
{
	Node *start = head;
	while (start != NULL)
	{
		cout << start->value<<" ";
		start=start->next;
	}
	cout <<endl;
}
int main()
{
	LinkList head1 = NULL,head2=NULL,mergeHead=NULL;
	CreateLinkList(head1); // 降序
	cout << "head1 finish\n";
	PrintLinkList(head1);

	CreateLinkList(head2); //升序
	cout << "head2 finish\n";
	PrintLinkList(head2);

	head2 = ReverseLinkList(head2); //反转，使其降序
	PrintLinkList(head2);

	mergeHead=MergeLinkList(head1,head2);//合并
	PrintLinkList(mergeHead);
}

typedef char VertexType;
typedef int EdgeType;

#define  MAXVEX 100
#define  INFINITY 65536

//邻接矩阵
typedef struct
{
	VertexType vex[MAXVEX];
	EdgeType arc[MAXVEX][MAXVEX];
	int numVertexs,numEdges;
}MGraph;

void CreateGrap(MGraph *G)
{
	cout << "输出顶点数，边数："<<endl;
	cin >> G->numVertexs>>G->numEdges;
	int i,j;
	for (i=0;i<G->numVertexs;++i)
	{
		cin>>G->vex[i];
	}
	for (i=0;i<G->numVertexs;++i)
	{
		for (j=0;j<G->numVertexs;++j)
		{
			G->arc[i][j]=INT_MAX;
		}
	}
	int k,w;
	for (k=0;k<G->numEdges;k++)
	{
		cout << "输入边（vi,vj）的i，j和权值w："<<endl;
		cin>>i>>j>>w;
		G->arc[i][j]=w;
		G->arc[j][i]=G->arc[i][j];
	}
}
//end 邻接矩阵


//邻接表
typedef struct EdgeNode 
{
	int adjvex;
	EdgeType weight;
	EdgeNode *next;
};

typedef struct VertexNode
{
	VertexType data;
	EdgeNode *firstedge;
};

typedef struct 
{
	VertexNode adjList[MAXVEX];
	int numVertexs,numEdges;
}GraphAdjList;

void CreateGrapAdj(GraphAdjList *G)
{
	int i,j,k;
	cout << "输入顶点数,边数："<<endl;
	cin >> G->numVertexs >> G->numEdges;

	for (i=0;i<G->numVertexs;++i)
	{
		cin>>G->adjList[i].data;
		G->adjList[i].firstedge=NULL;
	}
	EdgeNode *e;
	for (k=0;k<G->numEdges;++k)
	{
		cout << "输入边（vi,vj）顶点序号"<<endl;
		cin >> i>>j;
		e=new EdgeNode;
		e->adjvex=j;
		e->next=G->adjList[i].firstedge;
		G->adjList[i].firstedge=e;
		e=new EdgeNode;
		e->adjvex=i;
		e->next=G->adjList[j].firstedge;
		G->adjList[j].firstedge=e;
	}
}
//end 邻接表

void AnswerPermutation(char *arr,int length,int start)
{
	if (NULL == arr || length <= 0)
	{
		return;
	}
	
	if (start == length)
	{
		for (int i = 0 ; i < length;++i)
		{
			cout << arr[i]<< " ";
		}
		cout <<endl;
	}
	else
	{
		for (int i = start;i<length;++i)
		{
			char temp = *(arr+i);
			*(arr+i) = *(arr+start);
			*(arr+start)=temp;
			AnswerPermutation(arr,length,start+1);
			temp = *(arr+i);
			*(arr+i) = *(arr+start);
			*(arr+start)=temp;
		}
	}
}


void AnswerCombination(char *arr, int num, vector<char> &ivec)
{
	if (NULL == arr )
	{
		return;
	}
	if (0==num)
	{
		copy(ivec.begin(),ivec.end(),ostream_iterator<char>(cout," "));
		cout <<endl;
		return;
	}
	if (*arr == '\0')
	{
		return;
	}
	ivec.push_back(*arr);
	AnswerCombination(arr+1,num-1,ivec);
	ivec.pop_back();
	AnswerCombination(arr+1,num,ivec);
}

//ab**cd**e*12 ----> *****abcde12
void SwapString(char array[],int length)
{
	if (NULL == array || length <= 0)
	{
		return ;
	}

	int posEnd = length - 1;
	int cur = length - 1;

	while (posEnd >= 0)
	{
		if (array[posEnd]=='*')
		{
			posEnd--;
			continue;
		}
		else
		{
			char temp = array[posEnd];
			array[posEnd]=array[cur];
			array[cur] = temp;
			posEnd--;
			cur--;
		}
	}

}

//1234 xyz , 34 ---> 34 xyz
char *StrStrCore(const char *array, const char *subArray)
{
	if (NULL == array || NULL == subArray)
	{
		return NULL;
	}

	const char *startArr = array;
	const char *startSubArr = subArray;

	while (*startArr != '\0')
	{
		const char *cur = startArr;
		while (*cur == *startSubArr && *startSubArr != '\0')
		{
			cur++;startSubArr++;
		}
		if (*startSubArr == '\0')
		{
			return (char*)cur;
		}
		startArr++;
	}

	return NULL;
}