c 链表交换节点的排序

#include <stdio.h>

typedef struct listnode
{
    int f;
    struct listnode *next;
} ListNode;

ListNode *sort(ListNode *head)
{
    ListNode *p,*p1,*p2,*p3;
    ListNode h, t;
    if (head == NULL) return NULL;
    h.next=head;
    p=&h;
    while (p->next!=NULL)
    {
        p=p->next;
    }
    p=p->next=&t;
    while (p!=h.next)
    {
        p3=&h;
        p1=p3->next;
        p2=p1->next;
        while (p2!=p)
        {
            if ((p1->f)>(p2->f))
            {
                p1->next=p2->next;
                p2->next=p1;
                p3->next=p2;

                p3=p2;
                p2=p1->next;

            } else {
                p3=p1;
                p1=p2;
                p2=p2->next;
            }
        }
        p=p1;
    }
    while (p->next!=&t)
    {
        p=p->next;
    }
    p->next=NULL;
    return h.next;
}

int main() {
    ListNode h,j,k,l;
    h.next=&j;
    h.f=3;
    j.next=&k;
    j.f=5;
    k.next=&l;
    k.f=1;
    l.next=NULL;
    l.f=7;
    ListNode* p = sort(&h);
    while (p != NULL) {
        printf("%d ", p->f);
        p=p->next;
    }
    printf("\n");
    return 0;
}

  

void sort1(ListNode *head)
{
	ListNode *p, *q, *pt;
	p = head;
	q = p->next;

	while(p->next != NULL)
	{
		while(q->next != NULL)
		{
			if (p->next->f > q->next->f)
			{
				pt = p->next;
				p->next = q->next;
				q->next = p->next->next;

				p->next->next = pt;
			}
			else
				q = q->next;
		}
		p = p->next;
		q = p->next;
	}
}

  

时间: 2024-10-29 20:03:05

c 链表交换节点的排序的相关文章

链表的基本排序

选择排序:链表的选择排序和一般的选择排序基本思路上是一样的,只是对于链表而言,他的指针不一样 遍历链表,每次找出一个最小的节点,将其值与未排序节点的首个节点交换,这里需要一个指针标记值最小的节点. Node *SelectSort( Node *L ){ Node *p, *q, *small; int temp; for( p = L->next; p->next != NULL; p = p->next )    /*每次循环都找出一个最小值,将最小值交换到第一位,然后将指针向后移动

算法总结之 单链表的选择排序

给定一个无序单链表的头节点head,实现单链表的选择排序 要求额外空间复杂度O(1) 思路: 既然额外空间复杂度O(1),就不能把链表装进容器,排好序后再从新链接,而是要求面试者在原链表上利用有限几个变量完成选择排序的过程. 选择排序是从未排序的部分找到最小值,然后放到排好序部分的尾部. 1 开始时默认真个链表都是未排序的部分,对于找到的最小值节点肯定是整个链表的最小值节点,将其设置为新的头节点记:newHead 2 每次在排序的部分中找到最小值的节点,然后哦把这个节点从未排序的链表删除,删除的

揭开链表逆转和排序的面纱

我们都知道,对于顺序表逆转和排序就如同数组一样,将数据改变位置就行,因为他们的数据是连续的空间存储的,但是对于链表如果你也这样只改变值进行排序,那你就太不懂链表的心了,链表的特点就是动态开辟游离的空间然后依据上一个节点所存的地址来寻找下一个节点,这样使得位置这个概念在链表里显得太不重要,所以对于链表我们如果想要逆转或者排序就是要改变每个节点里面存储的地址,通俗一点就是要改变指针的指向,于是我找到了一种将所有链表逆转和排序的统一算法: (这里所说链表全是带有头节点链表) 简述算法步骤:1.将链表的

[程序员代码面试指南]链表问题-单链表的选择排序(选择排序)

题意 给定一个无序单链表的头节点head,实现单链表的选择排序. 题解 按选择排序方法:每次从原链表找出最小值,从原链表删除,插入新的有序链表. 时间复杂度O(n^2) 额外空间复杂度O(1) 代码 public class Main { public static void main(String args[]) { Node n1=new Node(2); Node n2=new Node(1); Node n3=new Node(3); n1.next=n2; n2.next=n3; No

148:Sort List【链表】【排序】

题目链接:https://leetcode.com/problems/sort-list/ /*题意:对链表进行排序*/ /** *思路:归并排序 * 分治:将链表分成两段:用slow和fast指针,slow每次只走一步,fast每次 * 走两步.当fast为空时,slow所在位置就是链表中间. * 合并:两个简单的链表的合并 */ class Solution { public: void show(ListNode *head) { while(head != NULL) { cout <<

链表操作 -- 未排序链表的处理问题

问题: 删除未排序链表中的重复元素. 解答: 1)最朴素的方法就是将链表排序,然后遍历并删除其中的重复元素.这种方法的时间复杂度依赖于排序的过程. 在此,我们要思考一下,找到并且删除链表中的重复元素真的需要排序过程吗? 2)如何才能在不排序的情况下找到重复元素? 最朴素的方法就是处理每个节点的时候,遍历剩余的节点,查看其中是否有重复的元素.这种方法的时间复杂度较高,O(n2). 有没有更好的算法或是数据结构来帮助我们降低这个时间复杂度?这种查找某个元素的存在性问题,可以借助于hash表来快速的实

C语言实现单向链表及其各种排序(含快排,选择,插入,冒泡)

#include<stdio.h> #include<malloc.h> #define LEN sizeof(struct Student) struct Student //结构体声明 { long num; int score; struct Student* next; }; int n; struct Student* creat() //创建单向链表 { struct Student *head=NULL, *p_before, *p_later; p_before =

「10.28」Dove 打扑克(链表)&#183;Cicada 与排序(概率)&#183;Cicada 拿衣服(各种数据结构)

A. Dove 打扑克 考场思考半天线段树树状数组,没有什么想法 打完暴力后突然想到此题用链表实现会很快. 因为只有$n$堆,所以设最多有$x$个不同的堆数,那么$x\times (x-1)/2==n$, 所以链表中最多有$\sqrt{n}$个元素, 所以可以用一个$set$维护当前的出现元素,每次$upper\_bound$找到合适位置插入链表, 因为当前元素有序所以可以统计链表后缀来求答案 知识点: 不要在T1花太长时间,数据结构题可能只用到一些简单数据结构 B. Cicada 与排序 很好

【LeetCode链表】删除排序链表中的重复元素 II

题目描述 给定一个排序链表,删除所有含有重复数字的节点,只保留原始链表中 没有重复出现 的数字. 示例: 输入: 1->2->3->3->4->4->5 输出: 1->2->5 题目链接:https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/ 做这题之前,可以先做删除排序链表中的重复元素,题解. 思路 这题是<剑指Offer>上的一道题.我们需要保存3个指针: