求單獨出現的數，冒泡排序優化，strncpy的優化

求未配對的數（1）：

在一組數據中有 只有一個數出現了一次，其他的數都是成對的出現，請找出這個數：這個題很容易解決，只要把這組數據所有異或（相同爲零，不一樣爲1），因此出現兩次的數異或後就爲零，最後剩下的就是出現一次的數。

#include<stdio.h>
#include<stdlib.h>

int find_once_num(int arr[], int len )
{
                 int num = 0;
                 for (int i = 0; i < len; i++)
                {
                                num ^= arr[i];
                }
                 return num;
}
int main()
{
                int arr[9] = { 8, 4, 2, 7, 9, 8, 4, 2, 7 };
                int ret=find_once_num(arr,9);
                printf( "%d\n",ret);
                system( "pause");
                return 0;
}

（2）

如今將題目變一下，一組數據中只有兩個數出現了一次，其他數字都是成對出現的，請找出這兩個數，這時就不能直接異或了，必須將這一組數據分紅兩塊，每塊只包含一個單獨出現的數，這樣剩下的問題就和第一題同樣了，可關鍵是怎麼分呢？？？

分析：咱們能夠先對這組數據進行排序，這樣成對出現的數就相鄰在一塊兒了，咱們再一對一對的比較，直到找到第一對不相等的數，而後從中分開，這樣就分紅兩塊了。

void bubble_sort(int arr[], int n )
{
   int flag = 0;
   int i = 0;
   int j = 0;
   for (i = 0; i < n - 1; i++)
   {
      flag = 1;
      for (j = 0; j < n - i - 1; j++)
      {
        if (arr [j]>arr[j + 1])
        {
          arr[j] = arr [j] + arr[j + 1];
          arr[j + 1] = arr [j] - arr[j + 1];
          arr[j] = arr [j] - arr[j + 1];
          flag = 0;
        }
       }
      if (flag == 1)
        break;
    }
}
int find_one_num(const int *p1,int len)
{
   assert(p1 );
   int num = 0;
    for (int i = 0; i <=len; i++)
   {
    num ^= p1[i];
   }
   return num;
}
int main()
{
  int arr[10] = {0 ,1, 13, 18, 18,13,1,46,0,3};
  int i = 0;
  int *p = arr;
  bubble_sort(arr, 10);
  for (i = 0; i < 10 - 1;)
  {
    if (p[i] == p[i + 1])
    {
      i += 2;
    }
    else
      break;
  }
  printf( "%d   %d \n", find(p, i),find((p+i+1),9-i-1));
  system( "pause");
  return 0;
}

冒泡排序的優化：

上面對數組進行排序時，用到了冒泡排序法，一般咱們使用冒泡排序法時會將每一個數都與後面的數進行比較，這樣雖然能夠實現冒泡排序，可是卻不是最優的方法，由於冒泡排序還能夠進行優化。

優化：以升序爲例

void bubble_sort(int arr[], int n )
{
   int flag = 0;
   int i = 0;
   int j = 0;
   for (i = 0; i < n - 1; i++)
   {
     flag = 1;        //設置一個標記flag                
     for (j = 0; j < n - i - 1; j++)                  
     {
     //若是第1,2有序，第2,3也有序，後面的都有序，則不進入if，flag就不會變成0
              if (arr [j]>arr[j + 1])                              {                                               arr[j] = arr [j] + arr[j + 1];                          arr[j + 1] = arr [j] - arr[j + 1];                       arr[j] = arr [j] - arr[j + 1];
               flag = 0;                                                //只要前一個數大於後一個數，進入if，flag會變成1
        }
      }
     if (flag == 1)                                       break;        //若是flag爲1，則就說明這組數據已經有序                
  }
}

strncpy的優化：

當n很大很大時，若是一個字節一個字節的copy效率會很是低下，因此咱們要想一個辦法，當n特別大時，使得一次性能夠copy多個字節。其實這個辦法就是強制類型轉換，將char *轉換爲int *（在c中試了一下轉換爲double*,顯示沒法轉換）,這樣一次就能夠copy 4個字節，而當n小於4時再轉換爲char*進行copy.

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
char* my_strncpy(char *dst, const char *src, int len)
{
	assert(dst);
	assert(src);
	int* p1= (int *)dst;
	const int* p2 = (int *)src;
	while (len)
	{
		if (len < 4)
		{
			(char *)*p1=(char *)*p2;
			((char* )p1)++;
			((char *)p2)++;
			len--;
		}
		else
		{
			*p1++ = *p2++;
			len -= 4;
		}

	}
	(char *)*p1 = '\0';
	return  dst;
}
int main()
{
	char arr1[100];
	char arr2[50];
	int n = 0;
	scanf("%s%s%d", arr1, arr2,&n);
	char *ret = my_strncpy(arr1, arr2, n);
	printf("%s\n",ret);
	system("pause");
	return 0;
}