基数计数排序+单链表

计数排序

基数排序

单链表

 

 

计数排序（时间复杂度，O(N) ）

void countSort(int array[],int range ,int len)
{
    //range是取值范围,假设0到10内，是11个下标，所以range+1
    vector<int>arr(range+1,0);
    for (int i = 0; i < len; i++)
    {
        arr[array[i]]++;
    }
    for (int i = 0,j = 0; i <range+1; i++)
    {
        while (arr[i]-- > 0)
        {
            array[j++] = i;
        }
    }
}

 

基数排序（时间复杂度，O(N) ）后期补解析

static int maxbits(int array[],int len)
{
    int max = -1;
    for (int i = 0; i < len; i++)
    {
        max = max > array[i] ? max : array[i];
    }
    int res = 0;
    while (max != 0)
    {
        res++;
        max /= 10;
    }
    return res;
}

static int getDigit(int x, int d)
{
    return ((x / ((int)pow(10, d - 1))) % 10);
}

static void radixSort(int array[], int begin, int end, int digit)
{
    int radix = 10;
    int i = 0, j = 0;
    vector<int>bucket(end - begin + 1);
    for (int d = 1; d <= digit; d++)
    {
        vector<int>count(radix);
        for (i = begin; i <= end; i++)
        {
            j = getDigit(array[i], d);
            count[j]++;
        }
        for (i = 1; i < radix; i++)
        {
            count[i] = count[i] + count[i - 1];
        }
        for (i = end; i >= begin; i--)
        {
            j = getDigit(array[i], d);
            bucket[count[j] - 1] = array[i];
            count[j]--;
        }
        for (i = begin, j = 0; i <= end; i++, j++)
        {
            array[i] = bucket[j];
        }
    }
}

void radixSort(int array[], int len)
{
    if (array == NULL || len < 2)
    {
        return;
    }
    radixSort(array, 0, len - 1, maxbits(array,len));
}

 

 

 

单链表

基础创建，增加，删除

typedef struct LNode {
    int data;
    LNode *next;
}LNode,*LinkList;

int ListInsert(LinkList &L, int i, int e)
{
    LinkList p=L;
    int j = 0;
    while(p&&j < e)
    {
        p = p->next;
        j++;
    }
    if (!p || j > i - 1)
    {
        return -1;
    }
    LinkList s = (LinkList)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return 1;
}

int ListDelete(LinkList &L, int i, int &e)
{
    LinkList p = L;
    int j = 0;
    while (p&&j < i)
    {
        p = p->next;
        j++;
    }
    if (!p || j > i - 1)
    {
        return -1;
    }
    LinkList q = p->next;
    p->next = q->next;
    e = q->data;
    delete[] q;
    return e;
}
//尾插法
void CreatList(LinkList &L, int n)
{
    LinkList p,q;
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    q = L;
    for (int i = n; i > 0; i--)
    {
        p = (LinkList)malloc(sizeof(LNode));
        cin >> p->data;
        p->next = NULL;
        q->next = p;
        q = q->next;
    }
}

 

单链表逆序

方法一： 

利用一个栈来完成逆序，先进后出原则。

先把链表每个值压入栈中，然后再出栈回填到链表中，完成逆序。

void reserseList(LinkList &L)
{
    LinkList p = L;
    stack<int>s;
    while (p->next != NULL)
    {
        p = p->next;
        s.push(p->data);
    }
    p = L;
    while (p->next != NULL)
    {
        p = p->next;
        p->data = s.top();
        s.pop();
    }
}

 

方法二：

 不借助额外空间进行逆序

LinkList reverseList(LinkList &L)
{
    LinkList pre = NULL;
    LinkList next = NULL;
    LinkList p = L;
    while (p != NULL)
    {
        next = p->next;
        p->next = pre;
        pre = p;
        p = next;
    }
    return pre;
}

 

单链表回文数判断

方法一：

额外空间复杂度O(N) ，用栈来做

bool isPalindrome(LinkList &L)
{
    LinkList p = L;
    stack<int>s;
    while (p->next != NULL)
    {
        p = p->next;
        s.push(p->data);
    }
    p = L;
    while (p->next != NULL)
    {
        p = p->next;
        if (p->data != s.top())
        {
            return false;
        }
        s.pop();
    }
    return true;
}

 

方法二：

优化方法一，额外空间复杂度O(N/2)，也是用栈实现的。

主要思想是，用快慢指针法，p是一次走两步，right一次走一步，p先到末尾，right这个时候在中间的位置

在跳指针的时候，就用栈来存储从第一个结点到中间结点的值，然后再出栈跟中间结点到末尾结点之间的值来做比较

bool isPalindrome2(LinkList L)
{
    if (L == NULL || L->next == NULL)
    {
        return true;
    }
    LinkList right = L->next;
    LinkList p = L->next;
    stack<int>s;
    while (p->next != NULL && p->next->next != NULL)
    {
        s.push(right->data);
        right = right->next;
        p = p->next->next;
    }
    while (!s.empty())
    {
        right = right->next;
        if (right->data != s.top())
        {
            return false;
        }
        s.pop();
    }
    return true;
}

 

 方法三：

不使用额外空间来进行的操作，额外空间复杂度O(1)

主要思想，使用快排指针进行操作，将整段链表看成3个部分，begin  Mid  end

定义两个链表的指针，慢指针n1步长为1，快指针n2步长为2。当n2到达尾部的时候，n1同时到达中部。

接着将中部到尾部的链表逆序，逆序完成之后，n1变成了尾部的结点，n2变成了首部的结点。

然后一个从前往后，一个从后往前，进行比较。

bool isPalindrome3(LinkList L)
{
    if (L == NULL || L->next == NULL)
    {
        return true;
    }
    LinkList n1 = L->next;
    LinkList n2 = L->next;
    while (n2->next != NULL && n2->next->next != NULL)
    {
        n1 = n1->next;//n1 变成 mid
        n2 = n2->next->next;//n2 变成 end
    }
    n2 = n1->next;//n2变成右边第一个结点
    n1->next = NULL;//mid->next = NULL
    LinkList n3 = NULL;
    
    while (n2 != NULL)//将右边反转
    {
        n3 = n2->next;
        n2->next = n1;
        n1 = n2;
        n2 = n3;
    }//n2=NULL，n1 = 最后一个位置，n3=NULL
    n3 = n1;//保存最后一个结点
    n2 = L->next;//n2等于首节点
    bool res = true;
    while (n1 != NULL && n2 != NULL)
    {
        if (n1->data != n2->data)
        {
            res = false;
            break;
        }
        n1 = n1->next;//R->mid
        n2 = n2->next;//L->mid
    }
    n1 = n3->next;
    n3->next = NULL;
    while (n1 != NULL)
    {
        n2 = n1->next;
        n1->next = n3;
        n3 = n1;
        n1 = n2;
    }
    return res;
}

 

单链表类似于荷兰国旗问题

【题目】给定一个单链表的头节点head，节点的值类型是整型，再给定一个整 数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于pivot的 节点，中间部分都是值等于pivot的节点，右部分都是值大于pivot的节点。 

方法一：

额外空间复杂度O(N)。

主要思想：

用一个容器vector来装单链表每个结点的值。

然后对vector进行partition，最后把vector容器中的值给单链表中替换掉

void listPartition(LinkList &L)
{
    LinkList p = L->next;
    vector<int>array;
    while (p != NULL)
    {
        array.push_back(p->data);
        p = p->next;
    }
    //判断小于等于大于5
    arrPartition(array, 5);
    p = L->next;
    int i = 0;
    while (p != NULL)
    {
        p->data = array[i++];
        p = p->next;
    }
}
void arrPartition(vector<int>&array, int pivot)
{
    int small = -1;
    int big = array.size();
    int index = 0;
    while (index != big)
    {
        if (array[index] < pivot)
        {
            Swap(array, ++small, index++);
        }
        else if (array[index] == pivot)
        {
            index++;
        }
        else {
            Swap(array, --big, index);
        }
    }
}
void Swap(vector<int>&array, int i, int j)
{
    int temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

 

方法二：

额外空间复杂度O(1)

定义6个额外空间变量，H代表头，T代表尾，s，e，b 分别对应小于部分，等于部分，大于部分，例如sT小于部分头结点

再定义一个next变量，用来指向下一个结点

首先全部置为空，p指针指向这个链表第一个位置

然后分别3个if语句的判断，看这个p的值是小于这个设定的pivot还是等于或者大于这个pivot

以小于为例，如果小于这个pivot，那么开始判断，这个小于部分是否为空，如果为空，说明这个p的值是第一个小于部分的值

如果不为空，说明小于部分已经有值了，那么就进行尾插操作，尾插到上一个小于部分结点的后面。

等于和大于的操作跟小于的一样，就是结点不同。

当以上操作都执行完了之后，再来开始边界考虑

先来看小于区域存不存在，如果存在，就把小于区域的尾部跟跟等于区域的头部连接起来。

然后再来判断等于部分有没有值，如果有值就不变，如果没值就把等于区域的尾结点跟小于区域的尾结点连接起来

最后来连接大于区域，先判断等于区域是否存在，如果存在就直接把等于区域的尾结点指向大于区域头结点。

函数末尾返回值，判断小于区域是否存在，如果存在就返回小于区域头结点。如果不存在就看等于区域存不存在，等于区域存在就返回等于区域头结点，如果等于区域也不存在就直接返回大于区域头结点

LinkList listPartition2(LinkList &L, int pivot)
{
    LinkList sH = NULL;
    LinkList sT = NULL;
    LinkList eH = NULL;
    LinkList eT = NULL;
    LinkList bH = NULL;
    LinkList bT = NULL;
    LinkList next = NULL;
    LinkList p = L->next;
    while (p != NULL)
    {
        next = p->next;
        p->next = NULL;
        if (p->data < pivot)
        {
            if (sH == NULL)
            {
                sH = p;
                sT = p;
            }
            else {
                sT->next = p;
                sT = p;
            }
        }
        else if (p->data == pivot)
        {
            if (eH == NULL)
            {
                eH = p;
                eT = p;
            }
            else {
                eT->next = p;
                eT = p;
            }
        }
        else if (p->data > pivot)
        {
            if (bH == NULL)
            {
                bH = p;
                bT = p;
            }
            else {
                bT->next = p;
                bT = p;
            }
        }
        p = next;
    }
    if (sT != NULL)
    {
        sT->next = eH;
        eT = eT == NULL ? sT : eT;
    }
    if (eT != NULL)
    {
        eT->next = bH;
    }
    return sH != NULL ? sH : eH != NULL ? eH : bH;
}