精华内容
下载资源
问答
  • 插入排序C

    2019-04-23 14:04:51
    #include<iostream> using namespace std; void insertSort(int arr[],int len) { for (int i = 1; i < len; i++) { int j = i; while (j > 0 && arr[j] <...

    #include<iostream>
    using namespace std;

    void insertSort(int arr[],int len)
    {
        for (int i = 1; i < len; i++)
        {
                int j = i;
                while (j > 0 && arr[j] < arr[j - 1])
                {
                        swap(arr[j], arr[j - 1]);
                        j--;
                }
        }
    }
    void showArr(const int arr[],int len)
    {
        for (int i = 0; i < len; i++)
        {
            cout << arr[i] << endl;
        }
    }

    int main()
    {
        int arr[] = { 1,3,5,7,9,2,4,6,8,10 };
        int len = size(arr);
        insertSort(arr,len);
        showArr(arr,len);
        system("pause");
        return EXIT_SUCCESS;
    }

    展开全文
  • 插入排序 插入排序的基本思想:每次将一个待排序序列按其关键字大小插入到前面已经排好序的子序列中,知道全部记录插入完成。主要有直接插入排序、折半插入排序和...// 直接插入排序c实现,a表示数组,n表示数组大小 /**
  • 以下三种插入排序时间复杂度均为O(n^2) 简单插入排序,简单直接。假定数组有序,插入 i, 从后往前遍历找到适合位置 j,移动 j +1 ~ i -1往后一位,插入i到j中。 void insertSort(int *arr, int numsSize) { int ...

    以下三种插入排序时间复杂度均为O(n^2)

    简单插入排序,简单直接。假定数组有序,插入 i, 从后往前遍历找到适合位置 j,移动 j +1 ~ i -1往后一位,插入i到j中。

    void insertSort(int *arr, int numsSize)
    {
    	int i, j, k, v;
    	for (i = 1; i < numsSize; i++)
    	{
    		for (j = i - 1; j >= 0; j--)
    		{
    			if (arr[i] >= arr[j])
    				break;
    		}
    		v = arr[i];
    		
    		for (k = i; k > j + 1; k--)
    			arr[k] = arr[k-1];
    		arr[k] = v;	
    	}
    	return;
    }

    折半插入排序,和简单插入排序相比减少比较次数,稍稍好那么一丢丢,时间复杂度还是O(n^2)

    void BiInsertSort(int *arr, int numsSize)
    {
    	int high, low, m, i, j, v;
    	for (i = 1; i < numsSize; i++)
    	{
    		high = i - 1;
    		low = 0;
    		v = arr[i];
    		while (low <= high)
    		{
    			m = (low + high)/2;
    			if (arr[m] >= arr[i])
    				high = m - 1;
    			else
    				low = m + 1;
    		}
    		for (j = i; j > low; j--)
    		{
    			arr[j] = arr[j-1];
    		}
    		arr[low] = v;
    	}
    }

    2路插入排序,减少移动次数,额外增加一个循环数组,需要考虑边界溢出,特别容易出错。时间复杂度和其它插入排序相比没有基本改变,不建议使用但是要理解并能够写出代码。first和final分别表示循环数组中的起始位置。

    void insertSort2(int *array, int arraysize)
    {
    	int final, first, i, j, n;
    	final = first = 0;
    
    	if (!array || arraysize < 1)
    		return ;
    		
    	int *tmp = (int *)malloc(sizeof(int) * arraysize);
    	if (!tmp)
    	{
    		printf("malloc error\n");
    		return ;
    	}
    
    	tmp[0] = array[0];
    	for (i = 1; i < arraysize; i++)
    	{
    		if (array[i] >= tmp[0])
    		{
    			//插入到左边
    			j = final;
    			while(array[i] < tmp[j])j--;
    			
    			for (n = ++final; n > j + 1; n--)
    				tmp[n] = tmp[n-1];
    			tmp[n] = array[i];	
    		}
    		else
    		{
    			//插入到右边
    			if (first == 0)
    			{
    				first = arraysize - 1;
    				tmp[first%arraysize] = array[i];
    			}			
    			else
    			{
    				j = first - arraysize;
    				while(tmp[(j + arraysize)%arraysize] < array[i])
    					j++;
    				for (n = (--first - arraysize); n < (j - 1); n++)
    					tmp[(n + arraysize)%arraysize] = tmp[(n + 1 + arraysize)%arraysize];
    					
    				tmp[(n + arraysize)% arraysize] = array[i]; 
    			}
    		}
    	}
    }

    =============================================================================================

    Linux应用程序、内核、驱动、后台开发交流讨论群(745510310),感兴趣的同学可以加群讨论、交流、资料查找等,前进的道路上,你不是一个人奥^_^。
     

    展开全文
  • 冒泡排序 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。 需求: 排序前 :{4,5,6,3,2,1}; 排序前 :{1,2,3,4,5,6};...bubbleSort.c static void compareSwap(int *a, int *b) { if

    冒泡排序

    冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。
    需求:
    排序前 :{4,5,6,3,2,1};
    排序前 :{1,2,3,4,5,6};

    排序原理:

    1.比较相邻的元素。如果前一个元素比后一个元素大,就交换这两个元素的位置。
    2对每一对相邻元素做同样的工作,从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
    在这里插入图片描述

    bubbleSort.c
    static void Swap(int *a, int *b)
    {
    	int temp = *a;
    	*a = *b;
    	*b = temp;
    }
    static int Compare(int x, int y)
    {
        return ((x) > (y)) ? (1) : (0);
    }
    static void bubbleSort(int *arr, int len)
    {
    	for (int i = 0; i < len - 1; i++){
    		for (int j = 0; j < len - i - 1; j++){
                if(Compare(arr[j], arr[j+1])){
    				Swap(&arr[j], &arr[j+1]);
    			}
    		}
    	}
    }
    
    run:在这里插入图片描述#### 冒泡排序的时间复杂度 O(N^2)

    冒泡排序使用了双层for循环,其中内层循环的循环体是真正完成排序的代码,
    所以,我们分析冒泡排序的时间复杂度,主要分析一下内层循环体的执行次数即可。
    最坏情况下,也就是假如要排序的元素为=={6,5,4,3,2,1}==逆序,那么∶

    元素比较的次数为︰
    (N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
    元素交换的次数为︰
    (N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
    总执行次数为︰
    (N^2/2-N/2)+(N^2/2-N/2)=N^2-N; ==>O(N^2)
    

    按照大O推导法则,保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2)

    选择排序

    选择排序是一种更加简单直观的排序方法。
    需求:
    排序前 :{4, 6, 8, 7, 9, 2, 10, 1};
    排序前 :{1, 2, 4, 6, 7, 8, 9, 10};

    排序原理∶

    1.每一次遍历的过程中,都假定第一个索引元素是最小值,和其他索引处的值依次进行比较
    如果当前索引处的值大于其他某个索引处的值,则假定其他某个索引出的值为最小值,最后可以找到最小值所在的索引。
    2.交换第一个索引处和最小值所在的索引处的值。
    在这里插入图片描述

    selectionSort.c
    static void swap(int *a, int *b)
    {
    	int temp = *a;
    	*a = *b;
    	*b = temp;
    }
    static int Compare(int x, int y)
    {
        return ((x) > (y)) ? (1) : (0);
    }
    static void selectionSort(int* arr, int len)
    {
    	for (int i = 0; i <= len - 2 ; i++){ 
    		int minIndex = i; 
    		for (int j = i +1; j < len ; j++){
                if(Compare(arr[minIndex],arr[j])){
    				minIndex = j;
    			}
    		}
    		swap(&arr[minIndex],&arr[i]);
    	}
    }
    
    run:

    在这里插入图片描述

    选择排序的时间复杂度 O(N^2)

    选择排序使用了双层for循环,其中外层循环完成了数据交换,内层循环完成了数据比较。

    插入排序

    插入排序( Insertion sort )是一种简单直观且稳定的排序算法。
    插入排序的工作方式非常像人们排序一手扑克牌一样。开始时,我们的左手为空并且桌子上的牌面朝下。然后,我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置,我们从右到左将它与已在手中的每张牌进行比较,如下图所示∶
    在这里插入图片描述
    需求:
    排序前: {4,3,2,10,12,1,5,6}
    排序后: {1,2,3,4,5,6,10,12}

    排序原理︰

    1. 把所有的元素分为两组,已经排序的和未排序的;
    2. 找到未排序的组中的第一个元素,向已经排序的组中进行插入;
    3. 倒序遍历已经排序的元素,依次和待插入的元素进行比较,直到找到一个元素小于等于待插入元素,那么就把待插入元素放到这个位置,其他的元素向后移动一位;
      在这里插入图片描述
    selectionSort.c
    static void Swap(int *a, int *b)
    {
    	int temp = *a;
    	*a = *b;
    	*b = temp;
    }
    static int Compare(int x, int y)
    {
        return ((x) > (y)) ? (1) : (0);
    }
    static void selectionSort(int* arr, int len)
    {
    	for (int i = 0; i < len ; i++){
    		for (int j = i + 1; j >= 0; j--){
                if(Compare(arr[j-1], arr[j])){
    				Swap(&arr[j-1], &arr[j]);
    			}
    		}
    	}
    }
    
    run:

    在这里插入图片描述

    插入排序的时间复杂度 O(N^2)

    插入排序使用了双层for循环,其中内层循环的循环体是真正完成排序的代码,所以,我们分析插入排序的时间复杂度
    主要分析一下内层循环体的执行次数即可。
    最坏情况下,也就是假如要排序的元素为=={12,10,6,5,4,3,2,1}==逆序,那么∶

    元素比较的次数为︰
    (N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
    元素交换的次数为︰
    (N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;
    总执行次数为︰
    (N^2/2-N/2)+(N^2/2-N/2)=N^2-N; ==>O(N^2)
    

    按照大O推导法则,保留函数中的最高阶项那么最终插入排序的时间复杂度为O(N^2)

    展开全文
  • 对链表进行插入排序 插入排序的动画演示如上。从第一个元素开始,该链表可以被认为已经部分排序(用黑色表示)。 每次迭代时,从输入数据中移除一个元素(用红色表示),并原地将其插入到已排好序的链表中。 插入...

    对链表进行插入排序



    插入排序算法:

    插入排序是迭代的,每次只移动一个元素,直到所有元素可以形成一个有序的输出列表。
    每次迭代中,插入排序只从输入数据中移除一个待排序的元素,找到它在序列中适当的位置,并将其插入。
    重复直到所有输入数据插入完为止。

    示例 1:

    输入: 4->2->1->3
    输出: 1->2->3->4
    示例 2:

    输入: -1->5->3->4->0
    输出: -1->0->3->4->5



    思路:

    假定链表头结点为有序链表,取新链表节点对假定的有序链表进行插入排序。
    在这里插入图片描述

    如图

    在这里插入图片描述

    代码示例:

    typedef struct ListNode Node;
    
    struct ListNode* insertionSortList(struct ListNode* head){
    
        if(head == NULL || head->next == NULL)
            return head;
    	//sort链表头节点
        Node* sorthead = head;
    	//新链表头
        Node* newhead = head->next;
    
        //解除sort链表和后续的连接。
        sorthead->next = NULL;
    	
        Node* cur = newhead;
        
        while(cur)
        {	//保留next节点。
            Node* next = cur->next;
    
            if(cur->val < sorthead->val) //头插
            {
                cur->next = sorthead;
                sorthead = cur;
            }
            else
            {
                Node* prev = sorthead;
                Node* sortcur = sorthead->next;
    			
    			//寻找插入节点。
                while(sortcur && cur->val >= sortcur->val)
                {
                    
                    prev = sortcur;
                    sortcur = sortcur->next;
                }
    
                if(sortcur)
                {
                    cur->next = sortcur;
                    prev->next = cur;
                }
    			
    			//如果为null,说明大于全部节点,进行尾插。
                if(sortcur == NULL)
                {
                    prev->next = cur;
                    cur->next = NULL;
                }
            }
    
            cur = next;
        }
    
        return sorthead;
    }
    
    展开全文
  • 插入排序C实现

    2014-03-26 16:06:37
    插入排序算法时间复杂度O(n*n),在内嵌生成十万随机数生成下,插入算法在该条件下平均运行时间在7s。 #include #include #define LEN 100000 //数据量:十万 void insertSort(int arr[],int len); int main...
  • 折半插入排序就是查找操作使用折半查找的直接插入排序,除此之外它与直接插入排序基本一样。 算法属性: 时间复杂度为O(n^2) 空间复杂度为O(1) 稳定排序。 因为要进行折半查找, 所以只能用于顺序结构。 适合初始...
  • 希尔排序是跨度大一点的直接插入排序,直接插入排序可以看成一趟增量是 1 的希尔排序。 算法属性: 时间复杂度取决于所选取的增量序列。 空间复杂度为O(1) 不稳定排序。 只能用于顺序结构,并且最后 一个增量值必须...
  • 直接插入排序C/C++

    2018-04-17 21:06:00
    void InsertionSort(int a[],int len); /* 算法: ...//由小到大的直接插入排序 direct insertionsort void InsertionSort(int a[],int len) { int i,j; int temp; for(i=1;i<len;i++){ ...
  • 插入排序 C实现

    2015-06-30 13:28:39
    #include void insertion_sort(int array[], int n) { int i, j, temp; for (i = 0; i { temp = array[i]; for (j = i - 1; j >= 0 && array[j] > temp; j--) { array[j + 1] = array[j];...array
  • 常用排序算法之插入排序c及lua实现

    千次阅读 2014-07-08 11:01:48
    插入排序(Insertion Sort)的算法描述是一种简单直观的排。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用...
  • 折半插入排序C/C++

    2018-04-17 21:19:00
    void BinaryInsertionSort(int a[],int left,int right)...//对数组a[left]到a[right]段数据从小到大排序 void BinaryInsertionSort(int a[],int left,int right) { int low,middle,high; int temp; int i,j...
  • C/C++实现 将整个数组a分为有序和无序的两个部分。有序的在前面,无序的在后面。 一开始有序的部分只有a[0],其余部分都属于无序的部分 每次取出无序最左边的元素,把他加入有序的部分。 假设插...
  • //直接插入排序 void InsertSort(SqList &L) { int i, j; for (i = 2; i ; ++i) { L.r[0] = L.r[i]; j = i - 1; while (L.r[0].key [j].key) //向后移动 { L.r[j + 1] = L.r[j]; j--; } L....
  • /*插入排序 * *dev/c++ 输入结束 *按回车键 *再加上俩ctrl+z才能运行 */ #include&amp;lt;cstdio&amp;gt; #include&amp;lt;iostream&amp;gt; using namespace std; void insertSort...
  • 1.特点 :在部分有序的情况下,插入排序效率很高,和选择排序 不一样的是,排序的效率受输入序列的影响很大  平均时间复杂度O(n^2) 最好情况下 O(n) 最坏情况下O(^2) 2.代码实现 迭代的方式实现  void ...
  • 插入排序

    2017-10-02 19:56:06
    插入排序C/C++实现
  • 经典排序方法 插入排序.c C语言 排序 插入排序
  • 想必各种数据结构和算法的书上...1、 简单插入排序。最原始的插入排序,不多说,直接上码。 void insertSort(int *array,int len) { if(NULL == array|| 1 == len) return; //检测还是要的 int i,j; for(i = 1;i;

空空如也

空空如也

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

插入排序c