一套编程题 编程题 41-50

41.请用标准C语言实现一个双向循环链表的查找与删除。
typedef struct doublecyclelink{
int key;
struct doublecyclelink *prev;
struct doublecyclelink *next;
}DoubleCycleLinkT;
DoubleCycleLinkT *findKey(DoubleCycleLinkT *link,int key);
遍历整个双向循环链表，将第一个与key值相同的结点移出链表，并返回。
若没有找到则返回NULL。
    DoubleCycleLinkT *findKey(DoubleCycleLinkT *link,int key)
    {
        DoubleCycleLinkT *p;
        p=link->next;
        while (p->next!=link) // 链表结尾
        {
            if (p->key==key) // 查找到key值相同,删除该节点,并返回
            {
                p->prev->next=p->next;
                p->next->prev=p->prev;
                free(p);
                return link;
            }
            else 
              p=p->next; // 否则查找下一节点
         }
        if (p->next == link) 
return NULL; //没找到，返回NULL 
    }

42.打印如下图案，共19行，只能有一个for循环（题目已经提供）
         *
        	 ***
       	     *****
       	    *******
             *********
             ***********
             *************
             ***************
            *****************
            *******************
            *****************
            ***************
            *************
            ***********
            *********
            *******
            *****
             ***
             *
    #include "stdio.h"
    void main()
    {
        for(int i=0;i<19;i++)
        {
            int j=0;
            while (j<19) 
            {
                if (i<=9) 
               {
                    if (j<=9) 
                    {
                        if (i+j>=9) 
                            printf("*");
                        else 
                            printf(" ");
                    }
                    else if (j-i<=9) 
                        printf("*");
                    else 
                        printf(" ");
                }
                else
                {
                     if (j<=9)
                    {
                        if (i-j<=9) 
                            printf("*");
                        else
                            printf(" ");
                    }
                    else if (j+i<=27) 
                        printf("*");
                    else 
                        printf(" ");
                }
                j++;
            }
            printf("\n");
        }
    }


43．编程:  将整数转换成字符串：void itoa(int,char);
例如itoa(-123,s[])则s=“-123”;
 	char* itoa(int value, char* string)
    {
        char tmp[33];
        char* tp = tmp;
        int i;
        unsigned v;
        char* sp;
        // 将值转为正值
        if (value < 0)
            v = -value;
        else
            v = (unsigned)value;
        // 将数转换为字符放在数组tmp中
        while (v)
        {
            i = v % 10;
            v = v / 10;
            *tp++ = i+'0';
        }
        // 将tmp里的字符填入string指针里，并加上负号（如果有） 
        sp = string;
        if (value < 0)
        *sp++ = '-';
        while (tp > tmp)
        *sp++ = *--tp;
        *sp = 0;
        return string;
    }

44.完成下列程序
*
*.*.
*..*..*..
*...*...*...*...
*....*....*....*....*....
*.....*.....*.....*.....*.....*.....
*......*......*......*......*......*......*......
*.......*.......*.......*.......*.......*.......*.......*.......
    #define N 8
    int main()
    {
        int i;
        int j;
        int k;
        for(i=0;i<N;I++)
        {
            for(j=0;j<I+1;J++)
            {
                printf("*");
                for(k=0;k<I;K++)
                    printf(".");
            }
            printf("\n");
        }
        return 0;
    }

45. 实现一个整型链表，支持插入，删除操作（有特殊要求，都是在指定节点后进行操作），并写一个对
链表数据进行降序排序的方法。

// 单链表结构体为
typedef struct LNode 
{
    int data;
    struct LNode *next;
}LNode, *pLinkList;

// 单链表类
class LinkList
{
private:
    pLinkList m_pList;
    int m_listLength;
public:
    LinkList();
    ~LinkList();
    bool InsertAfter(int afternode, int data);//插入
    bool RemoveAfter(int removenode);//删除
    void sort();//排序
};

实现方法
//insert a node after a specified node
bool LinkList::InsertAfter(int afternode, int data)
{
    LNode *pTemp = m_pList;
    int curPos = -1;
    if (afternode > m_listLength ) // 插入点超过总长度
    {
        return false;
    }
    while (pTemp != NULL) // 找到指定的节点
    {
        curPos++;
        if (curPos == afternode) 
            break;
        pTemp = pTemp->next;
    }
    if (curPos != afternode) // 节点未寻到，错误退出
   {
        return false;
    }
    LNode *newNode = new LNode; // 将新节点插入指定节点后
    newNode->data = data;
    newNode->next = pTemp->next;
    pTemp->next = newNode;
    m_listLength++;
    return true;
}

//remove the node after a specified node
bool LinkList::RemoveAfter(int removenode) 
{
    LNode *pTemp = m_pList;
    int curPos=-1;
    if (removenode > m_listLength) // 删除点超过总长度
    {
        return false;
    }

    // 找到指定的节点后一个节点，因为删除的是后一个节点
    while (pTemp != NULL) 
    {
        curPos++;
        if (curPos == removenode+1) 
            break;
        pTemp = pTemp->next;
    }
    if (curPos != removenode) // 节点未寻到，错误退出
    {
        return false;
    }
    LNode *pDel = NULL; // 删除节点
    pDel = pTemp->next;
    pTemp->next = pDel->next;
    delete pDel;
    m_listLength--;
    return true;
}

//sort the linked list to descending order.
void LinkList::sort()
{
    if (m_listLength<=1)
    {
        return;
    }
    LNode *pTemp = m_pList;
    int temp;
    // 选择法排序
    for(int i=0;i<M_LISTLENGTH-1;I++)
    for(int j=i+1;j<M_LISTLENGTH;J++)
    if (pTemp[i].data<PTEMP[J].DATA)
    {
        temp=pTemp[i].data;
        pTemp[i].data=pTemp[j].data;
        pTemp[j].data=temp;
    }
}　

46. 编程实现单链表的插入
Node* InsertNode(Node *Head, int num)
{
    		Node *newNode = new Node;
		newNode->data = num;
		if(!Head)//此时为空链表
		{
			newNode->next = NULL;
			return newNode;
		}
		Node *p = Head;
		Node *q = NULL;//q指向p结点之前的结点
		while(p)//此时寻找位置
		{
			if(p->data < num)
			{
            		q = p;
				p = p->next;
			}
			else//此时找到了位置
				break;
		}
		if(p == Head)//插入到头结点之前
		{
			newNode->next = Head;
			Head = newNode;
		}
		else if(!p)//插入到尾结点之后,此时q指向尾结点
		{
			q->next = newNode;
			newNode->next = NULL;
		}
		else//插入到p结点和q结点之间
		{
			newNode->next = q->next;
			q->next = newNode;
		}
		return Head;
}

47. 编程实现双链表删除结点（注意它和单链表删除结点的情况有所不同）
Node* DoubleLink_DelNode(Node *Head, int num)
{
		Node *p = Head;
		if(!p)
			return NULL;
		while(p)
		{
			if(num != p->data)
		   		p = p->next;
			else
				break;
		}
		if(!p)//没有找到要删除的结点
			return NULL;
		else
		{
			if(p == Head)//此时删除的是头结点
			{
				Head = Head->next;
		   		delete p;
			}
			else if(p->next)//此时删除的是中间结点
			{
				p->prev->next = p->next;
				p->next->prev = p->prev;
				delete p;
			}
			else//删除的是尾结点
			{
				p->prev->next = NULL;
				delete p;
			}
		}
    	     return Head;
}

48. 编程实现双链表的插入
Node* DoubleLink_InsertNode(Node *Head, int num)
{
		Node *newNode = new Node;//初始化产生一个新结点
		newNode->data = num;
		newNode->prev = NULL;
		newNode->next = NULL;
		Node *p = Head;
		Node *q = NULL;
		while(p)
		{
			if(p->data < num)
			{
				q = p;
				p = p->next;
			}
			else
				break;
		}
		if(p == Head)//此时是在头结点之前进行插入
		{
			newNode->next = p;
			p->prev = newNode;
			Head = newNode;
		}
		else if(!p)//在尾结点之后进行插入
		{
			q->next = newNode;
			newNode->prev = q;
		}
		else//在中间进行插入
		{
			p->prev->next = newNode;
			newNode->prev = p->prev;
			newNode->next = p;
			p->prev = newNode;
		}
   		 return Head;
}

49. 如何证明一个表是循环链表
link * p,*q; 
p=head; 
q=p->next; 
while(q&&q->next&&p!=q)  //q or q->next ==NULL时无环， q==q时有环 
{
p=p->next; 
 		q=q->next->next; 
}
if(p==q) 
      cout<<"have ring"; 
else 
     cout<<"no ring";

50. 实现队列的出队与入队
//数据入队列
Node *EnQueue(Node *head, Node **tail, int data)
{
		//创建一个新结点
		Node *p = new Node;
		p->data = data;
		p->next = NULL;
		if(head == NULL)//此时为空队列
		{
        		head = p;
			*tail = p;
		}
		else
		{
			(*tail)->next = p;
			*tail = p;
		}
		return head;
}

//删除头结点
Node* DeQueue(Node *head)
{
    		if(!head)//头结点为空
			return NULL;
		else
		{
			Node *p = head;
			head = head->next;
			delete p;
		}
		return head;
}