//有两列数字， A{1,2,3,4,5,6,7,8,9}   B{10,11,12,13,14,15} 
//合并成一个新的数列C，要求所有的奇数排在所有的偶数前面，
//并且奇数要升序，偶数要降序，输出数列C到屏幕上

#include"stdio.h"
int getminodd(int c[], int start, int n)
{
  int k;
  int minodd = start;
  while(c[minodd]%2 == 0)
    {
      minodd = minodd+1;
      if(minodd == n)
	{
	  break;
	}
    }
  if(minodd != n)
    {
      for(k=minodd; k<n; k++)
	{
	  if((c[minodd]>c[k]) && c[k]%2 == 1)
	    {
	      minodd = k;
	    }
	}
    } 
  return minodd;
}

int getmaxeven(int c[], int start, int n)
{
  int k;
  int maxeven = start;
  while(c[maxeven]%2 != 0)
    {
      maxeven = maxeven+1;
      if(maxeven == n)
	{
	  break;
	}
    }
  if(maxeven != n)
    {
      for(k=maxeven; k<n; k++)
	{
	  if((c[maxeven]<c[k]) && c[k]%2 == 0)
	    {
	      maxeven = k;
	    }
	}
    } 
  return maxeven;
}

int main()
{
  int a[9] = {1,2,3,4,5,6,7,8,9};
  int b[6] = {10,11,12,13,14,15};
  int c[15] = {};
  int i;
  int j;
  int k=0;
  int count=0;
  int minodd=0;
  int maxeven=0;
  int swap;
  //合并
  for(i=0; i<9; i++)
    {
      c[k] = a[i];
      k = k+1;
    }
  for(j=0; j<6; j++)
    {
      c[k] = b[j];
      k = k+1;
    }
  //奇数部分选择排序
  while(1)
    {
      minodd = getminodd(c, count, 15);
      if(minodd == 15)
	{
	  break;
	}
      swap = c[count];
      c[count] = c[minodd];
      c[minodd] = swap;
      count = count+1;
      if(count >= 15)
	{
	  break;
	}
    }
  //偶数部分选择排序
  while(1)
    {
      maxeven = getmaxeven(c, count, 15);
      if(maxeven == 15)
	{
	  break;
	}
      swap = c[count];
      c[count] = c[maxeven];
      c[maxeven] = swap;
      count = count+1;
      if(count >= 15)
	{
	  break;
	}
    }
  //输出
  for(k=0; k<15; k++)
    {
      printf("%d ", c[k]); 
    }
  printf("\n");
  return 1;
}

//有两个集合A={a,b,f,d,e} B={g,b,h,d,e,e} 合并为一个集合C， C中的元素是递增排列的，并且无重复元素。
//这道题也可以拼接两个集合到一个集合，然后排序消重。

#include"stdio.h"
int getmin(char k[], int n)
{
  int min = -1;
  int i;
  for(i=0; i<n; i++)
    {
      if(k[i] != '#')
	{
	  min = i;
	}
    }
  if(min != -1)
    {
      for(i=0; i<5; i++)
	{
	  if((k[i] == '#') || i == min)
	    {
	      continue;
	    }
	  if(k[i] < k[min])
	    {
	      min = i;
	    }
	  else if(k[i] == k[min])
	    {
	      k[i] = '#';
	    }
	}
    }
  return min;
}

int main()
{
  char a[5] = {'a','b','f','d','e'};
  char b[6] = {'g','b','h','d','e','e'};
  char c[12] = {};
  int i = 0;
  int j = 0;
  int mina;
  int minb;
  int k = 0;
  int flaga = 0;
  int flagb = 0;
  while(1)
    {
      mina = getmin(a,5);
      minb = getmin(b,6);
      if((mina != -1) && (minb != -1))
	{
	  if(a[mina] < b[minb])
	    {
	      c[k] = a[mina];
	      a[mina] = '#';
	      k = k+1;
	    }
	  else if(a[mina] == b[minb])
	    {
	      c[k] = a[mina];
	      a[mina] = '#';
	      b[minb] = '#';
	      k = k+1;
	    }
	  else
	    {
	      c[k] = b[minb];
	      b[minb] = '#';
	      k = k+1;
	    }
	}
      else if((mina == -1) && (minb != -1))
	{
	  c[k] = b[minb];
	  b[minb] = '#';
	  k = k+1;
	}
      else if((mina != -1) && (minb == -1))
	{
	  c[k] = a[mina];
	  a[mina] = '#';
	  k = k+1;
	}
      else
	{
	  c[k] = '#';
	  break;
	}
    }
  i = 0;
  while(i<12)
    {
      if(c[i] == '#')
	{
	  printf("\n");	 
	  break;
	}
      else
	{
	  printf("%c ", c[i]);
	  i = i+1;
	}
    }
}

//用C编写程序：输入一系列整数，保存这些整数，将所有奇数放在所有偶数之前，并且奇数部分和偶数部分需要按从小到大顺序排列，最后输出。
#include "stdio.h"
#include "stdlib.h"
typedef struct node{
  int x;
  struct node *next;
}llnode;

llnode* getNumberList()//此函数建立临时链表，用来接收用户输入
{
  int number = 0;
  llnode *head = (llnode *)malloc(sizeof(llnode));
  llnode *p = head;
  p->x = 0;
  p->next = NULL;
  printf("请输入一列整数，数字之间用空格隔开，以输入#并回车结束:");
  while(scanf("%d", &number))
    {
      llnode *n = (llnode *)malloc(sizeof(llnode));
      n->x = number;
      n->next = NULL;
      p->next = n;
      p = n;
      head->x ++;
    }
  return head;
}

int* getNumberArray(llnode *head)//此函数用来处理用户输入，把用户输入从链表转移到动态数组，以便后面的操作
{
  llnode *p = head;
  llnode *q = head;
  int *numberarray;
  int i;
  numberarray = (int *)malloc(sizeof(int)*(head->x));
  p = head->next;
  while(p!=NULL)
    {
      numberarray[i] = p->x; 
      i++;
      p = p->next;
    }
  return numberarray;
}
  
void removeNumberList(llnode *head)//此函数用于删除临时链表，释放空间
{
  llnode *p = head;
  llnode *q = head;
  while(p!=NULL)
    {
      q = p->next;
      free(p);
      p = q;
    }
}

void divideNumberArray(int *numberarray, int n)//此函数用于把奇数放到偶数的前面
{
  int start = 0;
  int end = n-1;
  int swap = 0;
  for(start=0; start<end; start++)
    {
      if(numberarray[start]%2 == 0)
	{
	  for(; end>start; end--)
	    {
	      if(numberarray[end]%2 == 1)
		{
		  swap = numberarray[start];
		  numberarray[start] = numberarray[end];
		  numberarray[end] = swap;
		  break;
		}
	    }
	}
    }
}

int getCut(int* numberarray, int n)//此函数用于得到奇数和偶数的划分点
{
  int i = 0;
  for(i=0; i<n; i++)
    {
      if(numberarray[i]%2 == 0)
	{
	  return i;
	}
    }
}

void sortNumberArray(int* numberarray, int start, int end)//此函数用于对指定范围内的数据进行升序排序
{
  int i = 0;
  int j = 0;
  int min = 0;
  int swap = 0;
  for(i=start; i<=end; i++)
    {
      min = i;
      for(j=i+1; j<=end; j++)
	{
	  if(numberarray[j] < numberarray[min])
	    {
	      min = j;
	    }
	}
      swap = numberarray[min];
      numberarray[min] = numberarray[i];
      numberarray[i] = swap;
    }
}

int main()
{
  int i = 0;
  int nodecount = 0;
  int *numberarray;
  int cut = 0;
  llnode *head;
  head = getNumberList();//由于不确定用户输入数据的多少，所以要采用链表，这样就解决了不知道用户会输入多少个数字的情况
  nodecount = head->x; //记录一下用户输入了多少数据
  numberarray = getNumberArray(head);//把临时链表的数据放到动态数组以便后续的处理
  removeNumberList(head);//至此numberarray存储了用户输入的所有数据，我们可以把之前的链表删除了，要不然会浪费内存资源
  //至此我们可以专心处理数组numberarry了，nodecount是数组元素个数
  divideNumberArray(numberarray, nodecount);//把奇数放到偶数的前面
  cut = getCut(numberarray, nodecount);//得到奇数和偶数的划分点
  sortNumberArray(numberarray, 0, cut-1);//对奇数排序
  sortNumberArray(numberarray, cut, nodecount-1);//对偶数排序
  for(i=0; i<nodecount; i++)//输出结果
    {
      printf("%d ", numberarray[i]);
    }
  printf("\n");
  return 0;
}