精华内容
下载资源
问答
  • 主要介绍了JavaScript实现链表插入排序链表归并排序,较为详细的分析了插入排序和归并排序,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下。
  • 对链表进行排序

    2019-12-26 19:43:07
    对链表进行排序。 思路: 1.借助辅助列表list,将链表中的值压入到list。 2.list进行排序,将排好序的list中的值返回到链表里。 /** * Definition for singly-linked list. * struct ListNode { * int val...

    半✅\(^o^)/~

    题目描述

    对链表进行排序。

    思路:

    1.借助辅助列表list,将链表中的值压入到list。

    2.对list进行排序,将排好序的list中的值返回到链表里。

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     ListNode *next;
     *     ListNode(int x) : val(x), next(NULL) {}
     * };
     */
    class Solution {
    public:
        ListNode *insertionSortList(ListNode *head) {
            if(head==nullptr||head->next==nullptr)
                return head;
            list<int> v;
            for (ListNode* p=head; p!=nullptr; p=p->next)
            {
                v.push_back(p->val);
            }
            v.sort();
            for(ListNode* p=head; p!=nullptr; p=p->next)
            {
                p->val = v.front();
                v.pop_front();
            }
            return head;
            
        }
    };

    快速排序:

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     ListNode *next;
     *     ListNode(int x) : val(x), next(NULL) {}
     * };
     */
    class Solution {
    public:
        ListNode *insertionSortList(ListNode *head) {
            if (head==nullptr||head->next==nullptr)
                return head;
            insertionSortList(head, nullptr);
            return head;
        }
        void insertionSortList(ListNode*head, ListNode*end)
        {
            if (head!=nullptr||head->next!=nullptr)
            {
                ListNode* p1=head;
                ListNode* p2=head;
                while(p2->next!=nullptr)
                    p2=p2->next;
                int pivot= p2->val;
                p2=head;
                while(p2->next!=nullptr)
                {
                    if (p2->val<pivot)
                    {
                        int tmp= p2->val;
                        p2->val=p1->val;
                        p1->val=tmp;
                        p1=p1->next;
                    }               
                    p2=p2->next;
                }
                p2->val=p1->val;
                p1->val=pivot;
                insertionSortList(head,p1);
                insertionSortList(p1->next,end);
            }
        }
    };

     

    展开全文
  • 链表插入排序

    2016-12-26 17:22:19
    给出若干个数,将数字存储在链表中,然后使用插入排序,按照升序排列输出数字。 输入一个整数n表示有n个数,接着输入这n个数。 按照升序输出这n个数。
  • C语言实现多种链表快速排序
  • 对链表进行插入排序(C语言实现)

    千次阅读 2021-01-09 10:26:11
    对链表进行插入排序。 插入排序的动画演示如下。从第一个元素开始,该链表可以被认为已经部分排序(用黑色表示)。 每次迭代时,从输入数据中移除一个元素(用红色表示),并原地将其插入到已排好序的链表中。 插入...

    一、题目要求

    对链表进行插入排序。

    插入排序的动画演示如下。从第一个元素开始,该链表可以被认为已经部分排序(用黑色表示)。
    每次迭代时,从输入数据中移除一个元素(用红色表示),并原地将其插入到已排好序的链表中。
    在这里插入图片描述

    插入排序算法:

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

    示例 1:

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

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

    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/insertion-sort-list
    著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

    二、思路

    这道题的图容易让人产生误解,按照图中显示,每个元素都是从后往前进行比较的,而单向链表支持从后往前访问。了解这个误区后,我们再想想,既然是从前往后遍历,我们不妨建立一个新的链表,新链表的初始只有一个节点,就是原链表的头结点,原链表依次往后遍历,每一个节点都有序插入到新链表中,左后得到的新链表就是有序的。

    三、图解

    在这里插入图片描述

    1. 这是原链表在这里插入图片描述

    2. 创建一个新的链表,第一个节点为原链表的头结点,原链表的第二个节点现在要有序插入到新链表中,此次插入为头插在这里插入图片描述

    3. 插入后,原链表继续往下遍历在这里插入图片描述

    4. 再次往下遍历插入在这里插入图片描述

    5. 直到cur为空结束

    四、代码实现

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     struct ListNode *next;
     * };
     */
    typedef struct ListNode Node;
    struct ListNode* insertionSortList(struct ListNode* head){
        if (head == NULL || head->next == NULL) {//链表为空或只有一个节点直接返回
    		return head;
    	}
    	Node* sorthead = head;//定义新的链表,把原链表的每个节点有序插入到新链表中去
    	Node* cur = head->next;
        Node* sorttail = head;//新链表的尾结点,方便尾插
        sorttail->next = NULL;//尾结点的next域置空
        while(cur){
            Node* sortcur = sorthead;
            Node* prev = NULL;
            while(sortcur && cur->val >= sortcur->val){//原链表的cur节点在新链表中找到插入的位置
                prev = sortcur;
                sortcur = sortcur->next;
            }
            if(sortcur == NULL){//原链表的cur节点比新链表中每个节点都大,执行尾插
                sorttail->next = cur;
                cur = cur->next;
                sorttail = sorttail->next;
                sorttail->next = NULL;
            }
            else if(prev == NULL){//cur节点比新链表中每个节点都小,执行头插
                Node* next = cur->next;
                cur->next = sorthead;
                sorthead = cur;
                cur = next;
            }
            else{//不是尾插,也不是头插,指定位置插入
                prev->next = cur;
                cur = cur->next;
                prev->next->next = sortcur;
            }
        }
        head = sorthead;
    	return head;//返回原链表的头
    }
    

    五、运行结果

    在这里插入图片描述

    展开全文
  • 利用插入排序对链表进行排序

    千次阅读 2018-08-15 22:08:00
    下图是 4-15-9-1插入排序的举例 当if(p.val&lt;=p.next.val){  p=p.next;} 当不满足条件时 q=p.next p.next=q.next  这时候,需要把q节点放到p节点之前的合适位置,即 while(r.next.val&lt;=q.val)...

     下图是对 4-15-9-1插入排序的举例

    当if(p.val<=p.next.val){
                    p=p.next;}  当不满足条件时 q=p.next  p.next=q.next 

    这时候,需要把q节点放到p节点之前的合适位置,即

    while(r.next.val<=q.val){
                        r=r.next;
                    }

    当条件满足时 r后移,当不满足时表示,找到比q节点大的数,那么需要把q节点放入r.next之前

    q.next=r.next;
       r.next=q;

    具体代码如下:

      public ListNode insertionSortList(ListNode head) {
            if(head == null || head.next== null){
                return head;
            }
            ListNode head1 = new ListNode(0);
            head1.next=head;
            ListNode p = head;
            ListNode q;
            ListNode r;
            while(p != null && p.next != null){
                if(p.val<=p.next.val){
                    p=p.next;
                }else{
                    q=p.next;
                    p.next=q.next;
                    r=head1;
                    while(r.next.val<=q.val){
                        r=r.next;
                    }
                    q.next=r.next;
                    r.next=q;
                }
            }
            
            return head1.next;
            
        }

    展开全文
  • C/C++ 编写函数,通过输入单向链表的头指针,对链表的value进行排序,返回排序后单向链表的头指针
  • 主要介绍了C语言数据结构 链表与归并排序实例详解的相关资料,需要的朋友可以参考下
  • SCIE, University of Electronic Science and Technology of China * 2.1.2单链表 四链表的特点 操作的顺序性 有平均次查找过程 离散存放 不受链表大小限制 不进行链点内容的搬移 查找操作数组效率优于链表 插入删除...
  • 基数排序(radix sort)又称桶排序(bucket sort)...并且按照数字位的值数据项进行排序,这种方法不需要进行比较操作。 为了尽可能少的消耗复制时占用的空间,桶的数据结构选择链表,为了构造队列,选择使用双向列表。
  • 单向链表实现基排序

    2017-04-08 02:41:37
    利用单链表实现基排序算法
  • 对链表进行插入排序(图解)

    千次阅读 多人点赞 2020-12-16 17:00:35
    图解 对链表进行插入排序 该题目力扣链接 点击这里 从前往后找插入点 插入排序的基本思想是,维护一个有序序列,初始时有序序列只有一个元素,每次将一个新的元素插入到有序序列中,将有序序列的长度增加 1,直到...

    图解 对链表进行插入排序

    该题目力扣链接
    点击这里

    从前往后找插入点

    插入排序的基本思想是,维护一个有序序列,初始时有序序列只有一个元素,每次将一个新的元素插入到有序序列中,将有序序列的长度增加 1,直到全部元素都加入到有序序列中。

    如果是 数组 的插入排序,则数组的前面部分是有序序列,每次找到有序序列后面的第一个元素(待插入元素)的插入位置,将有序序列中的插入位置后面的元素都往后移动一位,然后将待插入元素置于插入位置。

    对于 链表 而言,插入元素时只要更新相邻节点的指针即可,不需要像数组一样将插入位置后面的元素往后移动,因此插入操作的时间复杂度是 O(1),但是找到插入位置需要遍历链表中的节点,时间复杂度是 O(n),因此链表插入排序的总时间复杂度仍然是 O(n^2),其中 n 是链表的长度。

    对于单向链表而言,只有指向后一个节点的指针,因此需要从链表的头节点开始往后遍历链表中的节点,寻找插入位置。

    对链表进行插入排序的具体过程如下。

    首先判断给定的链表是否为空,若为空,则不需要进行排序,直接返回。
    
    创建哨兵节点 newnode,令 newnode->next = head。引入哨兵节点是为了便于在 head 节点之前插入节点。
    
    维护 sortlast 为链表的已排序部分的最后一个节点,初始时 lastSorted = head。
    
    维护 cur 为待插入的元素,初始时 cur = head->next。
    
    比较 sortlast 和 cur 的节点值。
    
        若 sortlast->val <= cur->val,说明 cur 应该位于 sortlast  之后,将 sortlast  后移一位,cur 变成新的 sortlast 。
    
        否则,从链表的头节点开始往后遍历链表中的节点,寻找插入 cur 的位置。令 pre 为插入 cur 的位置的前一个节点,进行如下操作,完成对 cur 的插入:
    
    sortlast->next = cur->next;
    cur->next = pre->next;
    pre->next = cur;
    

    令 cur = sortlast->next,此时 cur 为下一个待插入的元素。

    重复第 5 步和第 6 步,直到 cur 变成空,排序结束。

    返回 newnode->next,为排序后的链表的头节点。

    实现原理如下图所示

    在这里插入图片描述

    实现代码:

    struct ListNode* insertionSortList(struct ListNode* head) 
    {
    	//如果头节点为空或者只有一个节点,则直接返回头节点
    	if ((head == NULL) || (head->next == NULL))
    		return head;
    	//开辟一个新的哨兵节点,其next存放头节点的地址
    	struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
    	newnode->next = head;
    	//排序链表的最后一个节点
    	struct ListNode* sortlast = head;
    	struct ListNode* cur = head->next;
    	//遍历链表所有节点
    	while (cur)
    	{
    		//需要插入的结点val大于等于排序链表最后一个节点的val,直接进行尾插,并更新sortlast
    		if (cur->val >= sortlast->val)
    		{
    			sortlast->next = cur;
    			sortlast = cur;
    		}
    		//从链表头开始寻找插入位置
    		else
    		{
    			struct ListNode* pre = newnode;
    			while (pre->next->val < cur->val)
    			{
    				pre = pre->next;
    			}
    			sortlast->next = cur->next;
    			cur->next = pre->next;
    			pre->next = cur;
    		}
    		cur = sortlast->next;
    	}
    	return newnode->next;
    }
    
    展开全文
  • 对链表进行插入排序

    千次阅读 2019-09-08 18:12:43
    对链表进行插入排序 题目 对链表进行插入排序。 插入排序算法: 插入排序是迭代的,每次只移动一个元素,直到所有元素可以形成一个有序的输出列表。 每次迭代中,插入排序只从输入数据中移除一个待排序的元素,找到...
  • 经典的双向链表排序算法。涵盖创建,删除,排序,获取,增加等
  • C语言链表排序操作

    2017-06-29 13:41:43
    链表创建、排序操作
  • 对链表进行插入排序。 插入排序的动画演示如上。从第一个元素开始,该链表可以被认为已经部分排序(用黑色表示)。 每次迭代时,从输入数据中移除一个元素(用红色表示),并原地将其插入到已排好序的链表中。 ...
  • 链表实现冒泡排序

    2016-05-15 09:13:23
    自己写的程序,里面有完整的注释,主要用c语言实现。
  • 对链表进行相应操作 链表为双向链表 其中的操作有 快速排序 选择排序 插入 删除链表链表中获取一个数等等 程序并没有测试周全 欢迎下载 若发现问题希望在我CSDN留言 以便及时更改
  • 这是一个用两种方法对链表进行排序,一种是简单的冒泡排序,一种是交换指针的方法
  • 动态内存的分配,在输入一系列正整数的同时输入的书进行排序
  • C语言中数据结构之链表归并排序实例代码 问题  设有两个无头结点的单链表,头指针分别为ha,hb,链中有数据域data,链域next,两链表的数据都按递增排序存放,现要求将hb表归到ha表中,且归并后ha仍递增序,归并中...
  • 链表快速排序

    2018-01-06 18:29:54
    能够将用户给定的值生成一个随机数组然后进行排序,递归实现
  • 对链表排序有两种方法: (1)比较了两个节点的大小后,指针进行改变,从而交换节点的顺序; (2)比较了两个节点的大小后,只交换数据域,而不改变指针,从而交换节点的顺序。 第二种办法比较简单,本文主要第...
  • 数据结构之双向链表地 Java 实现 单链表只能从前往后遍历 ,如果链表地长度较大 , 遍历到链表后半部分地时候想 要往前查找 ,就只能回到开头 ,重新遍历了 . 双向链表提供了这个能力 , 即允许前向遍历 , 也允许后向遍历...
  • 首先用快慢指针的方法找到链表中间节点,然后递归的两个子链表排序,把两个排好序的子链表合并成一条有序的链表。归并排序应该算是链表排序最佳的选择了,保证了最好和最坏时间复杂度都是nlogn,而且它在数组排序...
  • 双向链表排序

    千次阅读 2020-03-03 20:35:49
    用单个指针单一方向进行排序,利用选择法排序的方法进行排序,对于链表排序的关键在于要和数组的排序方法一一对应,由于链表并不知道有多少个节点,也即不知道要进行多少次循环,所以对于数组中的惯用for循环就不...
  • 做LeetCode时遇到的一个小问题,总结一下。 链表定义为如下 public class ListNode {  int val;...要求用插入排序对进行排序,并返回第一个节点。 解决方案的代码如下: public class Solution {
  • 对链表进行插入排序。 插入排序算法: 插入排序是迭代的,每次只移动一个元素,直到所有元素可以形成一个有序的输出列表。 每次迭代中,插入排序只从输入数据中移除一个待排序的元素,找到它在序列中适当的位置,并...
  • 链表排序

    多人点赞 热门讨论 2021-09-11 12:29:42
    148. 排序链表 你链表的头结点 head ,请将其按 升序 排列并返回 排序后的链表 。 进阶: 你可以在 O(n log n) 时间复杂度和常数级...链表排序的最佳方法:归并排序 1.找到中间节点 2.将中间节点断成左右两半,然后

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 253,695
精华内容 101,478
关键字:

对动态链表进行排序