单链表之将该单链表中第i个位置的结点插入到第j个位置的节点之前,保持其他结点顺序不变

单链表之将该单链表中第i个位置的结点插入到第j个位置的节点之前，保持其他结点顺序不变
1、题目：
将该单链表中第i个位置的结点插入到第j个位置的节点之前，保持其他结点顺序不变。
输入：链表头结点，i,j
无输出。
eg:
将链表第3个结点插入到头结点之前

InsertNodeIBeforeNodeJ_OK(p1,3,1);

原链表：10->6->8->3->5->7
结果： 8->10->6->3->5->7

2、子函数：

//将单链表中 第i个位置的结点插入到第j个位置之前
//之前错误是原因：因为--形参指针没有用 & 引用，所以，里面的值就一直不变
void InsertNodeIBeforeNodeJ(ListNode* &pHead, int i, int j)//正确 8，10，6，3，5，7  千万注意：& 引用
{
    ListNode *pnode = pHead;

    //寻找第i个结点的位置
    int m = 1;
    while (pnode->next != NULL && m < i - 1)
    {
        pnode = pnode->next;
        m++;
    }
    ListNode *pi_pre = pnode;
    ListNode *pi = pi_pre->next;//找到第i个位置的结点
    ListNode *pi_next = pi->next;

    //第j个结点位置 分支判断执行
    if (j == 1)//第j个结点---头结点
    {
        //执行插入程序
        pi->next = pHead;
        pi_pre->next = pi_next;
        pHead = pi;
    }
    else//第j个结点---除头结点外 其他结点
    {
        //寻找第j个结点位置
        pnode = pHead;
        m = 1;
        while (pnode->next != NULL && m < j - 1)
        {
            pnode = pnode->next;
            m++;
        }
        ListNode *pj_pre = pnode;
        ListNode *pj = pj_pre->next;//找到第j个位置的结点

        //执行插入程序
        pj_pre->next = pi;
        pi->next = pj;
        pi_pre->next = pi_next;
    }
}

3、测试程序

#include<iostream>
using namespace std;

struct ListNode
{
    int data;
    ListNode *next;
};

ListNode* CreateNode(int value)
{
    ListNode *p = new ListNode();
    p->data = value;
    p->next = NULL;
    return p;
}

void ConnecteNodes(ListNode *p1, ListNode *p2)
{
    if (p1 == NULL)//错误代码：  while (p1 == NULL)
        return;
    p1->next = p2;
}

void DispList(ListNode* &p)
{
    if (p == NULL)
        return;
    ListNode *pnode = p;
    while (pnode)
    {
        cout << pnode->data;
        if (pnode->next)
            cout << "->";
        pnode = pnode->next;//  错误代码：pnode = p->next;
    }
    cout << endl;
}
void DestroyList(ListNode *p)
{
    ListNode* pnode = p;
    while (pnode)
    {
        p = p->next;
        delete pnode;
        pnode = p;
    }
}

void InsertSort(int *a, int len)
{
    for (int i = 1; i < len; ++i)
    {
        for (int j = 0; j < i; ++j)
        {
            if (a[j]>a[i])
            {
                int temp = a[i];
                for (int k = i; k>j; --k)
                    a[k] = a[k - 1];

            }
        }
    }
}
//--------------------------------------------------------------------------------------------------
//将单链表中 第i个位置的结点插入到第j个位置之前
//之前错误是原因：因为--形参指针没有用 & 引用，所以，里面的值就一直不变
void InsertNodeIBeforeNodeJ(ListNode* &pHead, int i, int j)//正确 8，10，6，3，5，7  千万注意：& 引用
{
    ListNode *pnode = pHead;

    //寻找第i个结点的位置
    int m = 1;
    while (pnode->next != NULL && m < i - 1)
    {
        pnode = pnode->next;
        m++;
    }
    ListNode *pi_pre = pnode;//第i-1个结点的位置
    ListNode *pi = pi_pre->next;//找到第i个位置的结点
    ListNode *pi_next = pi->next;//第i+1个结点的位置

    //第j个结点位置 分支判断执行
    if (j == 1)//第j个结点---头结点
    {
        //执行插入程序
        pi->next = pHead;//step1:第i个结点的下一个指针指向头结点
        pi_pre->next = pi_next;//step2:第i-1个结点的下一个指针 指向 原第i+1个结点
        pHead = pi;//step3:头指针指向第i个结点：第i个结点成为了新的头结点
    }
    else//第j个结点---除头结点外 其他结点
    {
        //寻找第j个结点位置
        pnode = pHead;
        m = 1;
        while (pnode->next != NULL && m < j - 1)
        {
            pnode = pnode->next;
            m++;
        }
        ListNode *pj_pre = pnode;
        ListNode *pj = pj_pre->next;//找到第j个位置的结点

        //执行插入程序
        pj_pre->next = pi;//step1:第i-1个结点的下一个指针 指向 原第i个结点
        pi->next = pj;//step2:第i个结点的下一个指针指向 第j个结点
        pi_pre->next = pi_next;//step3:第i-1个结点的下一个指针 指向 原第i+1个结点
    }
}
//--------------------------------------------------------------------------------------------------
void test8_OK()
{
    cout << "---test8_OK----InsertNodeIBeforeNodeJ()----------" << endl;

    ListNode *p1 = CreateNode(10);
    ListNode *p2 = CreateNode(6);
    ListNode *p3 = CreateNode(8);
    ListNode *p4 = CreateNode(3);
    ListNode *p5 = CreateNode(5);
    ListNode *p6 = CreateNode(7);

    ConnecteNodes(p1, p2);
    ConnecteNodes(p2, p3);
    ConnecteNodes(p3, p4);
    ConnecteNodes(p4, p5);
    ConnecteNodes(p5, p6);

    DispList(p1);//10->6->8->3->5->7
    InsertNodeIBeforeNodeJ(p1, 3, 1);
    cout << "InsertNodeIBeforeNodeJ(p1, 3, 1);" << endl;
    DispList(p1);//8->10->6->3->5->7
    DestroyList(p1);
}
void test()
{
    cout << "---test----InsertNodeIBeforeNodeJ()----------" << endl;

    ListNode *p1 = CreateNode(10);
    ListNode *p2 = CreateNode(6);
    ListNode *p3 = CreateNode(8);
    ListNode *p4 = CreateNode(3);
    ListNode *p5 = CreateNode(5);
    ListNode *p6 = CreateNode(7);

    ConnecteNodes(p1, p2);
    ConnecteNodes(p2, p3);
    ConnecteNodes(p3, p4);
    ConnecteNodes(p4, p5);
    ConnecteNodes(p5, p6);

    DispList(p1);//10->6->8->3->5->7
    InsertNodeIBeforeNodeJ(p1, 5, 2);
    cout << "InsertNodeIBeforeNodeJ(p1, 5, 2);" << endl;
    DispList(p1);//10->5->6->8->3->7
    DestroyList(p1);
}

int main()
{
    test();
    test8_OK();
    return 0;
}

单链表 之 将该单链表中第i个位置的结点插入到第j个位置的节点之前,保持其他结点顺序不变

猜你喜欢

单链表之将该单链表中第i个位置的结点插入到第j个位置的节点之前,保持其他结点顺序不变