C++链表的建立、删除、排序等操作

链表正向建立

#include <bits/stdc++.h>
using namespace std;
typedef int dataType;

struct node {
    dataType data;
    node *next;
};

node *initnode(int *arr, int n) {
    node *head, *tail, *Nnode;
    for (int i = 0; i < n; i++) {
        Nnode = new node; 
        Nnode->data = arr[i];
        Nnode->next = NULL;
        if (i == 0)
            head = tail = Nnode;
        tail->next = Nnode;
        tail = tail->next;
    }
    return head;
}

void printnode(node *head) {
    for (node *p = head; p != NULL; p = p->next) {
        cout << p->data << ' ';
    }
}

main() {
    int a[6] = {1, 2, 3, 4, 5, 6};
    node *head;
    head = initnode(a, 6);
    printnode(head);
    getchar();
    return 0;
}

链表的逆向建立

node *initnode(int *arr, int n) {
    node *head = NULL, *tail = NULL, *Nnode;
    for (int i = 0; i < n; i++) {
        Nnode = new node;
        Nnode->data = arr[i];
        Nnode->next = head;
        head = Nnode;
    }
    return head;
}

添加链表节点

int value;
cin >> value;
node *Nnode = new node;
Nnode->data = value;
Nnode->next = NULL;
//添加在p节点后面
Nnode->next=Pindex->next;
Pindex->next=Nnode;
//添加在p节点前面
for(node *pre = head; pre && pre->next != Pindex; pre = pre->next);  //找到p节点前面一个节点pre
if(pre){  //如果p节点为头结点，无前向节点
  pre->next=Nnode;
  Nnode->next=Pindex;
}
else{
  Nnode->next=head;
  head=Nnode;
}

链表节点的删除

//查找列表，若找到链表中有相应的值，则标记该节点为P，否则不做处理
node *p = head, *pre = NULL;
    while (p->data != value) { //value为需要删除节点的值
        pre = p;
        p = p->next;
    }
    if (p) {  //若链表中有对应的值
        if (pre) {  //若p不为头结点
            pre->next = p->next;
            delete p;
        } else {  //若p为头结点
            head1 = head->next; 
            delete p;
        }
    }

删除整个链表

node *p = head;
while (p) {
    head = p->next;
    delete p;
    p = head;
}

链表的有序插入

int value;
cin >> value;
//假设链表为升序排序，找到第一个比插入值大的节点p，插入到p节点前面
node *p = head, *pre = NULL;
while (p && p->data < value) {
    pre = p;
    p = p->next;
}
node *Nnode = new node;
Nnode->data = value;  
Nnode->next = NULL;
if (pre) {
    pre->next = Nnode;
    Nnode->next = p;
} 
else {
    Nnode->next = head;
    head = Nnode;
}

链表的选择排序

for (node *pi = head; pi; pi = pi->next) {
    node *pmin = pi;
    for (node *pj = pi->next; pj; pj = pj->next)
        if (pj->data < pmin->data)
            pmin = pj;
    if (pmin != pi) {
        int temp = pi->data;
        pi->data = pmin->data;
        pmin->data = temp;
    }
}

链表的冒泡排序

void bubbleSort(node *&head) {
    for (node *pi = head; pi; pi = pi->next) {
        for (node *pj = head; pj && pj->next; pj = pj->next) {
            if (pj->data > pj->next->data) {  //只交换两个节点的值
                int temp = pj->data; 
                pj->data = pj->next->data;
                pj->next->data = temp;
            }
        }
    }
}