精华内容
下载资源
问答
  • c++链表排序

    2012-01-13 17:00:38
    使用c++的类和结构体指针,对链表进行排序,而且排序链表和排好序的链表是同一个链表,不借助其他临时链表
  • c++ 链表排序

    千次阅读 2019-05-11 19:08:50
    node *bubbleSortList(node *head) { if (head == NULL || head->next == NULL) return head; node *p = NULL; bool isChange = true; while (p != head->next->next && i...
    node *bubbleSortList(node *head)
    {
        if (head == NULL || head->next == NULL) return head;
        node *p = NULL;
        bool isChange = true;
        while (p != head->next->next && isChange)
        {
            node *q = head->next;
            isChange = false; //标志当前这一轮中又没有发生元素交换,如果没有则表示数组已经有序
            for (; q->next && q->next != p; q = q->next)
                if (q->data > q->next->data)
                    swap(q->data, q->next->data), isChange = true;
            p = q;
        }
        return head;
    }
    
    展开全文
  • C++链表排序(归并法+快速排序)

    千次阅读 2021-04-18 22:16:34
    链表归并排序的过程如下。 找到链表的中点,以中点为分界,将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法,快指针每次移动 2 步,慢指针每次移动 1步,当快指针到达链表末尾时,慢指针指向的链表...

    在这里插入图片描述
    我们可以试用归并排序解决:
    对链表归并排序的过程如下。

    找到链表的中点,以中点为分界,将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法,快指针每次移动 2 步,慢指针每次移动 1步,当快指针到达链表末尾时,慢指针指向的链表节点即为链表的中点。

    对两个子链表分别排序。

    将两个排序后的子链表合并,得到完整的排序后的链表

    上述过程可以通过递归实现。递归的终止条件是链表的节点个数小于或等于 1,即当链表为空或者链表只包含 1 个节点时,不需要对链表进行拆分和排序。

    
    class Solution {
    public:
        ListNode* sortList(ListNode* head) {
            return sortList(head, nullptr);
        }
    
        ListNode* mergesort(ListNode* head, ListNode* tail) {
            if (head == nullptr) {
                return head;
            }
            if (head->next == tail) {
                head->next = nullptr;
                return head;
            }
            ListNode* slow = head, * fast = head;
            while (fast != tail) {
                slow = slow->next;
                fast = fast->next;
                if (fast != tail) {
                    fast = fast->next;
                }
            }
     
            return merge( mergesort(head, slow),  mergesort(slow, tail));
        }
    
        ListNode* merge(ListNode* head1, ListNode* head2) {
            ListNode* dummyHead = new ListNode(0);
            ListNode* temp = dummyHead, * temp1 = head1, * temp2 = head2;
            while (temp1 != nullptr && temp2 != nullptr) {
                if (temp1->val <= temp2->val) {
                    temp->next = temp1;
                    temp1 = temp1->next;
                }
                else {
                    temp->next = temp2;
                    temp2 = temp2->next;
                }
                temp = temp->next;
            }
            if (temp1 != nullptr) {
                temp->next = temp1;
            }
            else if (temp2 != nullptr) {
                temp->next = temp2;
            }
            return dummyHead->next;
        }
    };
    

    快速排序不能随机选取节点,时间复杂度太高所以会超时

    class Solution {
        public static ListNode sortList(ListNode head) {
            return quickSort(head ,null);
        }
    
        public static ListNode quickSort(ListNode head ,ListNode end){
            if(head ==end || head.next ==end) return head;
            ListNode lhead = head ,utail = head ,p = head.next;
            while (p != end){
                ListNode next = p.next;
                if(p.val < head.val){//头插
                    p.next = lhead;
                    lhead = p;
                }
                else { //尾插
                    utail.next = p;
                    utail = p;
                }
                p = next;
            }
            utail.next = end;
            ListNode node = quickSort(lhead, head);
            head.next =  quickSort(head.next, end);
            return node;
        }
    }
    
    
    
    展开全文
  • C++链表的冒泡排序

    2021-01-20 23:28:52
    C++链表的冒泡排序 #include <iostream> using namespace std; #include <string> #include <ctime> #define NUM 10 //生成的随机数链表长度 struct Node //链表结构体的定义 { int ...
    #include <iostream>
    using namespace std;
    
    #include <string>
    #include <ctime>
    
    #define NUM 10			//生成的随机数链表长度
    
    struct Node				//链表结构体的定义
    {
    	int value;
    	Node* next;
    }typedef Node;
    
    void BubbleSort(Node* head);		//链表冒泡排序函数
    Node* NodeInit(int num);			//链表初始化
    void PrintNodes(Node* head);		//打印链表各节点的值
    
    int main() {
    	Node* head = NodeInit(NUM);		//创建+赋值一个节点个数为NUM的链表
    	PrintNodes(head);				//排序前打印
    	BubbleSort(head);				//冒泡排序
    	cout << endl;
    	PrintNodes(head);				//排序后打印
    
    	system("pause");
    	return 0;
    }
    
    /*
    链表初始化函数
    功  能:生成一个指定长度链表并赋随机值
    入  口:链表长度
    返回值:链表头节点
    */
    Node* NodeInit(int num) {
    	if (num < 1) {
    		return NULL;
    	}
    	srand(time(NULL));
    	Node* head = new Node;
    	Node* p = head;
    	for (int i = 0; i < num - 1; i++) {		//循环创建节点并赋值
    		p->value = rand() % 100;
    		p->next = new Node;
    		p = p->next;
    	}
    	p->value = rand() % 100;
    	p->next = NULL;							//尾结点的next设为空指针
    
    	return head;							//将头节点指针返回
    }
    
    /*
    链表冒泡排序函数
    功  能:对链表进行排序
    入  口:链表头节点
    返回值:无
    */
    void BubbleSort(Node* head) {
    	if (head == NULL)
    		return;
    
    	Node* tail = NULL;
    
    	for (Node* p = head; p->next != NULL; p = p->next) {	//外循环次数为  链表长度 - 1
    		Node* cur = head;
    		for (; cur->next != tail; cur = cur->next) {
    			if (cur->value > cur->next->value) {			//“>”为从小到大排序
    				int temp = cur->value;
    				cur->value = cur->next->value;
    				cur->next->value = temp;
    			}
    		}
    		tail = cur;											//尾节点前移
    	}
    }
    /*
    链表打印函数
    功  能:对链表各节点进行打印
    入  口:链表头节点
    返回值:无
    */
    void PrintNodes(Node* head) {
    	for (Node* p = head; p != NULL; p = p->next) {
    		cout << p->value << endl;
    	}
    }
    
    
    展开全文
  • C++ 链表排序

    2019-07-09 15:09:44
    1/ 链表插入排序问题。 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ...

    1/ 链表插入排序问题。

    /**
     * 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) {
            ListNode *tmp=new ListNode(INT_MIN);
            //一个额外的节点
          
            ListNode*cur, *t;
            while(head)
            {
                t=head->next;
                //tmp指向的是有序的链表,head指向未排序的原链表
                cur=tmp;
                //获取插入的位置
                while(cur->next && cur->next->val <=head->val)
                {
                    cur=cur->next;
                }
                //head应该插入到cur的后边
                head->next=cur->next;
                cur->next=head;//key question.
                //原未排序链表前进一步。
                head=t;
    
            }
            return tmp->next;
        }
    };

    2/ 链表归并排序

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     ListNode *next;
     *     ListNode(int x) : val(x), next(NULL) {}
     * };
     */
    class Solution {
    public:
        ListNode* sortList(ListNode* head) {
            if(head==NULL || head->next==NULL) return head;
            ListNode*slow=head;
            ListNode*fast=head;
            ListNode*prev=head;
            //分割为两个链表
            while(fast && fast->next)
            {
                prev=slow;
                slow=slow->next;
                fast=fast->next->next;
            }
            prev->next=NULL;
            //递归调用,只有有序的链表才能合并。
            return mergeList(sortList(head),sortList(slow));
        }
        //合并链表
        ListNode* mergeList(ListNode*l1,ListNode* l2)
        {
            if(l1==NULL) return l2;
            if(l2==NULL) return l1;
            if(l1->val<l2->val)
            {
                // 递归调用,减小复杂度,也可用循环来归并
                l1->next=mergeList(l1->next,l2);
                return l1;
            }
            else
            {
                l2->next=mergeList(l1,l2->next);
                return l2;
            }
        }
    
        //迭代
        ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
            ListNode* d=new ListNode(-1),*cur=d;
            while(l1 && l2)
            {
                if(l1->val < l2->val)
                {
                    cur->next=l1;
                    l1=l1->next;
                }
                else
                {
                    cur->next=l2;
                    l2=l2->next;
                }
                cur=cur->next;
            }
            cur->next=l1?l1:l2;
            return d->next;
        }
        
    };

    3/ 链表快速排序

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     ListNode *next;
     *     ListNode(int x) : val(x), next(NULL) {}
     * };
     */
    class Solution {
    public:
        ListNode* partition(ListNode* head, int x) {
            if(!head)
                return NULL;
            ListNode* dump=new ListNode(0);
            dump->next=head;
            ListNode* pre=dump,*cur=head;
            //查找第一个大于等于 x 的值
            while(pre->next && pre->next->val < x)
                pre=pre->next;
            cur=pre;
            // pre 表示小于x 的最后一个值。cur—>next 表示 大于x   (待排序的链表)
            //cout<<pre->val <<" next is"<<pre->next->val<<endl;
            while(cur->next)
            {
                // 
                if(cur->next->val < x)
                {
                    //将 cur->next 节点插入到 pre 之后。
                    ListNode* t=cur->next;
                    //移除t节点
                    cur->next=t->next;
                    //插入t节点
                    t->next=pre->next;
                    pre->next=t;
                    pre=pre->next;
                    
                }
                else
                    cur=cur->next;
            }
     
            return dump->next;
            
        }
    };

     

    展开全文
  • c/c++实现链表排序

    2011-11-07 16:15:21
    简单实现链表排序,利用图形深入浅出的讲解,涵盖排序遇到很多问题,详细的很,助你轻松理解链表排序
  • C++链表实现归并排序

    2019-09-23 23:02:02
    C++ 链表实现的归并排序 首先是定义和创建两个链表用来排序 typedef int ElemType; typedef struct LNode { ElemType data; struct LNode * next; }LinkNode; void CreateListF(LinkNode * &L, ...
  • C++链表冒泡排序

    千次阅读 2015-07-15 21:23:18
    #include ...//别问我为什么要写链表的冒泡排序,操蛋操蛋操蛋。 struct Node { int data; Node *next; Node(int d = int()) :data(d), next(NULL){} }; class List { public: List(int a[], i
  • (四)C++双向链表排序

    千次阅读 2018-11-09 16:40:10
    C++双向链表排序 建立一个长度为n的带头结点的双向链表,使得该链表中的数据元素递增有序排列。(必须使用双向链表完成,数据类型为整型。) 输入 第一行:双向表的长度; 第二行:链表中的数据元素。 输出 ...
  • c++链表(详解版)

    万次阅读 多人点赞 2019-06-13 16:27:57
    在自学C++的时候,看到好多人都在提链表,于是就自学了一下,看了很多别人的文章,加入了一些自己的理解,做了一下总结
  • C++链表插入排序

    2014-11-14 15:21:13
    #include using namespace std; struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; ListNode *insertionSortList(ListNode *head) { if(head==N
  • C++链表的归并排序

    千次阅读 2014-07-28 11:46:54
    void sort(node* plst,int low,iny high,int *parray)//low与high是闭区间[low,high]{ if(low { int mid=(low+high)/2;...//递归调用左半边链表进行排序 sort(plst,mid+1,high,parray);//递归调用右半边
  • c++链表的实现

    2016-11-26 12:18:25
    c++链表的实现
  • C++ 链表的归并排序

    2017-12-25 18:58:56
    void disp_nodeList(ListNode *p) { while (p!=NULL) { disp(p->val); p = p->next; } }class Solution { public: ListNode* sortList(ListNode* head) { if (head==NULL || hea
  • C++链表还是比较有用的,建表与输出比较容易,排序与插入删除则难一些,我采用的方法是,将要处理的节点依次拿出并放在新的链表中,比较容易理解,也许不是最好的方法,但比交换数据好一点。
  • C++ 链表直接插入排序

    千次阅读 2018-07-24 20:13:51
    //链表直接插入排序 void Sort(LinkList &L) { LinkList p, p1, q, pre; if (L->next != NULL) { p = L->next->next; L->next->next = NULL; while (p != NULL) { pre = L; //pre指向q的前驱 q = ...
  • 冒泡排序链表中使用方法希望可以发代码详细点c++语言中 ..........谢谢
  • 实现C++链表的创建、删除、排序、合并(保持单调不减) 思路: 方法1:如果将两链表头尾相接后再整体排序,复杂度太高。因此可以利用链表已经排好序的特点进行逐步合并。用两个指针p1、p2指向两链表头结点head1、...
  • 使用C++实现双向循环链表的增删改查排序等操作,可查看个人博客的【[数据结构和算法]C/C++双向循环链表实现(增删改查排序)】--链接https://blog.csdn.net/slimmm/article/details/84317806
  • C++链表的建立,排序,删除

    千次阅读 2016-07-17 16:46:22
    描述:使用随机数建立链表节点,节点的结构很简单,就是一个整形数(随机数)和一个指针,有三个函数,第一个函数建立链表,第二个函数对链表进行排序,第三个函数将链表中所有有重复数字的节点删除,只留只出现过一...
  • 下面的资料是关于C++算法之链表排序的代码。 { return; while(curr){ prev = curr; curr = curr->next; insert_for_sort_operation(ppNode, prev); } return; } ...
  • 这是按照链表插入一个最小元素发展而来的排序,练练手。 #include<iostream> using namespace std; struct node{ int data; node*next; }; node*create(int n){ node*head,*tail,*p; head=tail=new node;...
  • C++链表的分类排序

    2015-11-02 13:53:08
    includeusing namespace std; struct linknode { char info; int sub; linknode *next; }; class Link { private: linknode *newnode,*newnode1,*current,*current1,*current2,*current3,*
  • 文章目录链表排序与数组排序的区别借助外部空间冒泡排序插入排序归并排序快速排序 链表排序与数组排序的区别 数组的排序几乎所有人都很熟悉了,常用的算法插入、冒泡、归并以及快排等都会或多或少依赖于数组可以在O...
  • 合并两个排序链表链表)题目描述结果知识点代码 题目描述 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。 结果 运行时间:4ms 占用内存:504k 知识点 指针:...
  • c++链表的使用

    2018-04-26 20:32:24
    c++结构体链表的简单排序,删除,添加等介绍和学习。。。
  • c++链表程序

    2013-01-16 00:03:37
    这个链表是用c++编写的里面实现了链表的各种功能,有增加、删除、查询、排序等一些功能。读懂该代码对于学习链表有很大的帮助。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,142
精华内容 21,656
关键字:

c++链表排序

c++ 订阅