精华内容
下载资源
问答
  • C语言算法
  • C语言选择排序算法

    2021-03-29 21:39:08
    c语言选择排序算法

    c语言选择排序算法

    
    #include<stdio.h>
    int main(void){
    
    	int i,j,k,t;
    
    	int a[10]={22,1,5,8,33,45,16,4,10,10};      //初始化数组
    
    	printf("原来的序列:\n");
    
    	for(i=0;i<10;i++)
    
    		printf("%3d",a[i]);
    		
    		printf("\n");
    	printf("排序后的序列:\n");
    
    	for(i=0;i<9;i++){
    		k=i;              // k为标志,第几趟就默认第几个数是最大或者最小值的位置
    		for(j=i+1;j<10;j++)
    		if(a[k]>a[j])
    			k=j;           //如果前一个大于后一个,则更新k标志
    		if(k!=i){        //如果k的值发生变化,则将原本i的位置的值和此刻k所在的位置的值交换
    		
    			t=a[i];
    			a[i]=a[k];
    			a[k]=t;
    		}               
    	}
    
    
    	for(i=0;i<10;i++)
    
    		printf("%3d",a[i]);   //循环输出数组
    		
    		printf("\n");        //输出完之后换行
    
    	return 0;
    }
    
    展开全文
  • c语言排序算法

    2015-01-07 14:43:20
    各种C语言排序算法,包括冒泡、插入、选择、堆排序等。
  • C语言 选择排序算法

    2020-09-03 21:15:37
    C语言 选择排序算法 #include <stdio.h> #include <stdlib.h> //选择排序算法 void selectSort(int *arr,int n) { int temp, i, j; int k; for(i = 0; i < n - 1; i++) { k = i; for(j =...

    C语言 选择排序算法

    #include <stdio.h>
    #include <stdlib.h>
    //选择排序算法 
    
    void selectSort(int *arr,int n)
    {
    	int temp, i, j;
    	int k;
    	
    	for(i = 0; i < n - 1; i++)
    	{
    		k = i;
    		for(j = i + 1; j < n; j++)
    		{//循环遍历查找最小的数 
    			if( arr[k] > arr[j])  
    			{ //避免交换元素的次数过多  
    				k = j; 
    			}
    		}
    		if( k != i)
    		{
    			temp = arr[i];
    			arr[i] = arr[k];
    			arr[k] = temp;
    		}
    	}
    }
    
    int main(void)
    {
    	int p[10] = {1, 5, 3, 4, 8, 10, 4, 6, 7, 2};
    	int i;
    	selectSort(p, 10); 
    //		输出 
    	for(i = 0; i < 10; i++)
    	{
    		printf("%d ", p[i]);
    	} 
    	system("pause");
    	return 0; 
    } 
    
    展开全文
  • 本篇文章主要介绍了 C语言选择排序算法,这里提供代码实例以便大家理解,通过本文,更好的理解排序算法
  • 本文主要介绍C语言 选择排序算法,这里对排序算法做了详细说明,并附代码示例,有需要的小伙伴可以参考下
  • c语言加密算法头文件

    2017-10-09 14:52:26
    c语言加密算法头文件下载(base64、md5、sha1),本来不想设资源分,可是好像没有0可以选择
  • c语言排序算法,其中包含插入排序,起泡排序,快速排序,选择排序
  • c语言常用算法整理

    万次阅读 多人点赞 2019-02-26 10:10:57
    这里整理c语言常用算法,主要有: 交换算法 查找最小值算法 冒泡排序 选择排序 插入排序 shell排序 (希尔排序) 归并排序 快速排序 二分查找算法 查找重复算法 代码如下: //交换 void swap(int *a, int *b){ int ...

    这里整理c语言常用算法,主要有:
    交换算法
    查找最小值算法
    冒泡排序
    选择排序
    插入排序
    shell排序 (希尔排序)
    归并排序
    快速排序
    二分查找算法
    查找重复算法

    代码如下:

    //交换
    void swap(int *a, int *b){
        int tmp=*a;
        *a=*b;
        *b=tmp;
    }
    
    //查找最小
    int min(int x, int y) {
        return x < y ? x : y;
    }
    
    typedef struct _Range {
        int start, end;
    } Range;
    
    Range new_Range(int s, int e) {
        Range r;
        r.start = s;
        r.end = e;
        return r;
    }
    
    
    //冒泡排序
    void looperSort(int *arr, int len){
        int i,j;
        for (i = 0; i < len - 1; ++i) {
            for (j = 0; j < len - 1-i; ++j) {
                if (arr[j]>arr[j+1]){
                    swap(&arr[j], &arr[j+1]);
                }
            }
        }
    }
    
    //选择排序
    void selectSort(int *arr, int num){
        int min, i, j;
        for (i = 0; i < num - 1; ++i) {
            min=i;
            for (j = i+1; j < num; ++j) {
                if (arr[j]<arr[min]){
                    min=j;
                }
            }
            if (min!=i)
                swap(&arr[min], &arr[i]);
        }
    }
    
    //插入排序
    void insertSort(int *arr, int num){
        int i,j, tmp;
        for (i = 1; i < num; ++i) {
            tmp=arr[i];
            for (j = i; j > 0 && arr[j-1] > tmp; --j) {
                arr[j]=arr[j-1];
            }
            arr[j]=tmp;
        }
    }
    
    //希尔排序
    void shellSort(int *arr, int num) {
        int gap, i, j, temp;
        for (gap = num >> 1; gap > 0; gap = gap >>= 1)
            for (i = gap; i < num; i++) {
                temp = arr[i];
                for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap){
                    arr[j + gap] = arr[j];
                }
                arr[j + gap] = temp;
            }
    }
    
    //归并排序
    void mergeSort(int *arr, int num) {
        int* a = arr;
        int* b = (int*) malloc(num * sizeof(int));
        int seg, start;
        for (seg = 1; seg < num; seg += seg) {
            for (start = 0; start < num; start += seg + seg) {
                int low = start, mid = min(start + seg, num), high = min(start + seg + seg, num);
                int k = low;
                int start1 = low, end1 = mid;
                int start2 = mid, end2 = high;
                while (start1 < end1 && start2 < end2){
                    b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
                }
                while (start1 < end1){
                    b[k++] = a[start1++];
                }
                while (start2 < end2){
                    b[k++] = a[start2++];
                }
            }
            int* temp = a;
            a = b;
            b = temp;
        }
        if (a != arr) {
            int i;
            for (i = 0; i < num; i++)
                b[i] = a[i];
            b = a;
        }
        free(b);
    }
    
    
    void merge_sort_recursive(int arr[], int reg[], int start, int end) {
        if (start >= end)
            return;
        int len = end - start, mid = (len >> 1) + start;
        int start1 = start, end1 = mid;
        int start2 = mid + 1, end2 = end;
        merge_sort_recursive(arr, reg, start1, end1);
        merge_sort_recursive(arr, reg, start2, end2);
        int k = start;
        while (start1 <= end1 && start2 <= end2)
            reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
        while (start1 <= end1)
            reg[k++] = arr[start1++];
        while (start2 <= end2)
            reg[k++] = arr[start2++];
        for (k = start; k <= end; k++)
            arr[k] = reg[k];
    }
    
    //归并排序 递归
    void mergeSort2(int *arr, const int len) {
        int reg[len];
        merge_sort_recursive(arr, reg, 0, len - 1);
    }
    
    
    //快速排序
    void quickSort(int *arr, const int num) {
        if (num <= 0)
            return; // 避免len等於負值時引發段錯誤(Segment Fault)
        // r[]模擬列表,p為數量,r[p++]為push,r[--p]為pop且取得元素
        Range r[num];
        int p = 0;
        r[p++] = new_Range(0, num - 1);
        while (p) {
            Range range = r[--p];
            if (range.start >= range.end)
                continue;
            int mid = arr[(range.start + range.end) / 2]; // 選取中間點為基準點
            int left = range.start, right = range.end;
            do
            {
                while (arr[left] < mid) ++left;   // 檢測基準點左側是否符合要求
                while (arr[right] > mid) --right; //檢測基準點右側是否符合要求
    
                if (left <= right)
                {
                    swap(&arr[left],&arr[right]);
                    left++;right--;               // 移動指針以繼續
                }
            } while (left <= right);
    
            if (range.start < right) r[p++] = new_Range(range.start, right);
            if (range.end > left) r[p++] = new_Range(left, range.end);
        }
    }
    
    void quick_sort_recursive(int arr[], int start, int end) {
        if (start >= end)
            return;
        int mid = arr[end];
        int left = start, right = end - 1;
        while (left < right) {
            while (arr[left] < mid && left < right)
                left++;
            while (arr[right] >= mid && left < right)
                right--;
            swap(&arr[left], &arr[right]);
        }
        if (arr[left] >= arr[end])
            swap(&arr[left], &arr[end]);
        else
            left++;
        if (left)
            quick_sort_recursive(arr, start, left - 1);
        quick_sort_recursive(arr, left + 1, end);
    }
    //快速排序 递归
    void quickSort2(int *arr, int len) {
        quick_sort_recursive(arr, 0, len - 1);
    }
    
    //二分查找
    int halfSearch(int key, int *a, int n) //自定义函数binary_search()
    {
        int start=0;
        int end=n-1;
        while (start<=end){
            int middle=(start+end)/2;
            if (key<a[middle]){
                end=middle-1;
            } else if (key>a[middle]){
                start=middle+1;
            } else{
                return middle;
            }
        }
        return -1;
    }
    
    //查找重复
    void searchRepeat(int *arr, int num, int searchKey){
        for (int i = 0; i < num; ++i) {
            for (int j = i+1; j < num; ++j) {
                if (arr[i]==arr[j]){
                    LOGI("repeat num index:%d", i);
                    break;
                }
            }
        }
    }
    

    如果对你有帮助记得点赞哦!!!

    展开全文
  • C语言经典算法,包括1.汉若塔 2 2.费式数列 3 3. 巴斯卡三角形 4 4.三色棋 5 5.老鼠走迷官(一) 7 6.老鼠走迷官(二) 9 7.骑士走棋盘 10 8.八皇后 13 9.八枚银币 15 10.生命游戏 17 11.字串核对 20 12.双色、三色...
  • 冒泡排序算法的思想是不断的交换,通过交换完成最终的排序。 选择排序的基本思想是每一趟在n-i+1个记录中选取最小的记录,作为第i个的记录。 1 void SimpleSelectSort(int *p) 2 { 3 int i,j,min; 4 for...

    冒泡排序算法的思想是不断的交换,通过交换完成最终的排序。

    选择排序的基本思想是每一趟在n-i+1个记录中选取最小的记录,作为第i个的记录。

     1 void SimpleSelectSort(int *p)
     2 {
     3     int i,j,min;
     4     for(i=0;i<10;i++)
     5     {
     6         min=i;    //将当前下标定义为最小下标
     7         for(j=i+1;j<10;j++)
     8         {
     9             if(p[min>p[j]])    //如果有小于当前最小值的
    10             {    
    11                 min=j;    //将此值的下标赋值给min
    12             }
    13         }
    14         if(i!=min)    //若min不等与i,说明找到了最小值,进行交换
    15         {
    16             swap(p,i,min);
    17         }
    18     }
    19 }

    特点:移动次数少

    比较次数:无论什么情况,比较次数为n-1+n-2+...+2+1=n(n-1)/2

    交换次数:最好为0,最差为n-1

    时间复杂度O(n2)

    转载于:https://www.cnblogs.com/DaLiNDluDlu/p/5258057.html

    展开全文
  • C语言全套资料 C语言程序设计 C语言算法 C语言课件 C语言顺序程序设计,C语言数组,C语言循环控制,C语言预处理命令,C语言文件操作指针,C语言选择结构程序设计,C语言结构体与共用体,C语言文件操作,C语言函数
  • C语言经典算法大全

    2018-10-13 00:14:34
    C语言经典算法大全 老掉牙 河内塔 费式数列 巴斯卡三角形 三色棋 老鼠走迷官(一) 老鼠走迷官(二) 骑士走棋盘 八个皇后 八枚银币 生命游戏 字串核对 双色、三色河内塔 背包问题(Knapsack Problem...
  • 好用的C语言滤波算法

    2018-08-06 16:28:20
    C语言滤波算法 ADC采集滤波算法,直接移植,很好用 使用插入排序的方法,将一个无序的数组按照从小到大进行排序 1、将数组进行平均滤波,参与平均滤波的数组起始位置可以通过参数选 * 择,即不一定对数组中的所有...
  • c语言选择排序算法

    2011-12-26 19:12:02
    该代码可以在vc++, vs 里编译运行通过
  • 在使用选择排序的时候应当注意与冒泡排序算法的区别,主要区别在于冒泡排序不固定数组中比较的元素,比较的为相邻的两个元素,而选择排序会选择一个固定的头或者尾,再将每一次比较出来的最大/最小值放到固定的头或...
  • C语言排序算法

    千次阅读 2021-03-16 15:56:56
    元素集合越接近有序,直接插入排序算法的时间效率越高 时间复杂度:O(N^2) 空间复杂度:O(1),它是一种稳定的排序算法 稳定性:稳定 直接选择排序的特性总结: 直接选择排序思考非常好理解,但是效率不是很好,...
  • c语言课件 算法

    2012-07-12 22:15:30
    C语言的语句 与其它高级语言一样,C语言也是利用函数体中的可执行语句,向计算机...( 1)选择结构控制语句 if()~else~, switch()~ (2)循环结构控制语句 do~while(), for()~, while()~, break, continue
  • c语言Dijkstra算法

    2020-11-09 15:49:22
    /Dijkstra算法:解决最短路径问题,从一个初始点v0出发,设置lowcost[]数组,记录初始点到每一个顶点的最短路径,设置path[]数组 记录初始点到每个点最短路径所经过的每一个点,设置visit[]数组,记录已经选入low...
  • C语言 排序算法

    2019-11-25 18:50:00
    冒泡排序 冒泡排序(英语:Bubble Sort)是一...选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序...
  • C语言排序算法

    2020-03-10 14:18:18
    C语言常用排序算法选择排序 选择排序算法 #include<stdio.h> #define SIZE 10 void SelectionSort(int *a,int len){ int i,j,k,temp,h; for(i=0;i<len-1;i++){ k=i; for(j=i+1;j<len;j++){ if(a...
  • C语言排序算法.zip

    2020-04-14 15:52:58
    包括7种排序 直接插入排序、希尔排序、快速排序、简单选择排序、堆排序、归并排序、基数排序,C语言实现。
  • C语言常见算法

    2019-10-15 12:28:02
    常见算法 一、数组排序 选择排序、插入排序、交换排序 1.直接插入排序 将待排序的数按大小,插到前面排好数据的适当位置。 11,8,1,10,7,4,12,2,3,6,5,9 实现方法:在已排数据中,只要比待排大,则向后...
  • C语言常用算法源代码

    2009-05-19 17:42:36
    C语言常用算法源代码,对于想好好学习c语言的来说是一个不错的选择!他会给你帮助的!
  • C语言 算法选择排序

    2019-12-30 22:48:34
    C语言算法 选择排序 #include <stdio.h> main() { int i,j,t; int a[10]; printf("请输入10个数:"); for (i=0;i<10;i++) scanf("%d",&a[i]); for (i=0;i<9;i++) for (j=i+1;j<=10;j++...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,247
精华内容 1,298
关键字:

c语言选择算法

c语言 订阅