数据结构示例-单向链表元素排序

📌 相关文章

📜 数据结构示例-单向链表元素排序

📅 最后修改于: 2020-10-15 04:49:20 🧑 作者: Mango

程序对单链表的元素进行排序

说明

在此程序中，我们需要按升序对给定单链列表的节点进行排序。

原始清单：

排序列表：

为了完成此任务，我们维护两个指针：current和index。最初，当前指向头节点，索引将指向当前旁边的节点。通过将当前数据与索引数据进行比较，遍历列表直到当前指向null。如果当前数据大于索引数据，则在它们之间交换数据。在上面的示例中，current最初将指向9，index将指向7。由于9大于7，因此交换数据。继续此过程，直到整个列表按升序排序。

算法

创建一个具有两个属性的类Node：data和next。下一个是指向列表中下一个节点的指针。
创建另一个具有两个属性的类SortList：head和tail。
addNode()将向列表添加一个新节点：
1. 创建一个新节点。
2. 它首先检查head是否等于null，这意味着列表为空。
3. 如果列表为空，则头和尾都将指向新添加的节点。
4. 如果列表不为空，则新节点将被添加到列表的末尾，使得尾部的下一个将指向新添加的节点。这个新节点将成为列表的新尾部。
sortList()将按升序对列表的节点进行排序。
1. 定义一个节点电流，该电流将指向头部。
2. 定义另一个节点索引，该索引将指向当前节点旁边的节点。
3. 比较当前节点和索引节点的数据。如果当前数据大于索引数据，则在它们之间交换数据。
4. 当前将指向current.next，索引将指向index.next。
5. 继续此过程，直到对整个列表进行排序。
display()将显示列表中存在的节点：
1. 定义一个节点电流，该电流将初始指向列表的开头。
2. 遍历列表，直到当前指向null。
3. 通过在每次迭代中使电流指向其旁边的节点来显示每个节点。

示例：

Python

#Represent a node of the singly linked list
class Node:
    def __init__(self,data):
        self.data = data;
        self.next = None;
        
class SortList:
    #Represent the head and tail of the singly linked list
    def __init__(self):
        self.head = None;
        self.tail = None;
        
    #addNode() will add a new node to the list
    def addNode(self, data):
        #Create a new node
        newNode = Node(data);
        
        #Checks if the list is empty
        if(self.head == None):
            #If list is empty, both head and tail will point to new node
            self.head = newNode;
            self.tail = newNode;
        else:
            #newNode will be added after tail such that tail's next will point to newNode
            self.tail.next = newNode;
            #newNode will become new tail of the list
            self.tail = newNode;
            
    #sortList() will sort nodes of the list in ascending order
    def sortList(self):
        #Node current will point to head
        current = self.head;
        index = None;
        
        if(self.head == None):
            return;
        else:
            while(current != None):
                #Node index will point to node next to current
                index = current.next;
                
                while(index != None):
                    #If current node's data is greater than index's node data, swap the data between them
                    if(current.data > index.data):
                        temp = current.data;
                        current.data = index.data;
                        index.data = temp;
                    index = index.next;
                current = current.next;
                
    #display() will display all the nodes present in the list
    def display(self):
        #Node current will point to head
        current = self.head;
        if(self.head == None):
            print("List is empty");
            return;
        while(current != None):
            #Prints each node by incrementing pointer
            print(current.data),
            current = current.next;
        print ""
 
sList = SortList();
        
#Adds data to the list
sList.addNode(9);
sList.addNode(7);
sList.addNode(2);
sList.addNode(5);
sList.addNode(4);
 
#Displaying original list
print("Original list: ");
sList.display();

#Sorting list
sList.sortList();
 
#Displaying sorted list
print("Sorted list: ");
sList.display();

输出：

 Original list: 
9 7 2 5 4 
Sorted list: 
2 4 5 7 9

C

#include 
 
//Represent a node of the singly linked list
struct node{
    int data;
    struct node *next;
};    
 
//Represent the head and tail of the singly linked list
struct node *head, *tail = NULL;
 
//addNode() will add a new node to the list
void addNode(int data) {
    //Create a new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    newNode->next = NULL;
    
    //Checks if the list is empty
    if(head == NULL) {
        //If list is empty, both head and tail will point to new node
        head = newNode;
        tail = newNode;
    }
    else {
        //newNode will be added after tail such that tail's next will point to newNode
        tail->next = newNode;
        //newNode will become new tail of the list
        tail = newNode;
    }
}
 
    //sortList() will sort nodes of the list in ascending order
    void sortList() {
        //Node current will point to head
        struct node *current = head, *index = NULL;
        int temp;
        
        if(head == NULL) {
            return;
        }
        else {
            while(current != NULL) {
                //Node index will point to node next to current
                index = current->next;
                
                while(index != NULL) {
                    //If current node's data is greater than index's node data, swap the data between them
                    if(current->data > index->data) {
                        temp = current->data;
                        current->data = index->data;
                        index->data = temp;
                    }
                    index = index->next;
                }
                current = current->next;
            }    
        }
    }
 
//display() will display all the nodes present in the list
void display() {
    //Node current will point to head
    struct node *current = head;
    if(head == NULL) {
        printf("List is empty \n");
        return;
    }
    while(current != NULL) {
        //Prints each node by incrementing pointer
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}
    
int main()
{
    //Adds data to the list
    addNode(9);
    addNode(7);
    addNode(2);
    addNode(5);
    addNode(4);
    
    //Displaying original list
    printf("Original list: \n");
    display();
    
    //Sorting list
    sortList();
    
    //Displaying sorted list
    printf("Sorted list: \n");
    display();
        
    return 0;
}

输出：

Original list: 
9 7 2 5 4 
Sorted list: 
2 4 5 7 9

JAVA

public class SortList {
    
    //Represent a node of the singly linked list
    class Node{
        int data;
        Node next;
        
        public Node(int data) {
            this.data = data;
            this.next = null;
        }
    }
 
    //Represent the head and tail of the singly linked list
    public Node head = null;
    public Node tail = null;
    
    //addNode() will add a new node to the list
    public void addNode(int data) {
        //Create a new node
        Node newNode = new Node(data);
        
        //Checks if the list is empty
        if(head == null) {
            //If list is empty, both head and tail will point to new node
            head = newNode;
            tail = newNode;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            tail.next = newNode;
            //newNode will become new tail of the list
            tail = newNode;
        }
    }
    
    //sortList() will sort nodes of the list in ascending order
    public void sortList() {
        //Node current will point to head
        Node current = head, index = null;
        int temp;
        
        if(head == null) {
            return;
        }
        else {
            while(current != null) {
                //Node index will point to node next to current
                index = current.next;
                
                while(index != null) {
                    //If current node's data is greater than index's node data, swap the data between them
                    if(current.data > index.data) {
                        temp = current.data;
                        current.data = index.data;
                        index.data = temp;
                    }
                    index = index.next;
                }
                current = current.next;
            }    
        }
    }
    
    //display() will display all the nodes present in the list
    public void display() {
        //Node current will point to head
        Node current = head;
        if(head == null) {
            System.out.println("List is empty");
            return;
        }
        while(current != null) {
            //Prints each node by incrementing pointer
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        
        SortList sList = new SortList();
        
        //Adds data to the list
        sList.addNode(9);
        sList.addNode(7);
        sList.addNode(2);
        sList.addNode(5);
        sList.addNode(4);
        
        //Displaying original list
        System.out.println("Original list: ");
        sList.display();
        
        //Sorting list
        sList.sortList();
        
        //Displaying sorted list
        System.out.println("Sorted list: ");
        sList.display();
    }
}

输出：

Original list: 
9 7 2 5 4 
Sorted list: 
2 4 5 7 9

C＃

using System;
                    
public class CreateList
{
    //Represent a node of the singly linked list
    public class Node{
        public T data;
        public Node next;
        
        public Node(T value) {
            data = value;
            next = null;
        }
    }
        
    public class SortList where T : IComparable{
        //Represent the head and tail of the singly linked list
        public Node head = null;             
         public Node tail = null;
    
        //addNode() will add a new node to the list
        public void addNode(T data) {
            //Create a new node
            Node newNode = new Node(data);
 
            //Checks if the list is empty
            if(head == null) {
                //If list is empty, both head and tail will point to new node
                head = newNode;
                tail = newNode;
            }
            else {
                //newNode will be added after tail such that tail's next will point to newNode
                tail.next = newNode;
                //newNode will become new tail of the list
                tail = newNode;
            }
        }
    
        //sortList() will sort nodes of the list in ascending order
        public void sortList() {
            //Node current will point to head
            Node current = head, index = null;
            T temp;
 
            if(head == null) {
                return;
            }
            else {
                while(current != null) {
                    //Node index will point to node next to current
                    index = current.next;
 
                    while(index != null) {
                        //If current node's data is greater than index's node data, swap the data between them
                        if(current.data.CompareTo(index.data) > 0) {
                            temp = current.data;
                            current.data = index.data;
                            index.data = temp;
                        }
                        index = index.next;
                    }
                    current = current.next;
                }    
            }
        }
        
        //display() will display all the nodes present in the list
        public void display() {
            //Node current will point to head
            Node current = head;
            if(head == null) {
                Console.WriteLine("List is empty");
                return;
            }
            while(current != null) {
                //Prints each node by incrementing pointer
                Console.Write(current.data + " ");
                current = current.next;
            }
            Console.WriteLine();
        }
    }
    
    public static void Main()
    {
        SortList sList = new SortList();
        
        //Adds data to the list
        sList.addNode(9);
        sList.addNode(7);
        sList.addNode(2);
        sList.addNode(5);
        sList.addNode(4);
        
        //Displaying original list
        Console.WriteLine("Original list: ");
        sList.display();
        
        //Sorting list
        sList.sortList();
        
        //Displaying sorted list
        Console.WriteLine("Sorted list: ");
        sList.display();
    }
}

输出：

Original list: 
9 7 2 5 4 
Sorted list: 
2 4 5 7 9

PHP：




data = $data;
        $this->next = NULL;
    }
}
class SortList{
    //Represent the head and tail of the singly linked list
    public $head;
    public $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
    }
    
    //addNode() will add a new node to the list
    function addNode($data) {
        //Create a new node
        $newNode = new Node($data);
        
        //Checks if the list is empty
        if($this->head == NULL) {
            //If list is empty, both head and tail will point to new node
            $this->head = $newNode;
            $this->tail = $newNode;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            $this->tail->next = $newNode;
            //newNode will become new tail of the list
            $this->tail = $newNode;
        }
    }
    
    //sortList() will sort nodes of the list in ascending order
    function sortList() {
        //Node current will point to head
        $current = $this->head; 
        $index = null;
        
        if($this->head == null) {
            return;
        }
        else {
            while($current != null) {
                //Node index will point to node next to current
                $index = $current->next;
                
                while($index != null) {
                    //If current node's data is greater than index's node data, swap the data between them
                    if($current->data > $index->data) {
                        $temp = $current->data;
                        $current->data = $index->data;
                        $index->data = $temp;
                    }
                    $index = $index->next;
                }
                $current = $current->next;
            }    
        }
    }
    
    //display() will display all the nodes present in the list
    function display() {
        //Node current will point to head
        $current = $this->head;
        
        if($this->head == NULL) {
            print("List is empty 
");
            return;
        }
        while($current != NULL) {
            //Prints each node by incrementing pointer
            print($current->data . " ");
            $current = $current->next;
        }
        print("
");
    }
}
    
$sList = new SortList();
        
//Adds data to the list
$sList->addNode(9);
$sList->addNode(7);
$sList->addNode(2);
$sList->addNode(5);
$sList->addNode(4);
 
//Displaying original list
print("Original list: 
");
$sList->display();
 
//Sorting list
$sList->sortList();
 
//Displaying sorted list
print("Sorted list: 
");
$sList->display();
?>

输出：

 Original list: 
9 7 2 5 4 
Sorted list: 
2 4 5 7 9