예제 #1
0
파일: 5.cpp 프로젝트: hbdhj/c
int main(void) {

    int N;
    scanf("%d", &N);
    int arr[N], i;
    for(i = 0; i < N; i++) {
        scanf("%d", &arr[i]);
    }

    insertionSort(N, arr);

    return 0;
}
예제 #2
0
파일: sort3.c 프로젝트: madhusirmv/C_monk
int main(void)
{
   double *pdNumbers;
   int iCount;
   int iArrayLength;
   double dNumber;
   int i;
   int iScanfRet;
   
   /* Read the integer that specifies how many numbers follow. */
   iScanfRet = scanf("%d", &iArrayLength);
   if ((iScanfRet != 1) || (iArrayLength < 0))
   {
      fprintf(stderr, "Improper number count\n");
      exit(EXIT_FAILURE);
   }
   
   /* Create an array with the specified number of elements. */   
   pdNumbers = (double*)calloc((size_t)iArrayLength, sizeof(double));
   if (pdNumbers == NULL)
   {
      fprintf(stderr, "Cannot allocate memory\n");
      exit(EXIT_FAILURE);
   }

   /* Read the numbers into the array. */
   for (iCount = 0; iCount < iArrayLength; iCount++)
   {
      iScanfRet = scanf("%lf", &dNumber);
      if (iScanfRet == 0)
      {
         fprintf(stderr, "Non-number in stdin\n");
         exit(EXIT_FAILURE);
      }         
      if (iScanfRet == EOF)
         break;
      pdNumbers[iCount] = dNumber;       
   }

   /* Sort the array. */
   insertionSort(pdNumbers, iCount);

   /* Write the numbers from the array. */
   for (i = 0; i < iCount; i++)
      printf("%g\n", pdNumbers[i]);

   /* Free the array. */
   free(pdNumbers);

   return 0;
}
예제 #3
0
std::vector<UINT16> Kinectv2::getRawDepth()
{
	rawDepth.resize(depthWidth * depthHeight);
	//std::vector<UINT16> rawDepth(depthWidth * depthHeight);
	for(int i = 0;i < depthWidth * depthHeight;i++)
		rawDepth[i] = 0;
	
	for(int k = 0;k < SAVE_SIZE;k++)
		for(int i = 0;i < depths[k].size();i++)
		{
			if(i < depthWidth || i % depthWidth == 0 || i % (depthWidth - 1) == 0 || i >= (depthHeight - 1) * depthWidth)
				depths[k][i] = depths[k][i];
			else
			{
				UINT16 window[9];
				window[0] = depths[k][i - depthWidth - 1];
				window[1] = depths[k][i - depthWidth];
				window[2] = depths[k][i - depthWidth + 1];
				window[3] = depths[k][i - 1];
				window[4] = depths[k][i];
				window[5] = depths[k][i + 1];
				window[6] = depths[k][i + depthWidth - 1];
				window[7] = depths[k][i + depthWidth];
				window[8] = depths[k][i + depthWidth + 1];
				insertionSort(window);
				depths[k][i] = window[4];
			}
		}

	//for(int i = 0;i < SAVE_SIZE;i++)
	//{
	//	for(int j = 0;j < depths[i].size();j++)
	//		rawDepth[j] += depths[i][j];
	//}
	//

	//for(int i = 0;i < rawDepth.size();i++)
	//	rawDepth[i] /= SAVE_SIZE;
	//setCoordinate(rawDepth);

//	std::vector<UINT16> rawDepth(depthWidth * depthHeight);
	//for(int i = 0;i < depthWidth * depthHeight;i++)
	//	rawDepth[i] = 0;


	//	for(int j = 0;j < depths[9].size();j++)
	//		rawDepth[j] = depths[9][j];
	//setCoordinate(rawDepth);

	return rawDepth;
}
예제 #4
0
파일: busca.c 프로젝트: toketas/labicc2
int main(int argc, char* argv[]) {

	if (argc < 4) {
		printf("Numero de argumentos insuficiente\n");
		printf("Uso: ./prog <tam_vetor> <chave> <tipo_busca>\n");
		printf("\t<tipo> = 1 sequencial, 2 binaria\n\n");
		return 0;
	}	

	int n = atoi(argv[1]); // tamanho do vetor
	int chave = atoi(argv[2]); // numero a buscar nos dados
	int op = atoi(argv[3]);

	int * vet = geraVetorAleatorio(n);
	printf("exemplos: %d, %d\n", vet[n-2], vet[n-1]);

	long int pos;

	clock_t c1, c2;
	
	c1 = clock();

	if (op == 1) {
		fprintf(stdout,"Realizando busca...\n");
		fflush(stdout);
		pos = buscaSequencial(vet, n, chave);
	} else if (op == 2) {
		fprintf(stdout,"Ordenando...\n");
		fflush(stdout);
		// bubbleSort(vet, n); // nao usar - dica do Obama
		insertionSort(vet, n);
		fprintf(stdout,"Realizando busca...\n");
		fflush(stdout);
		pos = buscaBinaria(vet, 0, n-1, chave);
	}

	c2 = clock();
	double time_diff = (c2-c1)/((double) CLOCKS_PER_SEC);
	printf("Tempo de execucao: %.4lf\n", time_diff);

	if (pos == -1) {
		printf("Valor nao encontrado\n\n");
	} else {
		printf("Valor encontrado na posicao: %ld\n\n", pos);
	}

	free(vet);


	return 0;
}
예제 #5
0
int* bucketSort(int arrA[], int arrSize)
{
	int* arrB; // Two dimensional array
	for (int i = 1; i<arrSize; i++)
	{
		arrB[floor(n*arrA[i])] = arr[i];			
	}
	for (int i = 0; i<n-1;i++)
	{
		arrB[i][i] = insertionSort(arrB[i][i], arrSize);
	}

return arrA;
}
int main(void) 
{
    int _ar_size;
    scanf("%d", &_ar_size);
    int _ar[_ar_size], _ar_i;

    for(_ar_i = 0; _ar_i < _ar_size; _ar_i++) 
    { 
        scanf("%d", &_ar[_ar_i]); 
    }

    insertionSort(_ar_size, _ar);
    return 0;
}
예제 #7
0
void testrandomlists(int n, int size)
{
  for(int i=0; i<n; i++)
    {
      int list[size];
      int check[size];
      fill_random(list, size);
      list_copy(list, check, size);
      insertionSort(list, size);
      insertionSortSafe(check, size);
      if(!list_equal(list, check, size))
	 printf("FAIL!\n");
    }
}
예제 #8
0
파일: main.c 프로젝트: 19ANDY/al-go-rithms
int main()
{
    // Usage and test

    int nums[] = {122, 111, 3, 125, 6, 21, 13, 13, 8};
    int len = sizeof(nums) / sizeof(nums[0]);
 
    printf("unsorted: ");
    printArray(nums, len); 
    insertionSort(nums, len);
    printf("sorted: ");
    printArray(nums, len);
    return 0;
}
예제 #9
0
int main() {

    /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
       int _ar_size;count=0;
    scanf("%d", &_ar_size);
    int _ar[_ar_size], _ar_i;
    for(_ar_i = 0; _ar_i < _ar_size; _ar_i++) { 
       scanf("%d", &_ar[_ar_i]); 
    }

    insertionSort(_ar_size, _ar);
    printf ("%d\n",count);
    return 0;
}
예제 #10
0
int main(){
	int arr[size];
	FILE * fp = fopen("number.txt", "r");
	for(int i = 0; i < size; i++){
		fscanf(fp, "%d", &arr[i]);
	}
	printf("\n");
	insertionSort(size-1, arr);
	//merge(size-1, arr);
	for(int i = 0; i < size; i++){
		printf("%d\n", arr[i]);
	}
	return 0;
}
예제 #11
0
int main(int argc, char* argv[]) {
    #define SIZE 7

    int arr[SIZE] = {2, 3, 1, 10, 8, 7, 9};
    insertionSort(arr, SIZE);

    int i;
    for (i=0; i<SIZE; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}
예제 #12
0
int main(void)
{
	 int _ar_size;
	 scanf("%d", &_ar_size);

	 int _ar[_ar_size];
	 for (int i = 0; i < _ar_size; i++) {
		  scanf("%d", &_ar[i]);
	 }

	 insertionSort(_ar_size, _ar);

	 return 0;
}
예제 #13
0
int main(int argc, char *argv[]){
	    FILE *in;
	    int i;
	    int j;

        in = fopen(argv[1], "r");
        if(in==NULL){
                printf("unable to open file %s for reading\n", argv[1]);
                exit(1);
        }

        int numOfKeys;
        fscanf(in, "%d", &numOfKeys);
        int keys[numOfKeys];
        int keys2[numOfKeys];
        /*This will read in the numbers and set them inside both arrays*/
        /*so they can later be sorted*/
        for(i = 0; i < numOfKeys;i++){
        	fscanf (in, "%d", &j);
        	keys[i] = j;
        	keys2[i] = j; 
        }
        heapSort(keys,numOfKeys);
        insertionSort(keys2,numOfKeys);

        /*This loop checks to see if both arrays are now sorted*/
        for(i = 0; i < numOfKeys-1;i++){
                if(keys[i] > keys[i+1]){
                        printf("NOT SORTED\n");
                        exit(1);
                }
                if(keys2[i] > keys2[i+1]){
                        printf("NOT SORTED\n");
                        exit(1);
                }
        }
        /*Print both now sorted arrays and end the program*/
        printf("The heapSorted Array");
        for(i = 0; i < numOfKeys;i++){
        	printf(" : %d",keys[i]);
        }
        printf("\nThe insertionSorted Array");
        for(i = 0; i < numOfKeys;i++){
        	printf(" : %d",keys2[i]);
        }
        printf("\n");
        fclose(in);
        return(0);
}
int main(void) {
  // Read input
  int N;
  scanf("%d", & N);

  int arr[N], i;
  for (i = 0; i < N; i++) {
    scanf("%d", & arr[i]);
  }

  // Sorting
  insertionSort(N, arr);

  return 0;
}
예제 #15
0
파일: 11-1.c 프로젝트: gsrr/Programs
int main()
{
        int* A = createArr(20, INT);
        print_arr(A, 20);
        int* B = createArr(10, INT);
        print_arr(B, 10);
        int i;
        int size = 10;
        for( i = 0 ; i < 10 ; i++)
        {
                insertionSort(A, B[i], i + 10);
        }
        print_arr(A, 20);
        return 0;
}
예제 #16
0
int main(int argc, char *argv[])
{
	int values[] = {80, 50, 70, 10, 60, 20, 40, 30 };
	int *pBuffer = NULL;

	printf("Before Sort\n");
	printArray(values, 8);

	insertionSort(values, 8);

	printf("After Sort\n");
	printArray(values, 8);

	return 0;
}
예제 #17
0
int main(){
	printf("Please input n:");
	int n=0;
	scanf("%d",&n);
	int arr[INF]={0};
	int i=0;
	for(i=0;i<n;i++){
		scanf("%d",&arr[i]);
	}
	insertionSort(arr,n);
	for(i=0;i<n;i++){
		printf("%d\n",arr[i]);
	}
	return 0;
}
예제 #18
0
int main()
{
  int tab[] = {6, 5, 2, 0, 1, 3, 4, 7, 7, 7, 6, 6, 5};
  
  std::cout << "Before: ";
  for(int i : tab) std::cout << i << ' ';
  std::cout << std::endl;

  insertionSort(tab, 13);
  
  std::cout << "After: ";
  for(int i : tab) std::cout << i << ' ';
  std::cout << std::endl;
  return 0;
}
예제 #19
0
int main()
{
	int n,a[1000],i;
	printf("Enter the size of array\n");
	scanf("%d",&n);
	printf("Enter the elements of array\n");
	for(i=0;i<n;i++)
	scanf("%d",&a[i]);
	//call the insertionSort function
	insertionSort(a,n);
	printf("sorted elements by insertionsort\n");
	for(i=0;i<n;i++)
	printf("%d ",a[i]);
	return 0;
}
예제 #20
0
파일: main.c 프로젝트: jefponte/exercicios
void menuOrdenacao() {
    int op = 0;;
    int vector[SIZE];
    int vectorAux[SIZE];
    readVector(SIZE, vector);
    printf("Vetor DESORNEDADO: ");
    printVector(SIZE, vector);

    do {
        op = menuDeOrdenacao();
        switch(op) {
            case 1:
                copiaVetor(vector, vectorAux);
                bubbleSortRecursive(SIZE, vectorAux);
                printf("Vetor DESORNEDADO: ");
                printVector(SIZE, vector);
                printf("\nVetor ORDENADO.");
                printVector(SIZE, vectorAux);
                break;
            case 2:
                copiaVetor(vector, vectorAux);
                insertionSort(SIZE, vectorAux);
                printf("Vetor DESORNEDADO: ");
                printVector(SIZE, vector);
                printf("\nVetor ORDENADO.");
                printVector(SIZE, vectorAux);
                break;
            case 3:
                copiaVetor(vector, vectorAux);
                seletionSort(SIZE, vectorAux);
                printf("Vetor DESORNEDADO: ");
                printVector(SIZE, vector);
                printf("\nVetor ORDENADO.");
                printVector(SIZE, vectorAux);
                break;
            case 4:
                copiaVetor(vector, vectorAux);
                quickSort(SIZE, vectorAux);
                printf("Vetor DESORNEDADO: ");
                printVector(SIZE, vector);
                printf("\nVetor ORDENADO.");
                printVector(SIZE, vectorAux);
                break;
            case 5:
                menuPrincipal();
        }
    } while(op!=5);
}
예제 #21
0
void quickSort(ItemType theArray[], int first, int last)
{
   if ((last − first + 1) < MIN_SIZE)
   {
      insertionSort(theArray, first, last);
   }
   else
   {
      // Create the partition: S1 | Pivot | S2
      int pivotIndex = partition(theArray, first, last);
      
      // Sort subarrays S1 and S2
      quickSort(theArray, first, pivotIndex − 1);
      quickSort(theArray, pivotIndex + 1, last);
   }  // end if
}  // end quickSort
예제 #22
0
TEST(SORT, insertion)
{
    const int COUNT = 10;
    int i, *after, *before;
    before = createValuesRandomly(COUNT);
    after = copyArrayValues(before, COUNT);

    insertionSort(after, COUNT);

    printf("before|after\n");
    for (i = 0; i < COUNT; ++i)
        printf("%d%7d\n", before[i], after[i]);

    free(after);
    free(before);
}
예제 #23
0
redirecionarFluxo(int valor){
	switch(valor){

		case 1:
			popularVetor();
			break;
		case 2:
			imprimirVetor();
			break;
		case 3:
			insertionSort();
			break;
		case 4:
		break;
	}
}
예제 #24
0
void topDownMergeSort(int A[], int *B, int begin, int end){
	if (end - begin >= 2){
		if (end - begin <= THRESHOLD){
			printf("Se executa insertion sort \n");
			insertionSort(A, begin, end);
		} else {
			int middle = (begin + end) / 2;
			topDownMergeSort(A, B, begin, middle);
			topDownMergeSort(A, B, middle, end);
			topDownMerge(A, begin, middle, end, B);
			copyArray(A, begin, end, B);

		}
	}
	
}
예제 #25
0
파일: sort.c 프로젝트: anshulk/code
int main()
{
	int i;
	float a[] = {1,5,4,7,6,2,3,8,9,10};
	
	insertionSort(a,10);

	for(i = 0; i<10; i++)
	{
		printf("%.0f ", a[i]);
	}
	
	printf("\n");
	
	return 0;
}
예제 #26
0
파일: teste2.c 프로젝트: waldirpires/mycode
int main(void) {

	int *a, *b, tam, i, num;
	time_t seconds, start, end;
	double duration;
	unsigned long trocas = 0;


	tam = 100000;
	time(&seconds);
	srand((unsigned int) seconds);

	//printf("Digite o tamanho do vetor:");
	//scanf("\n%d", &tam);

	a = (int*) malloc(tam*sizeof(int));
	b = (int*) malloc(tam*sizeof(int));

	for (i = 0; i < tam; i++)
	{
		num = gerarNumeroAleatorio(1000);
		a[i] = num;
		b[i] = num;
	}

	time(&start);
	trocas = selectionSort(a, tam);
	time(&end);
	duration = difftime(end, start);
	printf("\nDuration: %f seconds \tTrocas: %u\n", duration, trocas);
	system("PAUSE");
	copy(b, a, tam);
	time(&start);
	trocas = insertionSort(a, tam);
	time(&end);
	duration = difftime(end, start);
	printf("\nDuration: %f seconds \tTrocas: %u\n", duration, trocas);
	system("PAUSE");
	copy(b, a, tam);
	time(&start);
	trocas = bubbleSort(a, tam);
	time(&end);
	duration = difftime(end, start);
	printf("\nDuration: %f seconds \tTrocas: %u\n", duration, trocas);
	system("PAUSE");
	return EXIT_SUCCESS;
}
예제 #27
0
void testSortPerformance(int *origin, int size, int idx, int inteval)
{
    const int START = idx;
    const int LIMIT = size;
    const int INTEVAL = inteval;
    int *clone, *extra, i;
    time_t start;
    double result[5];

    clone = (int *) malloc(sizeof(int) * LIMIT);
    extra = (int *) malloc(sizeof(int) * LIMIT);

    printf("%s\t%s\t%s\t%s\t%s\t%s\n", "개수", "선택정렬", "삽입정렬", "퀵정렬", "합병정렬", "히프정렬");
    for (i = START; i <= LIMIT; i += INTEVAL)
    {
        memcpy(clone, origin, sizeof(int) * LIMIT);
        start = clock();
        selectionSort(clone, i);
        result[0] = (double) (clock() - start) / (CLOCKS_PER_SEC / 1000);

        memcpy(clone, origin, sizeof(int) * LIMIT);
        start = clock();
        insertionSort(clone, i);
        result[1] = (double) (clock() - start) / (CLOCKS_PER_SEC / 1000);

        memcpy(clone, origin, sizeof(int) * LIMIT);
        start = clock();
        quickSort(clone, 0, i - 1);
        result[2] = (double) (clock() - start) / (CLOCKS_PER_SEC / 1000);

        memcpy(clone, origin, sizeof(int) * LIMIT);
        start = clock();
        mergeSort(clone, extra, i - 1);
        result[3] = (double) (clock() - start) / (CLOCKS_PER_SEC / 1000);

        memcpy(clone, origin, sizeof(int) * LIMIT);
        start = clock();
        heapSort(clone, i - 1);
        result[4] = (double) (clock() - start) / (CLOCKS_PER_SEC / 1000);

        printf("%d\t%lf\t%lf\t%lf\t%lf\t%lf\n", i, result[0], result[1], result[2], result[3], result[4]);
    }

    free(clone);
    free(extra);
}
예제 #28
0
파일: array.c 프로젝트: chachalaca/PRC1
int main (int argc, char **argv)
{
	int array[10];
	for(int i=0;i<10;i++)
		{
		array[i] = array[i]%10;
		
		}

	insertionSort(array);
	for(int i=0;i<10;i++)
		{
		
		printf("%i\n", array[i]);
		}

}
예제 #29
0
int main (void) {
    int *v, n, i;
    printf("Inserire n: ");
    scanf("%d", &n);
    v = (int *)malloc(n * sizeof(int));
    srand(time(NULL));
    for(i=0; i<n; i++) {
        v[i] = rand()%10;
        printf("%d\t", v[i]);
    }
    printf("\n\n");
    insertionSort(v, n);
    for(i=0; i<n; i++)
        printf("%d\t", v[i]);
    printf("\n");
    return 0;
}
예제 #30
0
int main(){
	//variable declaration
	int arr[5], i;
	
	//input
	for(i = 0; i < 5; i++)
		scanf("%d", &arr[i]);
	
	//sort
	insertionSort(arr, 5);	//passing arr address and no. of elements
	
	//output
	for(i = 0; i < 5; i++)
		printf("%d\n", arr[i]);
		
	return 0;
}