数据结构示例-双向链表中的元素排序

📌 相关文章

📜 数据结构示例-双向链表中的元素排序

📅 最后修改于: 2020-10-15 05:58:50 🧑 作者: Mango

问：程序以排序双向链表的元素。

说明

在此程序中，我们将创建一个双向链接列表，并以升序对列表节点进行排序。

排序列表：

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

算法

定义一个Node类，该类代表列表中的一个节点。它具有三个属性：数据，前一个将指向上一个节点，下一个将指向下一个节点。
定义另一个用于创建双向链接列表的类，它具有两个节点：head和tail。最初，头和尾将指向null。
addNode()将节点添加到列表中：
1. 它首先检查head是否为空，然后将节点插入为head。
2. 头部和尾部都将指向新添加的节点。
3. 头的前一个指针将指向空，而头的下一个指针将指向空。
4. 如果head不为null，则新节点将插入列表的末尾，以使新节点的前一个指针指向尾。
5. 新的节点将成为新的尾巴。尾巴的下一个指针将指向null。
sortList()将按照升序对列表中的节点进行排序。
1. 定义一个节点电流，该电流将指向头部。
2. 定义另一个节点索引，该索引将指向当前节点旁边的节点。
3. 比较当前节点和索引节点的数据。如果当前数据大于索引数据，则在它们之间交换数据。
4. 当前将指向current.next，索引将指向index.next。
5. 继续此过程，直到对整个列表进行排序。
display()将显示列表中存在的所有节点。
1. 定义一个新节点“当前”，该节点将指向头部。
2. 打印current.data直到current指向null。
3. 当前将在每次迭代中指向列表中的下一个节点。

示例：

Python

#Represent a node of doubly linked list
class Node:
    def __init__(self,data):
        self.data = data;
        self.previous = None;
        self.next = None;
        
class SortList:
    #Represent the head and tail of the doubly linked list
    def __init__(self):
        self.head = None;
        self.tail = None;
        
    #addNode() will add a node to the list
    def addNode(self, data):
        #Create a new node
        newNode = Node(data);
        
        #If list is empty
        if(self.head == None):
            #Both head and tail will point to newNode
            self.head = self.tail = newNode;
            #head's previous will point to None
            self.head.previous = None;
            #tail's next will point to None, as it is the last node of the list
            self.tail.next = None;
        else:
            #newNode will be added after tail such that tail's next will point to newNode
            self.tail.next = newNode;
            #newNode's previous will point to tail
            newNode.previous = self.tail;
            #newNode will become new tail
            self.tail = newNode;
            #As it is last node, tail's next will point to None
            self.tail.next = None;
            
    #sortList() will sort the given list in ascending order
    def sortList(self):
        #Check whether list is empty
        if(self.head == None):
            return;
        else:
            #Current will point to head
            current = self.head
            while(current.next != None):
                #Index will point to node next to current
                index = current.next;
                while(index != None):
                    #If current's data is greater than index's data, swap the data of current and index
                    if(current.data > index.data):
                        temp = current.data;
                        current.data = index.data;
                        index.data = temp;
                    index = index.next
                current = current.next
                
    #display() will print out the nodes of 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();
        
dList = SortList();
#Add nodes to the list
dList.addNode(7);
dList.addNode(1);
dList.addNode(4);
dList.addNode(5);
dList.addNode(2);
 
#Displaying original list
print("Original list: ");
dList.display();
 
#Sorting list
dList.sortList();
 
#Displaying a sorted list

print("Sorted list: ");
dList.display();

输出：

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

C

#include 
 
//Represent a node of the doubly linked list

struct node{
    int data;
    struct node *previous;
    struct node *next;
};    
 
//Represent the head and tail of the doubly linked list
struct node *head, *tail = NULL;
 
//addNode() will add a node to the list
void addNode(int data) {
    //Create a new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    
    //If list is empty
    if(head == NULL) {
        //Both head and tail will point to newNode
        head = tail = newNode;
        //head's previous will point to NULL
        head->previous = NULL;
        //tail's next will point to NULL, as it is the last node of the list
        tail->next = NULL;
    }
    else {
        //newNode will be added after tail such that tail's next will point to newNode
        tail->next = newNode;
        //newNode's previous will point to tail
        newNode->previous = tail;
        //newNode will become new tail
        tail = newNode;
        //As it is last node, tail's next will point to NULL
        tail->next = NULL;
    }
}
 
//sortList() will sort the given list in ascending order
void sortList() {
    struct node *current = NULL, *index = NULL;
    int temp;
    //Check whether list is empty
    if(head == NULL) {
        return;
    }
    else {
        //Current will point to head
        for(current = head; current->next != NULL; current = current->next) {
            //Index will point to node next to current
            for(index = current->next; index != NULL; index = index->next) {
                //If current's data is greater than index's data, swap the data of current and index
                if(current->data > index->data) {
                    temp = current->data;
                    current->data = index->data;
                    index->data = temp;
                }
            }
        }
    }
}
 
//display() will print out the nodes of 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()
{
    //Add nodes to the list
    addNode(7);
    addNode(1);
    addNode(4);
    addNode(5);
    addNode(2);
    
    //Displaying original list
    printf("Original list: \n");
    display();
    
    //Sorting list
    sortList();
    
    //Displaying sorted list
    printf("Sorted list: \n");
    display();
 
    return 0;
}

输出：

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

JAVA

public class SortList {
    
    //Represent a node of the doubly linked list

    class Node{
        int data;
        Node previous;
        Node next;
        
        public Node(int data) {
            this.data = data;
        }
    }
    
    //Represent the head and tail of the doubly linked list
    Node head, tail = null;
    
    //addNode() will add a node to the list
    public void addNode(int data) {
        //Create a new node
        Node newNode = new Node(data);
        
        //If list is empty
        if(head == null) {
            //Both head and tail will point to newNode
            head = tail = newNode;
            //head's previous will point to null
            head.previous = null;
            //tail's next will point to null, as it is the last node of the list
            tail.next = null;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            tail.next = newNode;
            //newNode's previous will point to tail
            newNode.previous = tail;
            //newNode will become new tail
            tail = newNode;
            //As it is last node, tail's next will point to null
            tail.next = null;
        }
    }
    
    //sortList() will sort the given list in ascending order
    public void sortList() {
        Node current = null, index = null;
        int temp;
        //Check whether list is empty
        if(head == null) {
            return;
        }
        else {
            //Current will point to head
            for(current = head; current.next != null; current = current.next) {
                //Index will point to node next to current
                for(index = current.next; index != null; index = index.next) {
                    //If current's data is greater than index's data, swap the data of current and index
                    if(current.data > index.data) {
                        temp = current.data;
                        current.data = index.data;
                        index.data = temp;
                    }
                }
            }
        }
    }
    
    //display() will print out the nodes of 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 the pointer.

            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        
        SortList dList = new SortList();
        //Add nodes to the list
        dList.addNode(7);
        dList.addNode(1);
        dList.addNode(4);
        dList.addNode(5);
        dList.addNode(2);
        
        //Displaying original list
        System.out.println("Original list: ");
        dList.display();
        
        //Sorting list
        dList.sortList();
        
        //Displaying sorted list
        System.out.println("Sorted list: ");
        dList.display();
    }
}

输出：

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

C＃

using System; 
namespace DoublyLinkedList 
{                     
    public class Program
    {
        //Represent a node of the doubly linked list

        public class Node{
            public T data;
            public Node previous;
            public Node next;
            
            public Node(T value) {
                data = value;
            }
        }
        
        public class SortList where T : IComparable{
            //Represent the head and tail of the doubly linked list
            protected Node head = null;             
             protected Node tail = null;
            
            //addNode() will add a node to the list
            public void addNode(T data) {
                //Create a new node
                Node newNode = new Node(data);
 
                //If list is empty
                if(head == null) {
                    //Both head and tail will point to newNode
                    head = tail = newNode;
                    //head's previous will point to null
                    head.previous = null;
                    //tail's next will point to null, as it is the last node of the list
                    tail.next = null;
                }
                else {
                    //newNode will be added after tail such that tail's next will point to newNode
                    tail.next = newNode;
                    //newNode's previous will point to tail
                    newNode.previous = tail;
                    //newNode will become new tail
                    tail = newNode;
                    //As it is last node, tail's next will point to null
                    tail.next = null;
                }
            }
            
            //sortList() will sort the given list in ascending order
            public void sortList() {
                Node current = null, index = null;
                T temp;
                //Check whether list is empty
                if(head == null) {
                    return;
                }
                else {
                    //Current will point to head
                    for(current = head; current.next != null; current = current.next) {
                        //Index will point to node next to current
                        for(index = current.next; index != null; index = index.next) {
                            //If current's data is greater than index's data, swap the data of current and index
                            if(current.data.CompareTo(index.data) > 0) {
                                temp = current.data;
                                current.data = index.data;
                                index.data = temp;
                            }
                        }
                    }
                }
            }
 
            //display() will print out the nodes of 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 the pointer.

                    Console.Write(current.data + " ");
                    current = current.next;
                }
                Console.WriteLine();
            }
 
        }
        
        public static void Main()
        {
            SortList dList = new SortList();
            //Add nodes to the list
            dList.addNode(7);
            dList.addNode(1);
            dList.addNode(4);
            dList.addNode(5);
            dList.addNode(2);
 
            //Displaying original list
            Console.WriteLine("Original list: ");
            dList.display();
 
            //Sorting list
            dList.sortList();
 
            //Displaying sorted list
            Console.WriteLine("Sorted list: ");
            dList.display();
        }    
    }
}

输出：

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

PHP：




data = $data;
    }
}
class SortList{
    //Represent the head and tail of the doubly linked list
    public $head;
    public $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
    }
    
    //addNode() will add a node to the list
    function addNode($data){
        //Create a new node
        $newNode = new Node($data);
        
        //If list is empty
        if($this->head == NULL) {
            //Both head and tail will point to newNode
            $this->head = $this->tail = $newNode;
            //head's previous will point to NULL
            $this->head->previous = NULL;
            //tail's next will point to NULL, as it is the last node of the list
            $this->tail->next = NULL;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            $this->tail->next = $newNode;
            //newNode's previous will point to tail
            $newNode->previous = $this->tail;
            //newNode will become new tail
            $this->tail = $newNode;
            //As it is last node, tail's next will point to NULL
            $this->tail->next = NULL;
        }
    }
    
    //sortList() will sort the given list in ascending order
    function sortList() {
        //Check whether list is empty
        if($this->head == NULL) {
            return;
        }
        else {
            //Current will point to head
            for($current = $this->head; $current->next != NULL; $current = $current->next) {
                //Index will point to node next to current
                for($index = $current->next; $index != NULL; $index = $index->next) {
                    //If current's data is greater than index's data, swap the data of current and index
                    if($current->data > $index->data) {
                        $temp = $current->data;
                        $current->data = $index->data;
                        $index->data = $temp;
                    }
                }
            }
        }
    }
    
    //display() will print out the nodes of 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("
");
    }
}
    
$dList = new SortList();
//Add nodes to the list
$dList->addNode(7);
$dList->addNode(1);
$dList->addNode(4);
$dList->addNode(5);
$dList->addNode(2);
 
//Displaying original list
print("Original list: 
");
$dList->display();
 
//Sorting list
$dList->sortList();
 
//Displaying sorted list
print("Sorted list: 
");
$dList->display();
?>

输出：

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