单链表排序

本文详细介绍了使用Java实现链表的插入排序算法过程。通过创建Node和ListNode类,完成链表的构建,并实现插入排序算法对链表进行排序。文章提供了完整的代码示例,包括链表的初始化、数据插入及排序后的输出。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

 下面会有对  链表 的对象的初始化以及数据存入,对链表里的数据进行直接插入排序法排序:

Node 类:

package lianbiao;

public class Node {
	  //链表节点的数据
    int data;

    //链表指向的下一个节点的指针
    Node next = null;

    public Node(int data) {
        this.data = data;
    }
}

ListNode 类:

package lianbiao;

public class ListNode {
        private static int i=1;
	    public static Node getSingleList(){
	        //向节点中添加元素
	    	Node head=new Node(8);
	        Node node1=new Node(7);
	        Node node2=new Node(6);
	        Node node3=new Node(5);
	        Node node4=new Node(4);
	        Node node5=new Node(3);
	        Node node6=new Node(2);
	        Node node7=new Node(1);
	        //指针指向下一个元素
	        head.next=node1;
	        node1.next=node2;
	        node2.next=node3;
	        node3.next=node4;
	        node4.next=node5;
	        node5.next=node6;
	        node6.next=node7;
	        node7.next=null;
	        return head;
	    }

	    public static void printList(Node node){
	    	
	    	if (i==1) {
		    System.out.print("单链表排序前:");
	        while(node!=null){
	            System.out.print(node.data+"-->");
	            node=node.next;
	        }
	        System.out.println();
			}else {
				 System.out.print("单链表排序后:");
			        while(node!=null){
			            System.out.print(node.data+"-->");
			            node=node.next;
			        }
			        System.out.println();
			}
	       i++;
	    }
	}


SortList 类:

package lianbiao;



public class SortList {
	 public static void main(String[] args) {
		   
		    Node head=ListNode.getSingleList();  //得到链表
	        ListNode.printList(head);   //输出排序之前的链表
	        head=insertSortList(head);  //排序链表
	        ListNode.printList(head);  //输出排序完的链表

	       
	    }
	 public static Node insertSortList(Node head) {
	        if(head==null||head.next==null)    return head;
	 
	        Node pre = head;//pre指向已经有序的节点
	        Node cur = head.next;//cur指向待排序的节点
	 
	        Node aux = new Node(-1);//辅助节点
	        aux.next = head;
	 
	        while(cur!=null){
	            if(cur.data<pre.data){
	              //先把cur节点从当前链表中删除,然后再把cur节点插入到合适位置
	                pre.next = cur.next;
	 
	                //从前往后找到l2.val>cur.val,然后把cur节点插入到l1和l2之间
	                Node l1 = aux;
	                Node l2 = aux.next;
	                while(cur.data>l2.data){
	                    l1 = l2;
	                    l2 = l2.next;
	                }
	                //把cur节点插入到l1和l2之间
	                l1.next = cur;
	                cur.next = l2;//插入合适位置
	 
	                cur = pre.next;//指向下一个待处理节点
	 
	            }else{// 如果下一个节点 大于等于当前节点,那么   取消判断, 介殿伟后羿。
	                pre = cur;
	                cur = cur.next;
	            }
	        }
	        return aux.next;
	    }

	

}

 

### 单链表排序实现代码 对于单链表排序问题,一种常见的做是将链表中的值提取到一个数组中进行排序,然后再将排序后的值重新填回链表中。这种方式简单且易于实现,适用于大多数情况。 以下是基于 C++、Java 和 Python 的单链表排序实现: #### C++ 实现 ```cpp struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(nullptr) {} }; class Solution { public: ListNode* sortInList(ListNode* head) { std::vector<int> nums; ListNode* p = head; // 遍历链表,将节点值加入数组 while (p != nullptr) { nums.push_back(p->val); p = p->next; } p = head; // 对数组元素排序 std::sort(nums.begin(), nums.end()); // 遍历数组,将排序后的值依次加入链表 for (int i = 0; i < nums.size(); ++i) { p->val = nums[i]; p = p->next; } return head; } }; ``` #### Java 实现 ```java class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } public class Solution { public ListNode sortInList(ListNode head) { List<Integer> nums = new ArrayList<>(); ListNode p = head; // 遍历链表,将节点值加入列表 while (p != null) { nums.add(p.val); p = p.next; } p = head; // 对列表元素排序 Collections.sort(nums); // 遍历列表,将排序后的值依次加入链表 for (int num : nums) { p.val = num; p = p.next; } return head; } } ``` #### Python 实现 ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def sort_in_list(head): nums = [] p = head # 遍历链表,将节点值加入列表 while p: nums.append(p.val) p = p.next p = head # 对列表元素排序 nums.sort() # 遍历列表,将排序后的值依次加入链表 for num in nums: p.val = num p = p.next return head ``` ### 算分析 - **时间复杂度**:O(n log n),其中 `n` 是链表的长度。排序的时间复杂度主要由排序函数(如 `std::sort`、`Collections.sort` 或 `list.sort()`)决定。 - **空间复杂度**:O(n),因为需要额外的存储空间来保存链表的值。 这种实现方式虽然在空间上不是最优解,但对于大多数应用场景已经足够高效,并且代码逻辑清晰易懂[^1]。 ---
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值